From 04373d4d73dc1620e5a62d82c77e2bf4e9fa136d Mon Sep 17 00:00:00 2001 From: Bijal Chudasama Date: Sat, 11 Mar 2023 18:28:38 +0200 Subject: [PATCH 01/31] weights of evidence for predictive mapping --- .vscode/settings.json | 7 + eis_toolkit/exceptions.py | 10 + .../weights_of_evidence/basic_calculations.py | 62 ++ .../calculate_responses.py | 42 ++ .../weights_of_evidence/calculate_weights.py | 60 ++ .../generalized_weights.py | 29 + .../weights_of_evidence/post_probabilities.py | 98 +++ .../weights_of_evidence/save_weights.py | 49 ++ .../prediction/weights_of_evidence/weights.py | 87 +++ .../weights_of_evidence/weights_arrays.py | 80 +++ .../weights_calculations.py | 64 ++ .../weights_generalizations.py | 102 ++++ .../weights_of_evidence/weights_type.py | 54 ++ notebooks/weights_of_evidence.ipynb | 576 ++++++++++++++++++ tests/data/remote/wofe/Merged_Ascending_.tif | Bin 0 -> 13496 bytes .../remote/wofe/Merged_Ascending_.tif.aux.xml | 59 ++ tests/data/remote/wofe/Merged_Descending_.tif | Bin 0 -> 13496 bytes .../wofe/Merged_Descending_.tif.aux.xml | 59 ++ tests/data/remote/wofe/Merged_Unique.tif | Bin 0 -> 13496 bytes .../remote/wofe/Merged_Unique.tif.aux.xml | 59 ++ tests/data/remote/wofe/Merged_pprbs.tif | Bin 0 -> 13496 bytes tests/data/remote/wofe/exp_wgts_asc.csv | 9 + tests/data/remote/wofe/exp_wgts_dsc.csv | 9 + tests/data/remote/wofe/exp_wgts_un.csv | 9 + tests/data/remote/wofe/wofe_dep_nan_.tif | Bin 0 -> 3008 bytes .../remote/wofe/wofe_dep_nan_.tif.aux.xml | 17 + tests/data/remote/wofe/wofe_dep_nan_.tif.ovr | Bin 0 -> 258 bytes .../remote/wofe/wofe_dep_nan_.tif.vat.cpg | 1 + .../remote/wofe/wofe_dep_nan_.tif.vat.dbf | Bin 0 -> 158 bytes tests/data/remote/wofe/wofe_dep_nan_.tif.xml | 2 + tests/data/remote/wofe/wofe_ev_nan.tfw | 6 + tests/data/remote/wofe/wofe_ev_nan.tif | Bin 0 -> 4034 bytes .../data/remote/wofe/wofe_ev_nan.tif.aux.xml | 30 + tests/data/remote/wofe/wofe_ev_nan.tif.ovr | Bin 0 -> 474 bytes tests/data/remote/wofe/wofe_ev_nan.tif.xml | 2 + tests/wofe_calculate_responses_test.py | 46 ++ tests/wofe_weights_calculations_test.py | 47 ++ 37 files changed, 1675 insertions(+) create mode 100644 .vscode/settings.json create mode 100644 eis_toolkit/prediction/weights_of_evidence/basic_calculations.py create mode 100644 eis_toolkit/prediction/weights_of_evidence/calculate_responses.py create mode 100644 eis_toolkit/prediction/weights_of_evidence/calculate_weights.py create mode 100644 eis_toolkit/prediction/weights_of_evidence/generalized_weights.py create mode 100644 eis_toolkit/prediction/weights_of_evidence/post_probabilities.py create mode 100644 eis_toolkit/prediction/weights_of_evidence/save_weights.py create mode 100644 eis_toolkit/prediction/weights_of_evidence/weights.py create mode 100644 eis_toolkit/prediction/weights_of_evidence/weights_arrays.py create mode 100644 eis_toolkit/prediction/weights_of_evidence/weights_calculations.py create mode 100644 eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py create mode 100644 eis_toolkit/prediction/weights_of_evidence/weights_type.py create mode 100644 notebooks/weights_of_evidence.ipynb create mode 100644 tests/data/remote/wofe/Merged_Ascending_.tif create mode 100644 tests/data/remote/wofe/Merged_Ascending_.tif.aux.xml create mode 100644 tests/data/remote/wofe/Merged_Descending_.tif create mode 100644 tests/data/remote/wofe/Merged_Descending_.tif.aux.xml create mode 100644 tests/data/remote/wofe/Merged_Unique.tif create mode 100644 tests/data/remote/wofe/Merged_Unique.tif.aux.xml create mode 100644 tests/data/remote/wofe/Merged_pprbs.tif create mode 100644 tests/data/remote/wofe/exp_wgts_asc.csv create mode 100644 tests/data/remote/wofe/exp_wgts_dsc.csv create mode 100644 tests/data/remote/wofe/exp_wgts_un.csv create mode 100644 tests/data/remote/wofe/wofe_dep_nan_.tif create mode 100644 tests/data/remote/wofe/wofe_dep_nan_.tif.aux.xml create mode 100644 tests/data/remote/wofe/wofe_dep_nan_.tif.ovr create mode 100644 tests/data/remote/wofe/wofe_dep_nan_.tif.vat.cpg create mode 100644 tests/data/remote/wofe/wofe_dep_nan_.tif.vat.dbf create mode 100644 tests/data/remote/wofe/wofe_dep_nan_.tif.xml create mode 100644 tests/data/remote/wofe/wofe_ev_nan.tfw create mode 100644 tests/data/remote/wofe/wofe_ev_nan.tif create mode 100644 tests/data/remote/wofe/wofe_ev_nan.tif.aux.xml create mode 100644 tests/data/remote/wofe/wofe_ev_nan.tif.ovr create mode 100644 tests/data/remote/wofe/wofe_ev_nan.tif.xml create mode 100644 tests/wofe_calculate_responses_test.py create mode 100644 tests/wofe_weights_calculations_test.py diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000..9b388533 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,7 @@ +{ + "python.testing.pytestArgs": [ + "tests" + ], + "python.testing.unittestEnabled": false, + "python.testing.pytestEnabled": true +} \ No newline at end of file diff --git a/eis_toolkit/exceptions.py b/eis_toolkit/exceptions.py index 573d1096..9bc3fbc8 100644 --- a/eis_toolkit/exceptions.py +++ b/eis_toolkit/exceptions.py @@ -60,3 +60,13 @@ class InvalidColumnIndexException(Exception): """Exception error for index out of range.""" pass + +class UnFavorableClassDoesntExistException(Exception): + """Exception error class for failure to generalize classes using the given studentised contrast threshold value. Class 1 (unfavorable class) doesn't exist""" + + pass + +class FavorableClassDoesntExistException(Exception): + """Exception error class for failure to generalize classes using the given studentised contrast threshold value. Class 2 (favorable class) doesn't exist""" + + pass \ No newline at end of file diff --git a/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py b/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py new file mode 100644 index 00000000..2baa6ac1 --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py @@ -0,0 +1,62 @@ +"""Basic calculations""" + +import pandas as pd +import rasterio +import numpy as np + + +def _basic_calculations( + ev_rst: rasterio.io.DatasetReader, + dep_rst: rasterio.io.DatasetReader +) -> pd.DataFrame: + + geol, dep_ar = np.array(ev_rst.read(1)), np.array(dep_rst.read(1)) + tot_pxls = np.size(geol) - np.count_nonzero(geol <= -1000000000) + dep1s, dep0s = np.count_nonzero(dep_ar == 1), np.count_nonzero(dep_ar == 0) + d_flat, g_flat = dep_ar.flatten(), geol.flatten() + df_flt = pd.DataFrame({"Clss": g_flat, "Ds": d_flat}) + Geol_Dep = df_flt.groupby("Clss")["Ds"] + Geol_Unq = np.unique(g_flat) + Geol_Cnt, Geol_Dep_Sum = Geol_Dep.count(), Geol_Dep.sum() + Geol_NoDep = Geol_Dep.count() - Geol_Dep.sum() + + calc_df = pd.DataFrame( + {"Class": Geol_Unq, "Count": Geol_Cnt, + "Point_Count": Geol_Dep_Sum, + "No_Dep_Cnt": Geol_NoDep, "Total_Area": tot_pxls, + "Total_Deposits": dep1s, "Tot_No_Dep_Cnt": dep0s + } + ) + + cols = ['Class', 'Count', 'Point_Count', 'No_Dep_Cnt', + 'Total_Area', 'Total_Deposits', 'Tot_No_Dep_Cnt'] + # replace_cols = ['Class', 'Count', 'Point_Count', 'No_Dep_Cnt', 'Total_Area', + # 'Total_Deposits', 'Tot_No_Dep_Cnt', 'Dep_outsidefeat', 'Non_Feat_Non_Dep'] + + return (calc_df + [cols] + .assign(Dep_outsidefeat=lambda calc_df: calc_df.Total_Deposits - calc_df.Point_Count) + .assign(Non_feat_Pxls=lambda calc_df: calc_df.Total_Area - calc_df.Count) + .assign(Non_Feat_Non_Dep=lambda calc_df: calc_df.Non_feat_Pxls - calc_df.Dep_outsidefeat) + # [replace_cols].replace({0: 0.0001, 1: 1.0001}), #FIX THIS? + ) + + +def basic_calculations( + ev_rst: rasterio.io.DatasetReader, + dep_rst: rasterio.io.DatasetReader +) -> pd.DataFrame: + """Performs basic calculations about the number of point pixels per class of the input raster. + + Args: + ev_rst (rasterio.io.DatasetReader): The evidential raster. + dep_rst (rasterio.io.DatasetReader): Deposit raster + + Returns: + basic_clcs (pandas.DataFrame): dataframe with basic calculations. + + Raises: None + + """ + basic_clcs = _basic_calculations(ev_rst, dep_rst) + return basic_clcs diff --git a/eis_toolkit/prediction/weights_of_evidence/calculate_responses.py b/eis_toolkit/prediction/weights_of_evidence/calculate_responses.py new file mode 100644 index 00000000..6c665d24 --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/calculate_responses.py @@ -0,0 +1,42 @@ +from eis_toolkit.prediction.weights_of_evidence.post_probabilities import prior_odds, extract_arrays, pprb, pprb_stat +import rasterio +from typing import Tuple, List +import numpy as np + + +def _calculate_responses( + dep_rst: rasterio.io.DatasetReader, + rasters_gen: List +) -> Tuple[np.ndarray, np.ndarray, np.ndarray, dict]: + rstr_meta = dep_rst.meta.copy() + prior_odds_, inv_dep1s = prior_odds(dep_rst) + gen_wgts_sum, var_gen_sum = extract_arrays(rasters_gen) + pprb_array = pprb(gen_wgts_sum, prior_odds_) + pprb_std, pprb_conf = pprb_stat(inv_dep1s, pprb_array, var_gen_sum) + return pprb_array, pprb_std, pprb_conf, rstr_meta + + +def calculate_responses( + dep_rst: rasterio.io.DatasetReader, + rasters_gen: List +) -> Tuple[np.ndarray, np.ndarray, np.ndarray, dict]: + """Calculates the posterior probability for presence of the targeted mineral deposit for the given evidential layers. + + Args: + dep_rst (rasterio.io.DatasetReader): Raster representing the mineral deposits or occurences point data. + rasters_gen (List): List of raster arrays for all evidential rasters, + where each element is a 3d array of generalized classes, + generalized weights and standard deviation of the corresponding generalized weights. + + Returns: + pprb_array (np.ndarray): Array of posterior probabilites of presence of the targeted mineral deposit for the given evidential layers. + pprb_std (np.ndarray): Standard deviations in the posterior probability calculations because of the deviations in weights of the evidential rasters. + pprb_conf(np.ndarray): Confidence of the prospectivity values obtained in the posterior probability array. + array_meta (dict): Resulting raster array's metadata (for visualizations and writing the array to raster file). + + Raises: + + """ + pprb_array, pprb_std, pprb_conf, array_meta = _calculate_responses( + dep_rst, rasters_gen) + return pprb_array, pprb_std, pprb_conf, array_meta diff --git a/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py b/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py new file mode 100644 index 00000000..8fa8f5aa --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py @@ -0,0 +1,60 @@ +from typing import Tuple, List +import rasterio +import pandas as pd + + +from eis_toolkit.prediction.weights_of_evidence.generalized_weights import weights_generalization +from eis_toolkit.prediction.weights_of_evidence.weights_arrays import weights_arrays +from eis_toolkit.prediction.weights_of_evidence.save_weights import save_weights +from eis_toolkit.prediction.weights_of_evidence.weights import positive_weights, negative_weights, contrast +from eis_toolkit.prediction.weights_of_evidence.weights_type import weights_type + +def _calculate_weights( + ev_rst: rasterio.io.DatasetReader, + bsc_clc: pd.DataFrame, + w_type: int = 0, stud_cont: float = 2 +) -> Tuple[pd.DataFrame, List, dict]: + + df_wgts_test, df_nan = weights_type( + bsc_clc, w_type) # df_nan is not needed + wpls_df = positive_weights(df_wgts_test) + wmns_df = negative_weights(wpls_df, w_type) + contrast_df = contrast(wmns_df) + + if w_type == 0: + cat_wgts = save_weights(contrast_df) + col_names = ['Class', 'WPlus', 'S_WPlus'] + gen_arrys, rstr_meta = weights_arrays(ev_rst, cat_wgts, col_names) + return cat_wgts, gen_arrys, rstr_meta + else: + num_weights = weights_generalization(contrast_df, w_type, stud_cont,) + col_names = ['Gen_Class', 'Gen_Weights', 'S_Gen_Weights'] + gen_arrys, rstr_meta = weights_arrays(ev_rst, num_weights, col_names) + return num_weights, gen_arrys, rstr_meta + + +def calculate_weights( + ev_rst: rasterio.io.DatasetReader, + bsc_clc: pd.DataFrame, + w_type: int = 0, stud_cont: float = 2 +) -> Tuple[pd.DataFrame, List, dict]: + """ Calculates weights of spatial associations. + + Args: + ev_rst (rasterio.io.DatasetReader): The evidential raster. + bsc_clc(pd.DataFrame): Dataframe obtained from basic_calculations function. + w_type (int, optional): Accepted values are 0 for unique weights, 1 for cumulative ascending weights, 2 for cumulative descending weights. Defaults to 0. + stud_cont (float, optional): studentized contrast value to be used for genralization of classes. Not needed if w_type = 0. Defaults to 2. + + Returns: + weights_df (pd.DataFrame): Dataframe with weights of spatial association between the input rasters. + gen_arrays (List): List of output raster arrays with generalized or unique classes, generalized weights and standard deviation of generalized weights. + raster_meta (dict): Raster array's metadata. + + Raises: + + """ + + weights_df, gen_arrys, raster_meta = _calculate_weights( + ev_rst, bsc_clc, w_type, stud_cont) + return weights_df, gen_arrys, raster_meta diff --git a/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py b/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py new file mode 100644 index 00000000..c4045e83 --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py @@ -0,0 +1,29 @@ +import pandas as pd + +from eis_toolkit.prediction.weights_of_evidence.weights_generalizations import reclass_gen, gen_weights_finalization +from eis_toolkit.prediction.weights_of_evidence.save_weights import save_weights + +def _weights_generalization( + df_wgts: pd.DataFrame, w_type: int, stud_cont: float = 2 +) -> pd.DataFrame: + + rcls_df = reclass_gen(df_wgts, stud_cont) + wgts_gen = gen_weights_finalization(rcls_df) + wgts_fnl = save_weights(wgts_gen, w_type) + return wgts_fnl + +def weights_generalization( + df_wgts: pd.DataFrame, w_type: int, stud_cont: float = 2 + + +) -> pd.DataFrame: + """Identifies the favourable and unfavorable classes based on the weights for ascending and descending weights and recalculates the generalized weitghts + Args: + df_wgts (pandas.DataFrame): dataframe with the weights + stud_cont (float, def = 2): studentized contrast value to be used for genralization of classes + Returns: + wgts_fnl (pandas.DataFrame): dataframe with generalized weights and generalized classes + Raises: + """ + wgts_fnl=_weights_generalization(df_wgts, w_type, stud_cont) + return wgts_fnl diff --git a/eis_toolkit/prediction/weights_of_evidence/post_probabilities.py b/eis_toolkit/prediction/weights_of_evidence/post_probabilities.py new file mode 100644 index 00000000..656794f6 --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/post_probabilities.py @@ -0,0 +1,98 @@ +import math +import numpy as np +import rasterio +from typing import Tuple, List + + +def prior_odds( + dep_rst: rasterio.io.DatasetReader +) -> Tuple[float, float]: + """Calculates the prior odds for the training points per unit cell of the study area. + + Args: + dep_rst (rasterio.io.DatasetReader): Raster representing the mineral deposits or occurences point data. + + Returns: + prior_odds_ (float): Prior odds for the mineral deposit per unit cell of the study area. + inv_dep1s (float): Reciprocal of number of deposit pixels. + """ + dep_rst_arr = np.array(dep_rst.read(1)) + #dep_size = np.size(dep_rst_arr) + dep1s = np.count_nonzero(dep_rst_arr == 1) + dep0s = np.count_nonzero(dep_rst_arr == 0) + inv_dep1s = 1/dep1s + prior_probab = dep1s/(dep1s+dep0s) + prior_odds_ = math.log(prior_probab)/(1-prior_probab) + return prior_odds_, inv_dep1s + + +def extract_arrays( + rasters_gen: List +) -> Tuple[np.ndarray, np.ndarray]: + """Creates weights summations and variance summations for all evidential rasters + + Args: + rasters_gen (List): List of raster arrays for all evidential rasters, + where each element is a 3d array of generalized classes, + generalized weights and standard deviation of the corresponding generalized weights. + + Returns: + gen_wgts_sum (np.ndarray): Array of sum of generalized weights of all input evidential raster arrays + var_gen_sum (np.ndarray)]: Array of sum of generalized variance of all input evidential raster arrays + Raises: + + """ + wgts_gen_ev = [row[1] for row in rasters_gen] + std_wgts_gen = [row[2] for row in rasters_gen] + gen_wgts_sum = np.sum(wgts_gen_ev, axis=0) + var_gen = np.square(std_wgts_gen) + var_gen_sum = np.sum(var_gen, axis=0) + return gen_wgts_sum, var_gen_sum + + +def pprb( + gen_wgts_sum: np.ndarray, + prior_odds_: float +) -> np.ndarray: + """Calculates the final posterior probabilites of presence of the targeted mineral deposit for the given evidential layers. + + Args: + gen_wgts_sum (np.ndarray): Array of sum of generalized weights of all input evidential raster arrays + prior_odds (float): Prior odds for the mineral deposit per unit cell of the study area. + + Returns: + pprb_array (np.ndarray): Array of posterior probabilites of presence of the targeted mineral deposit for the given evidential layers. + + Raises: + + """ + #e = 2.718281828 + #pprb_array =(e**(gen_wgts_sum + prior_odds))/(1+(e**(gen_wgts_sum + prior_odds))) + pprb_array = (np.exp(gen_wgts_sum + prior_odds_)) / \ + (1+(np.exp(gen_wgts_sum + prior_odds_))) + return pprb_array + + +def pprb_stat( + inv_dep1s: float, + pprb_array: np.ndarray, + var_gen_sum: np.ndarray +) -> Tuple[np.ndarray, np.ndarray]: + """Calculates the standard deviation and the confidence arrays of the posterior probability calculations. + + Args: + inv_dep1s (float): Reciprocal of number of deposit pixels. + pprb_array (np.ndarray): Array of posterior probabilites of presence of the targeted mineral deposit for the given evidential layers. + var_gen_sum (np.ndarray): Array of sum of generalized variance of all input evidential raster arrays. + + Returns: + pprb_std (np.ndarray): Standard deviations in the posterior probability calculations because of the deviations in weights of the evidential rasters. + pprb_conf(np.ndarray): Confidence of the prospectivity values obtained in the posterior probability array. + + Raises: + + """ + pprb_sqr = np.square(pprb_array) + pprb_std = np.sqrt((inv_dep1s + var_gen_sum) * pprb_sqr) + pprb_conf = pprb_array/pprb_std + return pprb_std, pprb_conf diff --git a/eis_toolkit/prediction/weights_of_evidence/save_weights.py b/eis_toolkit/prediction/weights_of_evidence/save_weights.py new file mode 100644 index 00000000..d128c984 --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/save_weights.py @@ -0,0 +1,49 @@ +import pandas as pd + + +def _save_weights( + df: pd.DataFrame, w_type: int = 0 +) -> pd.DataFrame: + + drop_cols = ['No_Dep_Cnt', 'Total_Area', 'Total_Deposits', 'Tot_No_Dep_Cnt', + 'Dep_outsidefeat', 'Non_feat_Pxls', 'Non_Feat_Non_Dep', + 'N_cls', 'Num_wpls', 'Deno_wpls', 'var_wpls', 'Num_wmns', + 'Non_Feat_Pxls_cm', 'Deno_wmns', 'var_wmns', 'var_wpls_gen', + 'cmltv_dep_cnt', 'cmltv_cnt', 'cmltv_no_dep_cnt' + ] + + if w_type != 0: + cols_rename = {'Class': 'Class', 'Point_Count': 'Cmltv. Point Count', 'Count': 'Cmltv. Count', + 'Act_Count': 'Count_', 'Act_Point_Count': 'Point Count_', + 'wpls': 'WPlus', 's_wpls': 'S_WPlus', 'wmns': 'WMinus', 's_wmns': 'S_WMinus', + 'contrast': 'Contrast', 's_contrast': 'S_Contrast', 'Stud_Cont': 'Stud. Contrast', + 'Rcls': 'Gen_Class', 'W_Gen': 'Gen_Weights', 's_wpls_gen': 'S_Gen_Weights' + } + else: + cols_rename = {'Class': 'Class', 'Point_Count': 'Point Count', 'Count': 'Count', + 'wpls': 'WPlus', 's_wpls': 'S_WPlus', 'wmns': 'WMinus', 's_wmns': 'S_WMinus', + 'contrast': 'Contrast', 's_contrast': 'S_Contrast', 'Stud_Cont': 'Stud. Contrast', + } + df = df.drop([col for col in drop_cols if col in df.columns], + axis=1).rename(columns=cols_rename).round(4) + return df + + +def save_weights( + df: pd.DataFrame, w_type: int = 0 +) -> pd.DataFrame: + """ Removes unnecessary columns and creates a clean dataframe with important spatial associations quantities. + For caterogical data with weights calculations type 'unique', this function is called after the weights calculations. + For numerical data this function is called after reclassification and generalized weights calculations. + + Args: + df (pandas.DataFrame): Data frame with all the calculations; obtained from the contrast function (for categorical data) or from the generalized weights function (for ordinal data) + w_type (int, def = 0): 0 = unique weights, 1 = cumulative ascending weights, 2 = cumulative descending weights + Returns: + df_weights (pandas.DataFrame): Final dataframe with only the necessary values. + Raises: + + """ + + df_weights = _save_weights(df, w_type) + return df_weights diff --git a/eis_toolkit/prediction/weights_of_evidence/weights.py b/eis_toolkit/prediction/weights_of_evidence/weights.py new file mode 100644 index 00000000..6a6ff0fb --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/weights.py @@ -0,0 +1,87 @@ +import pandas as pd +import numpy as np + + +def positive_weights( + df: pd.DataFrame +) -> pd.DataFrame: + """ Calculates positive weights of spatial associations between the input data and the points + Args: + df (pandas.DataFrame): The dataframe containing data values, obtained from the weights_type function + Returns: + df_wpls (pandas.DataFrame): The dataframe with positive weights of spatial associaton for each data class + Raises: + + """ + pd.set_option('mode.chained_assignment', None) + df_wpls = (df + .assign(Point_Count=lambda df: df.Point_Count. + replace(0, 0.0001)) + .assign(Num_wpls=lambda df: (df.Point_Count/df.Total_Deposits) + .replace(0, 0.0001).replace(1, 1.0001)) + .assign(Deno_wpls=lambda df: df.No_Dep_Cnt/df.Tot_No_Dep_Cnt) + .assign(wpls=lambda df: np.log(df.Num_wpls)-np.log(df.Deno_wpls)) + .assign(var_wpls=lambda df: (1/df.Point_Count)+(1/df.No_Dep_Cnt)) + .assign(s_wpls=lambda df: np.sqrt(df.var_wpls)) + ) + return df_wpls + + +def negative_weights( + df_: pd.DataFrame, w_type: int = 0 +) -> pd.DataFrame: + """ Calculates negative weights of spatial associations between the input data and the points. + Args: + df (pandas.DataFrame): The dataframe containing the positive weights for the data values; obtained from the positive_weights function + w_type (int = 0): 0 = unique weights, 1 = cumulative ascending weights, 2 = cumulative descending weights. + Returns: + df_wmns (pandas.DataFrame): The dataframe with the negative weights of spatial association for each class. + Raises: + + """ + df = df_.copy() + pd.set_option('mode.chained_assignment', None) + if w_type != 0: + df.rename(columns={"Count": "Act_Count", + "cmltv_cnt": "Count"}, inplace=True) + + df_wmns = (df + .assign(Num_wmns=lambda df: (df.Total_Deposits - (df.Point_Count/df.Total_Deposits)) + .replace(0, 0.0001)) + .assign(Dep_outsidefeat=lambda df: (df.Total_Deposits - df.Point_Count) + .replace(0, 0.0001)) + .assign(Non_Feat_Pxls_cm=lambda df: (df.Total_Area - df.Count) + .replace(0, 0.0001)) + .assign(Non_Feat_Non_Dep=lambda df: (df.Non_Feat_Pxls_cm - df.Dep_outsidefeat) + .replace(0, 0.0001)) + .assign(Deno_wmns=lambda df: (df.Non_Feat_Pxls_cm - (df.Dep_outsidefeat/df.Tot_No_Dep_Cnt)) + .replace(0, 0.0001)) + .assign(wmns=lambda df: np.log(df.Num_wmns)-np.log(df.Deno_wmns)) + .assign(var_wmns=lambda df: (1/df.Dep_outsidefeat)+(1/df.Non_Feat_Non_Dep)) + .assign(s_wmns=lambda df: np.sqrt(df.var_wmns)) + .round(4) + ) # some of these calculations could be clubbed together + # this should be before 'wmns' assignment, check at some point + df_wmns.loc[df_wmns["Num_wmns"] == + df_wmns["Deno_wmns"], "Num_wmns"] = 1.0001 + return df_wmns + + +def contrast(df: pd.DataFrame + ) -> pd.DataFrame: + """Calculates the contrast and the studentized contrast values from the postive and negative spatial associations quantified as weights in the positive_weights and negative_weights functions + Args: + df (pandas.DataFrame): The dataframe containing the positive and negative weights of spatial associations; obtained from the negative_weights function + Returns: + df_cont (pandas.DataFrame): The dataframe with contrast and studentized contrast values + Raises: + """ + + df_cont = (df + .assign(contrast=lambda df: df.wpls - df.wmns) + .assign(s_contrast=lambda df: np.sqrt(df.var_wpls + df.var_wmns)) + .assign(Stud_Cont=lambda df: df.contrast/df.s_contrast) + .round(3) + ) + #df_stud_cont = df_cont[['Class', 'contrast', 's_contrast', 'Stud_Cont']] + return df_cont diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_arrays.py b/eis_toolkit/prediction/weights_of_evidence/weights_arrays.py new file mode 100644 index 00000000..3f634202 --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/weights_arrays.py @@ -0,0 +1,80 @@ + +from typing import Tuple, List +import pandas as pd +import numpy as np +import rasterio +import functools + + +def _raster_array( + ev_rst: rasterio.io.DatasetReader, + df_wgts_nan: pd.DataFrame, col: str +) -> np.ndarray: + #rstr_meta = ev_rst.meta.copy() + rstr_arry = np.array(ev_rst.read(1)) + s = rstr_arry.shape + #print(df_wgts_nan.Class) + wgts_mapping_dct = {} + wgts_mapping_dct = pd.Series(df_wgts_nan.loc[:, col],index=df_wgts_nan.Class).to_dict() + replace_array = np.array([list(wgts_mapping_dct.keys()), list(wgts_mapping_dct.values())]) + rstr_arry_wgts = rstr_arry.reshape(-1) + mask_array = np.isin(rstr_arry_wgts, replace_array[0, :]) + ss_rplc_array = np.searchsorted(replace_array[0, :], rstr_arry_wgts[mask_array]) + rstr_arry_rplcd = replace_array[1, ss_rplc_array] + rstr_arry_rplcd = rstr_arry_rplcd.reshape(s) + return rstr_arry_rplcd + + +def raster_array( + ev_rst: rasterio.io.DatasetReader, + df_wgts_nan: pd.DataFrame, col: str +) -> np.ndarray: + """Converts the generalized weights dataaframe to numpy arrays with the extent and shape of the input raster + + Args: + ev_rst (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the dep_rst. + df_wgts_nan (pd.DataFrame): Generalized weights dataframe with info on NaN data also. + col (str): Columns to use for generation of raster object arrays. + + Returns: + np.ndarray: Individual raster object arrays for generalized or unique classes, generalized weights and standard deviation of generalized weights + """ + raster_array_ = _raster_array(ev_rst, df_wgts_nan, col) + return raster_array_ + + +def _weights_arrays( + ev_rst: rasterio.io.DatasetReader, + df_wgts: pd.DataFrame, + col_names: List +) -> Tuple[List, dict]: + rstr_meta = ev_rst.meta.copy() + list_cols = list(df_wgts.columns) + nan_row = {val: -1.e+09 for val in list_cols} + nan_row_df = pd.DataFrame.from_dict(nan_row, orient = 'index') + nan_row_df_t = nan_row_df.T + df_wgts_nan = pd.concat([nan_row_df_t, df_wgts]) + class_rstr, w_gen_rstr, std_rstr = map( + functools.partial(raster_array, ev_rst, df_wgts_nan), + col_names) + gen_arrys = [class_rstr, w_gen_rstr, std_rstr] + return gen_arrys, rstr_meta + +def weights_arrays( + ev_rst: rasterio.io.DatasetReader, + df_wgts: pd.DataFrame, col_names: List +) -> Tuple[List, dict]: + """Calls the raster_arrays function to convert the generalized weights dataaframe to numpy arrays. + + Args: + ev_rst (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the dep_rst. + df_wgts (pd.DataFrame): Dataframe with the weights. + col_names (List): Columns to generate the arrays from. + + Returns: + gen_arrys (List): List of individual raster object arrays for generalized or unique classes, generalized weights and standard deviation of generalized weights + rstr_meta (dict): Raster array's metadata. + """ + + gen_arrys, rstr_meta = _weights_arrays(ev_rst, df_wgts, col_names) + return gen_arrys, rstr_meta diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py b/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py new file mode 100644 index 00000000..de0c8d58 --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py @@ -0,0 +1,64 @@ +from typing import Tuple, List +import rasterio +import pandas as pd + +from eis_toolkit.prediction.weights_of_evidence.calculate_weights import calculate_weights +from eis_toolkit.prediction.weights_of_evidence.basic_calculations import basic_calculations +from eis_toolkit.checks.crs import check_matching_crs +from eis_toolkit.exceptions import NonMatchingCrsException + +def _weights_calculations( + ev_rst: rasterio.io.DatasetReader, + dep_rst: rasterio.io.DatasetReader, + w_type: int = 0, + stud_cont: float = 2 +) -> Tuple[pd.DataFrame, List, dict]: + + bsc_clc_df = basic_calculations(ev_rst, dep_rst) + weights_df, raster_gen, raster_meta = calculate_weights( + ev_rst, bsc_clc_df, w_type, stud_cont) + return weights_df, raster_gen, raster_meta + + +def weights_calculations( + ev_rst: rasterio.io.DatasetReader, + dep_rst: rasterio.io.DatasetReader, + w_type: int = 0, + stud_cont: float = 2 +) -> Tuple[pd.DataFrame, List, dict]: + """Calculates weights of spatial associations. + + Args: + ev_rst (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the dep_rst. + dep_rst (rasterio.io.DatasetReader): Raster representing the mineral deposits or occurences point data. + w_type (int, optional): Accepted values are 0 for unique weights, 1 for cumulative ascending weights, 2 for cumulative descending weights. Defaults to 0. + stud_cont (float, optional): studentized contrast value to be used for genralization of classes. Not needed if w_type = 0. Defaults to 2. + + Returns: + weights_df (pd.DataFrame): Dataframe with weights of spatial association between the input rasters + raster_gen (List): List of output raster arrays with generalized or unique classes, generalized weights and standard deviation of generalized weights + raster_meta (dict): Raster array's metadata. + + Raises: + ValueError: Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. + The below exceptions will be incorporated into the function later as the development for other related functions progresses in the toolkit. + NonMatchingCrsException: The input rasters are not in the same crs + InvalidParameterValueException: Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. (status - pending) + NonMatchingTransformException: The input rasters do not have the same cell size and/or same extent (status - pending) + NonMatchingCoRegistrationException: The input rasters are not coregistered (status - pending) + """ + + w_type_acc = [0, 1, 2] + if w_type not in w_type_acc: + raise ValueError( + "Invalid parameter values. Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively") + """ + if not check_matching_crs( + objects=[ev_rst, dep_rst] + ): + raise NonMatchingCrsException + """ + weights_df, raster_gen, raster_meta = _weights_calculations(ev_rst, dep_rst, w_type, stud_cont) + + return weights_df, raster_gen, raster_meta + diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py b/eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py new file mode 100644 index 00000000..549f04eb --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py @@ -0,0 +1,102 @@ +import pandas as pd +import numpy as np +import functools + +from eis_toolkit.exceptions import UnFavorableClassDoesntExistException, FavorableClassDoesntExistException + + +def _reclass_gen( + df: pd.DataFrame, stud_cont: float = 2 +) -> pd.DataFrame: + + df['Rcls'] = df.Stud_Cont.ge(stud_cont)[::-1].cummax()+1 + + df_stud_cont = df[['Class', 'contrast', 'Stud_Cont', 'Rcls']].round(4) + + if 1 not in df['Rcls'].values: + print(df_stud_cont) + raise UnFavorableClassDoesntExistException("""Exception error: Class doesn't exist. + For the given studentized contrast value, none of the classes were classified to the 'Unfavorable' class, i.e., class 1. + Check the displayed studentized contrast values ('Stud_Cont') and run weights calculations again using a suitable threshold value.""") + + elif 2 not in df['Rcls'].values: + print(df_stud_cont) + raise FavorableClassDoesntExistException("""Exception error: Class doesn't exist. + For the given studentized contrast value none of the classes were classified to the 'Favorable' class, i.e., class 2. + Check the displayed studentized contrast values ('Stud_Cont') and run weights calculations again using a suitable threshold value.""") + + else: + df_ = df.round(4).sort_values(by="Class", ascending=True) + return df_ + + +def reclass_gen( + df: pd.DataFrame, stud_cont: float = 2 +) -> pd.DataFrame: + """Performs reclassification of classes into favourable and unfavourable categories for ordianl data, based on studentized contrast values provided by the user. + Args: + df (pandas.DataFrame): The dataframe with all the weights calculations; obtained from the contrast function + stud_cont (float, def = 2): The threshold for studentized contrast for reclassification + Returns: + df_rcls (pandas.DataFrame): The dataframe with data classes categorized as favourable and unfavourable + Raises: + UnFavorableClassDoesntExistException: Failure to generalize classes using the given studentised contrast threshold value. Class 1 (unfavorable class) doesn't exist + FavorableClassDoesntExistException: Failure to generalize classes using the given studentised contrast threshold value. Class 2 (favorable class) doesn't exist + """ + df_rcls = _reclass_gen(df, stud_cont) + return df_rcls + + +def gen_weights( + df: pd.DataFrame, gen_cls: int +) -> pd.DataFrame: + """_summary_ + Args: + df (pd.DataFrame): + gen_cls (int): List of generalized class values + Returns: + df_gen_wgts (pd.DataFrame): Dataframe with positives weights of associations for generalized classes + Raises: + + """ + df_rc = df.groupby('Rcls') + df_rc_ = df_rc.get_group(gen_cls) + df_gen_wgts = (df_rc_ + .assign(cmltv_dep_cnt=lambda df_rc_: df_rc_.Point_Count.cumsum()) + .assign(cmltv_cnt=lambda df_rc_: df_rc_.Count.cumsum()) + .assign(cmltv_no_dep_cnt=lambda df_rc_: df_rc_.No_Dep_Cnt.cumsum()) + .iloc[[-1]] + ) + + return (df_gen_wgts + .assign(Num_wpls=lambda df_gen_wgts: df_gen_wgts.cmltv_dep_cnt/df_gen_wgts.Total_Deposits) + .assign(Deno_wpls=lambda df_gen_wgts: df_gen_wgts.cmltv_no_dep_cnt/df_gen_wgts.Tot_No_Dep_Cnt) + .assign(W_Gen=lambda df_gen_wgts: np.log(df_gen_wgts.Num_wpls)-np.log(df_gen_wgts.Deno_wpls)) + .assign(var_wpls_gen=lambda df_gen_wgts: (1/df_gen_wgts.cmltv_dep_cnt)+(1/df_gen_wgts.cmltv_no_dep_cnt)) + .assign(s_wpls_gen=lambda df_gen_wgts: np.sqrt(df_gen_wgts.var_wpls_gen)) + ) + + +def gen_weights_finalization( + df: pd.DataFrame +) -> pd.DataFrame: + """ Calls the gen_weights function and calculates positives weights of associations for each generalized class + + Args: + df (pd.DataFrame): Dataframe with weights of associations + Returns: + df (pd.DataFrame): Dataframe with positives weights of associations for generalized classes + """ + gen_cls = [1, 2] + gw_1, gw_2 = map(functools.partial(gen_weights, df), gen_cls) + gw = pd.concat([gw_1, gw_2]) + for i in range(len(gen_cls)): + clss = gen_cls[i] + w = gw.iloc[i, 31] + s_w = gw.iloc[i, 33] + v_w = gw.iloc[i, 32] + df.loc[df.Rcls == clss, 'W_Gen'] = w + df.loc[df.Rcls == clss, 's_wpls_gen'] = s_w + df.loc[df.Rcls == clss, 'var_wpls_gen'] = v_w + df.round(4) + return df diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_type.py b/eis_toolkit/prediction/weights_of_evidence/weights_type.py new file mode 100644 index 00000000..39cf2675 --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/weights_type.py @@ -0,0 +1,54 @@ +from typing import Tuple +import pandas as pd + +def _weights_type( + df: pd.DataFrame, w_type: int = 0 +) -> Tuple [pd.DataFrame, pd.DataFrame]: + + df.loc[df.Class <= -1000000000.0, 'N_cls'] = 'NaN' # not needed as such + df.loc[df.Class > -1000000000.0, 'N_cls'] = 'Data' + df_rcl=df.groupby('N_cls') + df_rcl_dt = df_rcl.get_group('Data') + df_rcl_nan = df_rcl.get_group('NaN') + + pd.set_option('mode.chained_assignment', None) + if (w_type == 0): + #returns the df with the data classes for categorical weights calculations + return df_rcl_dt, df_rcl_nan + #for sorting of classes for numerical weights calculations + elif (w_type != 0): + df_rcl_dt.rename(columns = {"Point_Count":"Act_Point_Count"}, inplace = True) + if (w_type == 1): + df_srtd = df_rcl_dt.sort_values(by = "Class", ascending=True) + #return df_srtd + elif (w_type == 2): + df_srtd = df_rcl_dt.sort_values(by = "Class", ascending=False) + + pd.set_option('mode.chained_assignment', None) + return (df_srtd + .assign(Point_Count = lambda df_srtd: df_srtd.Act_Point_Count.cumsum().replace(0,0.0001)) + .assign(cmltv_cnt = lambda df_srtd: df_srtd.Count.cumsum()) + .assign(No_Dep_Cnt = lambda df_srtd: df_srtd.No_Dep_Cnt.cumsum().replace(0, 0.0001)), + df_rcl_nan + ) + +def weights_type( + df: pd.DataFrame, w_type: int = 0 +) -> Tuple[pd.DataFrame, pd.DataFrame]: + """ + Identifies NoData and separates it out from subsequent calculations. Based on the type of weights selected by the user, the function performs the sorting and cumulative count calculations. + Args: + df (pandas.DataFrame): The dataframe with basic calculations performed in the basic_calculations function + w_type(int, def = 0): 0 = unique weights, 1 = cumulative ascending weights, 2 = cumulative descending weights + Returns: + df_data (pandas.DataFrame): The dataframe with data values and sorted is weights calculations type is numerical (i.e., w_type = 1 or 2) + df_nan (pandas.DataFrame): The dataframe with information on NoData + Raises: + + """ + w_type_acc = [0,1,2] + if w_type not in w_type_acc: + raise ValueError("Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively") + else: + df_data, df_nan = _weights_type(df, w_type) + return df_data, df_nan diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb new file mode 100644 index 00000000..886edb10 --- /dev/null +++ b/notebooks/weights_of_evidence.ipynb @@ -0,0 +1,576 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Basic implementation of weights of evidence for predictive mapping of mineral deposits" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.insert(0, \"..\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import rasterio\n", + "import pandas as pd\n", + "from rasterio import Affine\n", + "from matplotlib import pyplot as plt\n", + "from rasterio.plot import show\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "test_ev = rasterio.open(\"../tests/data/remote/wofe/wofe_ev_nan.tif\")\n", + "test_dep = rasterio.open(\"../tests/data/remote/wofe/wofe_dep_nan_.tif\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Weights Calculations - Use the weights_calculations function" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from eis_toolkit.prediction.weights_of_evidence.weights_calculations import weights_calculations " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate weights for weights type - Unique" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "test_wgt_un_, test_gen_un_, test_rst_meta = weights_calculations(test_ev, test_dep, 0, 2)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate weights for weights type - Cumulative Ascending" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_calculations(test_ev, test_dep, 1, 2)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate weights for weights type - Cumulative Descending" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_calculations(test_ev, test_dep, 2, 2)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Optional: Save results to csv " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "tab_names = ['test_wgt_un_', 'test_wgt_asc_', 'test_wgt_dsc_']\n", + "weights_tables = [test_wgt_un_, test_wgt_asc_, test_wgt_dsc_]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for tab_name, tab in zip(tab_names, weights_tables):\n", + " tab.to_csv(f'../tests/data/{tab_name}.csv')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot arrays: Example - Generalized weights for weights type 'Unique'" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (10,10))\n", + "ax.set_title(\"Generalized weights\")\n", + "clrbar = ax.imshow(test_gen_un_[1], cmap='terrain')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(test_gen_un_[1], ax = ax, transform = test_ev.transform, cmap='terrain')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot arrays: Example - Generalized weights for weights type 'Cumulative Ascending'" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (10,10))\n", + "ax.set_title(\"Generalized weights\")\n", + "clrbar = ax.imshow(test_gen_asc_[1], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(test_gen_asc_[1], ax = ax, transform = test_ev.transform, cmap='viridis')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot arrays: Example - Generalized weights for weights type 'Cumulative Descending'" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (10,10))\n", + "ax.set_title(\"Generalized weights\")\n", + "clrbar = ax.imshow(test_gen_dsc_[1], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(test_gen_dsc_[1], ax = ax, transform = test_ev.transform, cmap='viridis')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Optional: Use the following function to save the arrays as a Geotif file. Example given below. By default the raster will be stored in the notebooks directory. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def arry_tif (out_meta, rstr_name, rst_arr, indx):\n", + " rst_cls = rasterio.open(rstr_name, 'w', **out_meta)\n", + " rst_cls.write(rst_arr[indx], 1)\n", + " rst_cls.close()\n", + " test_tf = rasterio.open(rstr_name)\n", + " show(test_tf, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "out_meta = test_ev.meta.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "arry_tif(out_meta, 'rst_clss_dsc_.tif', test_gen_dsc_, 0) #saves the generalized classes\n", + "arry_tif(out_meta, 'rst_gen_wgts_dsc_.tif', test_gen_dsc_, 1) #saves the generalized weights of the generalized classes\n", + "arry_tif(out_meta, 'rst_gen_std_dsc_.tif', test_gen_dsc_, 2) #saves the standard deviations of the generalized weights " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Integration of generalized weights rasters to calculate the posterior probabilities - use the 'calculate_responses' function" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from eis_toolkit.prediction.weights_of_evidence.calculate_responses import calculate_responses" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "test_wgts_arr = [test_gen_un_, test_gen_asc_, test_gen_dsc_]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "t_pprb_array, t_pprb_std, t_pprb_conf, array_meta = calculate_responses(test_dep, test_wgts_arr)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting the Posterior Probability Raster" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (10,10))\n", + "ax.set_title(\"Probability\")\n", + "clrbar = ax.imshow(t_pprb_array, cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(t_pprb_array, ax = ax, transform = test_ev.transform, cmap='viridis')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting the Standard Deviations of the calculated posterior Probabilities" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (10,10))\n", + "ax.set_title(\"Standard Deviation of Posterior Probabilities\")\n", + "clrbar = ax.imshow(t_pprb_std, cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(t_pprb_std, ax = ax, transform = test_ev.transform, cmap='viridis')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting the Confidence in the posterior probability values" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (10,10))\n", + "ax.set_title(\"Confidence\")\n", + "clrbar = ax.imshow(t_pprb_conf)\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(t_pprb_conf, ax = ax, transform = test_ev.transform)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Optional: Save the probability arrays to raster files" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "list_pprbs = [t_pprb_array, t_pprb_std, t_pprb_conf]\n", + "arry_tif(out_meta, 'pprb.tif', list_pprbs, 0) #saves the posterior probability raster\n", + "arry_tif(out_meta, 'pprb_std.tif', list_pprbs, 1) #saves the standard deviation of the prosterior probability raster\n", + "arry_tif(out_meta, 'pprb_conf.tif', list_pprbs, 2) #saves the confidence score in the posterior probability calculcations as a raster\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tests/data/remote/wofe/Merged_Ascending_.tif b/tests/data/remote/wofe/Merged_Ascending_.tif new file mode 100644 index 0000000000000000000000000000000000000000..61bf99905b8eb5ec5f2c627b24c48efb6127907d GIT binary patch literal 13496 zcmeHO&r4Kc6uoa|7zKw=(y7Ie4_uTIv=~BLq~k(i7P(LtE!x(izdTfLi~a;b zX3@f3e?YZr83b^bG~!Wy+>xH{r(b7645kKQm2H` zU4D`RcNo_g*ZKUxPrayTye8n8q(L>V{p4q^sAqTD1)gDii*d%8o$t(c;O=%&=eKBw zadz()KR4dCa(u%0&AS#g`8?z2Xi%q=&m}f79MtFz#nEwCp)C$JcA$za6fAI6i$$gcv!o;j;G^V}Hy}gKaWJeH$IqyD{$Frzg|> zxZ;e>4SqlC2ZPvl$G{Gee{5J4aU2O@vc-yjt0BZ(e$$6 zpic>#>T7Z})r^6U`-#Di#shjrthtMv*fO=51?NH?#K?&aqff-9KL6KDr9If}O44*y zM{kHt^<&7?#=q&j$j82>76%N2=pp#1dbsmzAmH zr>r{e&>sN-s0)I{uCAA5zwI2U3c9!xWJ`K4NI%Q>A z<(>PUU6ZNA@$GG_fBAQPrk`U{Uasn{axtCDRp0BV<0?BFo$I)_m_6HM5%O+qJB;~r VBV;ZidxiWR2szidSJnSl + + + + 0.9995421245421245 + 2.000457875457875 + 1092 + 0 + 0 + 99|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|682 + + + + 2 + 1.8732394366197 + 1 + 0.33270455805684 + 71.52 + + + + + + 0.3373912605474065 + 0.575108733492129 + 1092 + 0 + 0 + 99|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|682 + + + + 0.57499998807907 + 0.54489435654291 + 0.33750000596046 + 0.079017326589278 + 71.52 + + + + + + 0.1150706922942465 + 0.1791293108528787 + 1092 + 0 + 0 + 99|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|682 + + + + 0.17910000681877 + 0.17098732943266 + 0.11509999632835 + 0.021293095205847 + 71.52 + + + diff --git a/tests/data/remote/wofe/Merged_Descending_.tif b/tests/data/remote/wofe/Merged_Descending_.tif new file mode 100644 index 0000000000000000000000000000000000000000..ad3df1ae0e08402ff4505fd0aa4520ac3509039b GIT binary patch literal 13496 zcmeHOJ8KkC7`?N*YyvKlK(et|%s>iF5G+J6g>h3Pu!RAWEi9}p#GerG2^%a-Yhh`V zM%hBdN^1)%OF{5wXyZ5IEF8fD-_3o@>`pRF?%A{Fd)#yC9Skr}SQpZtsdasQt) z|M35R_ZL==?tZ+m{c8Ee?vMBPwkN72cW2I+miUuB#o1_$M_mym^W)K+>6*6KnV6Sr zrjwn&&$aS%eQjsBe{f?ny_ybhU%S3L*t@)QWpDlPFMBBUpC6sQb@9OTS3caiIsWu; zOMxoZ4m{$MR? zG(2i-G0v(R)?|vFFmF-Aux%~VYk0Op9e7Qq%)`+Bu(>Wg?u>nqpLVRt)Yl!+L&Vr$ z!=uIp`){ay5$Of~(hd`GswW@lE5yrvIour>ttl_~Cq`y)n86)^6` zFz(4TE(YRz0vlcyfxi9u{!MKB_59&kXn7PE9#eCEFZ>x!Uud`Wo|E + + + + 0.9995421245421245 + 2.000457875457875 + 1092 + 0 + 0 + 275|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|506 + + + + 2 + 1.6478873239437 + 1 + 0.47762887205107 + 71.52 + + + + + + 0.0510672606074084 + 0.3412327453947793 + 1092 + 0 + 0 + 506|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|275 + + + + 0.34110000729561 + 0.15327746651962 + 0.051199998706579 + 0.13846461410998 + 71.52 + + + + + + 0.2311901961395265 + 0.2526098127534865 + 1092 + 0 + 0 + 506|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|275 + + + + 0.25260001420975 + 0.23873521282639 + 0.23119999468327 + 0.010221267188304 + 71.52 + + + diff --git a/tests/data/remote/wofe/Merged_Unique.tif b/tests/data/remote/wofe/Merged_Unique.tif new file mode 100644 index 0000000000000000000000000000000000000000..6d50665050e86444a9aaba0b4298f7ce89756eb7 GIT binary patch literal 13496 zcmeI2%}Z2a6vp5AK!t`-P>YZp5Go~T5mIfOJAs0WB-BNVXwgEVMSp?NCylj8+PMgF z*D6A&MJ;67wWwAtgP=tqv?yp*1f4sM@C!O}UhjMFTuF!Pedf&bp7%M=GhdD~Jw4`n zoO8X-6-urk=%^fpHXagO6kL+?dpSz&dd%wr?kkjCQEDIL7--kyHG^&3C-{KinA1Nz z)IWr^v+cUvpse{|8}K?KMTHfr{cQg{8Nr+jgqU%c}zsCHHz-A;H$A9`Kh)p zOLFZ|Rn)dFtsA1{=&y6@%D;at^bRjwczLkCGH`$D(~FDsEmooBPPcPq@h85t&&Bdu zV^Bzip0!4|8+2V_XTd!fah3S|YhSr_9vzvSpPf5>rh1|}f9~Y?)bz};$>TGli<{L& zS>L?Acl<9NMA7==L+c9*UnZRM#W!jz*Jf*19zK<|#9E*K#nVpD$t+yGHePw{+?%uV zzy>DA7i;;3s(0GIJnqlzEZ8?w@>ipcBi|=Z-Md-ye@;kpAIPKcX=jIRtKB!! z^f>F@oH5HxwY~C|HT}sto1N}Q&6>}hs^>Xh?R9FWIfPutyt2%fo=}5^^Oi65TQI#P z4w>avFHH}s;%LcT1-9g!gA+axB>LSY;p0TXHmPS<6{8zNOAg zi8XC`sB?B=Uu~95H4lCFvhX>Jwr`R;^JO24wzN5%o!EC@OQya(H9kEgrheAhhxJgH z`TAmNO9RsrV#{8kGPU^3_eIocS(`S;H&aay`&j%Zhn^6VW5Je8HT|q}FV=~vlXYTC zAM!(C-rtx@D9pJuOn)?vrEbZTedwW9C&w3SJy|CX)t{NNrRQh%>lU3!I9X61jW@7g3j=XtH>gT;SePM&?()3*J019qQ3 Fe*m|W39 + + + + 0.9945054945054945 + 13.00549450549451 + 1092 + 0 + 0 + 275|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|11|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|396|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|2|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|10 + + + + 13 + 2.8169014084507 + 1 + 2.0983552187565 + 71.52 + + + + + + -8.768938637041783 + 4.213939285540318 + 1092 + 0 + 0 + 43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|11|0|0|0|0|0|0|0|10|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|396|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|275|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|2 + + + + 4.2080001831055 + -0.43703965436329 + -8.7629995346069 + 2.4146011307113 + 71.52 + + + + + + 0.2933653725154234 + 100.0506318675511 + 1092 + 0 + 0 + 275|396|0|0|0|0|0|43|0|0|0|0|2|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|65 + + + + 100.00499725342 + 8.7295441580185 + 0.33899998664856 + 27.500314761149 + 71.52 + + + diff --git a/tests/data/remote/wofe/Merged_pprbs.tif b/tests/data/remote/wofe/Merged_pprbs.tif new file mode 100644 index 0000000000000000000000000000000000000000..72d910fa1e69f12a5321d7dd3df7fdd7c7e71deb GIT binary patch literal 13496 zcmeI1%}Z2K7{;3uoocFxveJ*}ZP4$~5 zV@!)Nv4n|PI&QC6nY%2(uF-be0;8niI zlf^=(HN~2Wg+|k98tgb@W+iQ!gZuCO$HAbI+Cvzclt*g$puDnw+8mlU;k0a-=TJ&~-13pJ$Qw_0gFx>u7q5+QYMxUH4^n61&!v{G1_~{ZnTh>R~bS zb!GMz1#>23&0bQD)HQW9bLP)Q>{GKgYL9ECQa`MtnHxQv37H-ZGdqc;{;6{>>SXpw zovf)te^|`tjk$!yJeS0rkL1zlQjXMFhclFPdR$qmNu3;4eP+s$cpN!dxzYV{p^|wO!|_@zdjT zF4wi3IayOj>X~)OnwmZyW+yRw_Q{uZBo6C)iqA|mYo-1rotcs~d%1d~9I0Bw` zx$eb2!(yMj!dfexMVgP~*XUBsO6rTkLpI<()`SJ)1NeCUgNZ8iIX|$ z+M%G8GA(FgtVq)~jUoo>x*~zrO8aTGPV4~$LLl)l4TM1Bf$e4D6@(B!$8Ovv>!fND zFG#gypYNV~zH`pK*FHWJ^#U4y0-Bglq_x-QyxUy?lm?av84mNuAD4 zW%z_nLkjl*f;b3s0ovc;WJ1`oe>DM2?;-sVIfNC3 z$Mi0O?ed1Og7BE03AB^6pK^h5K02mvF|E}en3VtTVdzT`lwY34;Q7DOfOkeLN6xa2w7d z)PO5_$`3S#bOGy*P1WVc_Hu#wXiMGG$I*d(6;r{6+P7T$4?Q;-b8MSvkJ7dsXT0^N zJ9v5_dM(^^t~171N6Q4uq;GKFO!E&TdoBcq*xfrfo%Bpmmu{britqYod>;)zdolP) z_s7A5UGrCc3z6B52Y0sYJoC-qmA*vq27m3R-rAq) zvG1y_&V6>^P|sq_Qg`ahsMKqp?ru2ybu8Vxcz?w4{J%yhIP>?eb!UZ4mzGkcBLg@D)+u zCxJJ&n2qYwytWIt+y)=&2o#a}z+6=v__GFg|43>J|LjkwVOJ%ZU_ RHQ*MjRn2>K!&vx_{1<=5;?Mv9 literal 0 HcmV?d00001 diff --git a/tests/data/remote/wofe/wofe_dep_nan_.tif.aux.xml b/tests/data/remote/wofe/wofe_dep_nan_.tif.aux.xml new file mode 100644 index 00000000..2c0ad0e5 --- /dev/null +++ b/tests/data/remote/wofe/wofe_dep_nan_.tif.aux.xml @@ -0,0 +1,17 @@ + + + Generic + + + + THEMATIC + + 1 + 0.014652014652015 + 0 + 1 + 1 + 0.12021050801788 + + + diff --git a/tests/data/remote/wofe/wofe_dep_nan_.tif.ovr b/tests/data/remote/wofe/wofe_dep_nan_.tif.ovr new file mode 100644 index 0000000000000000000000000000000000000000..127f1c89f434f53ffd1ea64e165285e56a91ea8c GIT binary patch literal 258 zcmebD)MDUZU|`^9_{YG)zzAf4Faskqm=*ysp=>@Nn+eJW>0m};vq9M)y`o5L86>tX z659#NZUCxxMq;}#Lfmi;DDDbnn*iCtNO~KWFfs4|#SQ^62jOkOPvKAS^MbG!-K32co#plsM;?=9NIi+(48tH>v_&1voHJP%zXp bFgG)Rf>dn-W4NS(AxIW3XJ7!7HIxDX$oCK> literal 0 HcmV?d00001 diff --git a/tests/data/remote/wofe/wofe_dep_nan_.tif.xml b/tests/data/remote/wofe/wofe_dep_nan_.tif.xml new file mode 100644 index 00000000..29805cfa --- /dev/null +++ b/tests/data/remote/wofe/wofe_dep_nan_.tif.xml @@ -0,0 +1,2 @@ + +20230303105256001.0ISO 19139 Metadata Implementation SpecificationFALSEInt Training_sites.tif E:\EIS2022\Data\TestData_wofe_fns\Training_sites_int.tifClip Training_sites_int.tif "405078.132931 7498269.102178 444078.132931 7526269.102178" E:\EIS2022\Data\TestData_wofe_fns\wofe_dep_nan6.tif wofe_ev_nan.tif -1000000000 NONE NO_MAINTAIN_EXTENTwofe_dep_nan6.tiffile://E:\EIS2022\Data\TestData_wofe_fns\wofe_dep_nan6.tifLocal Area Network002405078.132931444078.1329317498269.1021787526269.1021781ProjectedGCS_EUREF_FINLinear Unit: Meter (1.000000)EUREF_FIN_TM35FIN<ProjectedCoordinateSystem xsi:type='typens:ProjectedCoordinateSystem' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:typens='http://www.esri.com/schemas/ArcGIS/10.6'><WKT>PROJCS[&quot;EUREF_FIN_TM35FIN&quot;,GEOGCS[&quot;GCS_EUREF_FIN&quot;,DATUM[&quot;D_ETRS_1989&quot;,SPHEROID[&quot;GRS_1980&quot;,6378137.0,298.257222101]],PRIMEM[&quot;Greenwich&quot;,0.0],UNIT[&quot;Degree&quot;,0.0174532925199433]],PROJECTION[&quot;Transverse_Mercator&quot;],PARAMETER[&quot;False_Easting&quot;,500000.0],PARAMETER[&quot;False_Northing&quot;,0.0],PARAMETER[&quot;Central_Meridian&quot;,27.0],PARAMETER[&quot;Scale_Factor&quot;,0.9996],PARAMETER[&quot;Latitude_Of_Origin&quot;,0.0],UNIT[&quot;Meter&quot;,1.0],AUTHORITY[&quot;EPSG&quot;,3067]]</WKT><XOrigin>-5120900</XOrigin><YOrigin>-9998100</YOrigin><XYScale>450445547.3910538</XYScale><ZOrigin>-100000</ZOrigin><ZScale>10000</ZScale><MOrigin>-100000</MOrigin><MScale>10000</MScale><XYTolerance>0.001</XYTolerance><ZTolerance>0.001</ZTolerance><MTolerance>0.001</MTolerance><HighPrecision>true</HighPrecision><WKID>102139</WKID><LatestWKID>3067</LatestWKID></ProjectedCoordinateSystem>8FALSELZW1TIFFTRUEdiscreteunsigned integer-1e+0920230303105329002023030310532900 Version 6.2 (Build 9200) ; Esri ArcGIS 10.6.1.9270wofe_dep_nan6.tif124.74497025.68519267.84576367.584674Raster DatasetdatasetEPSG8.1(9.2.0)210405078.132931 7498269.102178405078.132931 7526269.102178444078.132931 7526269.102178444078.132931 7498269.102178424578.132931 7512269.102178391000.000000281000.000000wofe_dep_nan6.tif.vatTable2OIDOIDOID400Internal feature number.EsriSequential unique whole numbers that are automatically generated.ValueValueInteger10100CountCountDouble1900Band_11.0000000.000000820230303 diff --git a/tests/data/remote/wofe/wofe_ev_nan.tfw b/tests/data/remote/wofe/wofe_ev_nan.tfw new file mode 100644 index 00000000..212f90bc --- /dev/null +++ b/tests/data/remote/wofe/wofe_ev_nan.tfw @@ -0,0 +1,6 @@ +1000.0000000000 +0.0000000000 +0.0000000000 +-1000.0000000000 +405578.1329310000 +7525769.1021779999 diff --git a/tests/data/remote/wofe/wofe_ev_nan.tif b/tests/data/remote/wofe/wofe_ev_nan.tif new file mode 100644 index 0000000000000000000000000000000000000000..52ecf63d22628cc7d75b8d59efaffa79c1aa52ef GIT binary patch literal 4034 zcmeHKYgAKL7QP{XyaJ*is088_b#w*Dg8)&8T$39Nn0JD4AZ8-DVl)X%5`1EPp;#-T z7Oh%=>WJEQ02zx2K58ADjxER(7&`&%Jd70UiYS zM79S6XwY^C2rA2VfP8`dGq~3uaez*N`4`~c0I&zJ7cGw9ijLzT^Z1xqtx=oREH@G< znrFuJB!gOy#lRdeCtH<{!K^sUfEl$Z(P5U=U%Smw8#DqyfJr8`K3xZh6qse1R8ikf zkYMRX%!C=tYO^-YV9hX+ipb`od_=}$+t|@z_Eo+tJvKMi3T*b}>|1{qj}F?ZsPsqn z`EKL3l_w)MC!F=%M?;olvtV%eR_owcmQA!cxmdu@e**@+Mla)53PGo}z0J&Jl%O<*7$2iE{Y8@bg)q>{-jvfa+bH{m7uj+!ylu(M2EEn)(ATX8+>a|W$ zBf}YV8k5GLGMV9Yx|J%7N7*u-P>=-6jB0~vIc79rDn4dRQJd3@FbIxF5I!nHB}p(> ztpjVQ+GGZMg~<$x<+3Dt!$**2G%v9_{d%1Z{?|se&XPf^(W(tFnFh9G7ebn%)?q5H zI>k}|*a?%#jIeW<2VM+wh6Ym!7psIuZK@VT8L?sTzG8q#1!0w$5EMeS)@k{H*1HiF z-!Z$nI&ZwtL0Kt-iG;0eSakXbYudPN)hX1KR~N+)cgB&{y9V#&Ps@wPB$b*|%CLR& z7E75&n)Hze1*y`?+Xd8M(&*p$ker;e;~>(g?sz%8DQFk>UvjsDTfP*3A)i)W)w%qf z>V!gm{}taOfrJk#rtE26293{bYNl6Q zF@((w@Z7ZK^Y-+W$*kZzb>>#%@(Is#!?ab`4XYQN`)A*(b-Ny|QJ%lMg8%JdW94~P z>fT#*_j*D89^Mj9amQ@CP?RTKQZ+0oW>8IG-1VbOf-3F(BBYY!^IaNA>ZAC*sj5jy|E_(JgN}#b}os!Gf(b&DQ8yV&^PH-J5O(O*DdWW zF73j+s;Q2G>zprTYkek(bvctSyOS4ovqd$U>)(pHQoZAM2NX|A@Sf=%{Qd6xXAee? z(KxqqcGVOSkMFv@F0eMIW>d)AzYKOVuYCBpySp|$JgPgM(o-1y-APT`j096Lfqj|o zajhmodgBnie(aMe)9X!ge9W9Of;&f=cYhMfD-BK~3rlaX9J|8E--Dg@k=%UV{BiIQR}#LOCqCOd*7S#F znNp=`{e)0momfsRTY625e}>9omw@4R_tUP`wGF#ZR(gp6K7-dWWB1GM}~Vlr(91 z$Jb3sd+&WCIulV}@$XM3J6-tW-uYuI9}NciUN#04PW=9HKpms@@xg~Nbv;Bc^oO4O zFn+@mqEO!WBtK2r+)K>GT6^_sLAjj+FA7T^ zJR1tCd-8m!@ZsQ4yCZJB$kQQKLBO?hTsMe9onu>w`1UOCjUs^?q6l$nuO7ciWbi~< zVn%g1PRbJP7&Aw~ckSRz-z+K_H>XAE-jPM!BDykxt{-W|nxHSTF-s6#L$+Uht9F5Q?^(^SkA!-Y(uj<0@*$-{NR< z#3d2jmK*IZF24;01i8IdK>h&R6wq9NZ3?IbV4DK!2iT&3jsYd)NqDV*PI=kBs+O7PNmRnWxv?~j?}!r03ocx!2kdN literal 0 HcmV?d00001 diff --git a/tests/data/remote/wofe/wofe_ev_nan.tif.aux.xml b/tests/data/remote/wofe/wofe_ev_nan.tif.aux.xml new file mode 100644 index 00000000..442a04e3 --- /dev/null +++ b/tests/data/remote/wofe/wofe_ev_nan.tif.aux.xml @@ -0,0 +1,30 @@ + + + Generic + + + Band_1 + + + 1 + 13 + 256 + 1 + 0 + 275|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|11|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|396|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|2|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|10 + + + + Band_1 + ATHEMATIC + 4.408739617190325 + 13 + 2.8169014084507 + 1 + 1 + 1 + 2.0983552187565 + 71.52 + + + diff --git a/tests/data/remote/wofe/wofe_ev_nan.tif.ovr b/tests/data/remote/wofe/wofe_ev_nan.tif.ovr new file mode 100644 index 0000000000000000000000000000000000000000..208510ab39da908a8622df9d0399c23439377833 GIT binary patch literal 474 zcmebD)MDUZU|`^9_{YG)zzAf4Faskqm=*ysp=>@Nn+eKR0J52(Y>;j?C>x|#6p1Z^ z#I{9ZJ3-kEK=sZ@Y!^m|8_og6U7>6qprOG~HOxTq#wAP)JV5#o5QBiOp#cmqRLpsM z<05a9fe7mb^RD@Mi8l|}`ph{PIOD`j9>rcJRmbEUt>=$hE_?_qijU_$e)?-&%5|l@ zU*5xa<#4@JvF_Cao5X!w!>ixbDF45HZ@%&QC5*_pdE?#Gl;X^wrc}UOG$p`MlQ$wmZI7 z;%haHfA#tE<_Dj0B7VpIQ2Fn%c+TI=^YyC_-`e{p+H7s(rCayE)i3x~{h>F?qt$A{ X|G252*4wH>yhl2@U>|#?)tP<(L2`pq literal 0 HcmV?d00001 diff --git a/tests/data/remote/wofe/wofe_ev_nan.tif.xml b/tests/data/remote/wofe/wofe_ev_nan.tif.xml new file mode 100644 index 00000000..36123d17 --- /dev/null +++ b/tests/data/remote/wofe/wofe_ev_nan.tif.xml @@ -0,0 +1,2 @@ + +20230303100923001.0ISO 19139 Metadata Implementation SpecificationFALSEwofe_ev_nan.tiffile://E:\EIS2022\Data\TestData_wofe_fns\wofe_ev_nan.tifLocal Area Network002405078.132931444078.1329317498269.1021787526269.1021781ProjectedGCS_EUREF_FINLinear Unit: Meter (1.000000)EUREF_FIN_TM35FIN<ProjectedCoordinateSystem xsi:type='typens:ProjectedCoordinateSystem' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:typens='http://www.esri.com/schemas/ArcGIS/10.6'><WKT>PROJCS[&quot;EUREF_FIN_TM35FIN&quot;,GEOGCS[&quot;GCS_EUREF_FIN&quot;,DATUM[&quot;D_ETRS_1989&quot;,SPHEROID[&quot;GRS_1980&quot;,6378137.0,298.257222101]],PRIMEM[&quot;Greenwich&quot;,0.0],UNIT[&quot;Degree&quot;,0.0174532925199433]],PROJECTION[&quot;Transverse_Mercator&quot;],PARAMETER[&quot;False_Easting&quot;,500000.0],PARAMETER[&quot;False_Northing&quot;,0.0],PARAMETER[&quot;Central_Meridian&quot;,27.0],PARAMETER[&quot;Scale_Factor&quot;,0.9996],PARAMETER[&quot;Latitude_Of_Origin&quot;,0.0],UNIT[&quot;Meter&quot;,1.0],AUTHORITY[&quot;EPSG&quot;,3067]]</WKT><XOrigin>-5120900</XOrigin><YOrigin>-9998100</YOrigin><XYScale>450445547.3910538</XYScale><ZOrigin>-100000</ZOrigin><ZScale>10000</ZScale><MOrigin>-100000</MOrigin><MScale>10000</MScale><XYTolerance>0.001</XYTolerance><ZTolerance>0.001</ZTolerance><MTolerance>0.001</MTolerance><HighPrecision>true</HighPrecision><WKID>102139</WKID><LatestWKID>3067</LatestWKID></ProjectedCoordinateSystem>32FALSELZW1TIFFTRUEcontinuousfloating point-1e+09Clip wofe_ev_rst_int.tif "406837.552257628 7499299.44095142 443548.563179649 7525651.99365652" E:\EIS2022\Data\TestData_wofe_fns\wofe_ev_nan.tif Extent_NaN -1000000000 ClippingGeometry NO_MAINTAIN_EXTENT20230303100923002023030310092300 Version 6.2 (Build 9200) ; Esri ArcGIS 10.6.1.9270wofe_ev_nan.tif124.74497025.68519267.84576367.584674Raster DatasetdatasetEPSG8.1(9.2.0)210405078.132931 7498269.102178405078.132931 7526269.102178444078.132931 7526269.102178444078.132931 7498269.102178424578.132931 7512269.102178391000.000000281000.000000Band_113.0000001.0000003220230303 diff --git a/tests/wofe_calculate_responses_test.py b/tests/wofe_calculate_responses_test.py new file mode 100644 index 00000000..9d3f3cd9 --- /dev/null +++ b/tests/wofe_calculate_responses_test.py @@ -0,0 +1,46 @@ +import pytest +import numpy as np +from pathlib import Path +import rasterio +import pandas as pd +from pandas.testing import assert_frame_equal + +from eis_toolkit.prediction.weights_of_evidence.calculate_responses import calculate_responses + +parent_dir = Path(__file__).parent +print(parent_dir) + +# Paths of files to be used as inputs to the calculate responses function +wgts_rst_un_path = parent_dir.joinpath("data/remote/wofe/Merged_Unique.tif") +wgts_rst_asc_path = parent_dir.joinpath("data/remote/wofe/Merged_Ascending_.tif") +wgts_rst_dsc_path = parent_dir.joinpath("data/remote/wofe/Merged_Descending_.tif") +dep_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_dep_nan_.tif") + +# Path to the file to compare the results of the calculates responses function +merged_pprb_path = parent_dir.joinpath("data/remote/wofe/Merged_pprbs.tif") + +# Actual testing function +def test_calculate_responses(): + """Tests if calculate_responses function works as intended""" + # expected arrays + pprb_rstrs = rasterio.open(merged_pprb_path) + pprb, std, conf = np.array(pprb_rstrs.read(1)), np.array(pprb_rstrs.read(2)), np.array(pprb_rstrs.read(3)) + exp_pprbs = [pprb, std, conf] + + #input to calculate_responses function + test_dep = rasterio.open(dep_rst_path) + wgts_rstr_paths = [wgts_rst_un_path, wgts_rst_asc_path, wgts_rst_dsc_path] + arrys_list_from_wgts = [] + for path_rst in wgts_rstr_paths: + wgts_rst_o = rasterio.open(path_rst) + pprb_, std_, conf_ = np.array(wgts_rst_o.read(1)), np.array(wgts_rst_o.read(2)), np.array(wgts_rst_o.read(3)) + list_one_block = [pprb_, std_, conf_] + arrys_list_from_wgts.append(list_one_block) + + # Call the calculate_responses function + t_pprb_array, t_pprb_std, t_pprb_conf, array_meta = calculate_responses(test_dep, arrys_list_from_wgts) + result_pprbs = [t_pprb_array, t_pprb_std, t_pprb_conf] + + #compare the results + for res, exp in zip(result_pprbs, exp_pprbs): + assert res.all() == exp.all() \ No newline at end of file diff --git a/tests/wofe_weights_calculations_test.py b/tests/wofe_weights_calculations_test.py new file mode 100644 index 00000000..ec77351a --- /dev/null +++ b/tests/wofe_weights_calculations_test.py @@ -0,0 +1,47 @@ +import pytest +import numpy as np +from pathlib import Path +import rasterio +import pandas as pd +from pandas.testing import assert_frame_equal + +from eis_toolkit.prediction.weights_of_evidence.weights_calculations import weights_calculations + +parent_dir = Path(__file__).parent +print(parent_dir) + +# Paths of files to be used as inputs to the weights_calculations function +ev_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_ev_nan.tif") +dep_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_dep_nan_.tif") + +# Paths to the files to compare the results of the weigths_calculations function to +wgts_rst_un_path = parent_dir.joinpath("data/remote/wofe/Merged_Unique.tif") +wgts_rst_asc_path = parent_dir.joinpath("data/remote/wofe/Merged_Ascending_.tif") +wgts_rst_dsc_path = parent_dir.joinpath("data/remote/wofe/Merged_Descending_.tif") + +wgts_un_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_un.csv") +wgts_asc_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_asc.csv") +wgts_dsc_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_dsc.csv") + + +@pytest.mark.parametrize("wgts_type, wgts_df_path, expected", [(0, wgts_un_path, wgts_rst_un_path), (1, wgts_asc_path, wgts_rst_asc_path), (2, wgts_dsc_path, wgts_rst_dsc_path)]) + +def test_weights_calculations( wgts_type, wgts_df_path, expected): + """Tests if weights_calculations function runs as intended; tests for all three weights type""" + #expected results + # weights dataframe + wgts_ = pd.read_csv(wgts_df_path).set_index('Clss') + exp_wgts_df = pd.DataFrame(wgts_) + # weights arrays + wgts_rstr_ = rasterio.open(expected) + clss, wgts, std = np.array(wgts_rstr_.read(1)), np.array(wgts_rstr_.read(2)), np.array(wgts_rstr_.read(3)) + exp_list_arr = [clss, wgts, std] + #inputs to function + ev_rst_ = rasterio.open(ev_rst_path) + dep_rst_ = rasterio.open(dep_rst_path) + #Calling the function + wgts_df, wgts_arr, rst_meta = weights_calculations(ev_rst=ev_rst_, dep_rst= dep_rst_, w_type=wgts_type, stud_cont=2) + assert_frame_equal(wgts_df, exp_wgts_df, check_dtype=False, check_index_type=False) + for res, exp in zip(wgts_arr, exp_list_arr): + assert res.all() == exp.all() + \ No newline at end of file From 790399543679a3f8a65e5b72e43e86984c8c8ccd Mon Sep 17 00:00:00 2001 From: Bijal Chudasama Date: Fri, 28 Jul 2023 10:24:19 +0300 Subject: [PATCH 02/31] replacing the default no data value to user defined no data value --- .../weights_of_evidence/basic_calculations.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py b/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py index 2baa6ac1..40b9cece 100644 --- a/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py +++ b/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py @@ -7,11 +7,12 @@ def _basic_calculations( ev_rst: rasterio.io.DatasetReader, - dep_rst: rasterio.io.DatasetReader + dep_rst: rasterio.io.DatasetReader, + nan_val: float ) -> pd.DataFrame: geol, dep_ar = np.array(ev_rst.read(1)), np.array(dep_rst.read(1)) - tot_pxls = np.size(geol) - np.count_nonzero(geol <= -1000000000) + tot_pxls = np.size(geol) - np.count_nonzero(geol <= nan_val) dep1s, dep0s = np.count_nonzero(dep_ar == 1), np.count_nonzero(dep_ar == 0) d_flat, g_flat = dep_ar.flatten(), geol.flatten() df_flt = pd.DataFrame({"Clss": g_flat, "Ds": d_flat}) @@ -44,13 +45,15 @@ def _basic_calculations( def basic_calculations( ev_rst: rasterio.io.DatasetReader, - dep_rst: rasterio.io.DatasetReader + dep_rst: rasterio.io.DatasetReader, + nan_val: float ) -> pd.DataFrame: """Performs basic calculations about the number of point pixels per class of the input raster. Args: ev_rst (rasterio.io.DatasetReader): The evidential raster. dep_rst (rasterio.io.DatasetReader): Deposit raster + nan_val (float): value of no data Returns: basic_clcs (pandas.DataFrame): dataframe with basic calculations. @@ -58,5 +61,5 @@ def basic_calculations( Raises: None """ - basic_clcs = _basic_calculations(ev_rst, dep_rst) + basic_clcs = _basic_calculations(ev_rst, dep_rst, nan_val) return basic_clcs From 7f7f947b1feb711ced5ecd7bde75b41833fbcd6d Mon Sep 17 00:00:00 2001 From: Bijal Chudasama Date: Fri, 28 Jul 2023 10:26:48 +0300 Subject: [PATCH 03/31] replacing default no data value to user defined no data value --- .../prediction/weights_of_evidence/basic_calculations.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py b/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py index 40b9cece..83d0ab7b 100644 --- a/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py +++ b/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py @@ -53,7 +53,7 @@ def basic_calculations( Args: ev_rst (rasterio.io.DatasetReader): The evidential raster. dep_rst (rasterio.io.DatasetReader): Deposit raster - nan_val (float): value of no data + nan_val (float): value of no data. Returns: basic_clcs (pandas.DataFrame): dataframe with basic calculations. From 0780bd7ca4fa476e011bd4178f72f66276e50536 Mon Sep 17 00:00:00 2001 From: Bijal Chudasama Date: Fri, 28 Jul 2023 10:36:23 +0300 Subject: [PATCH 04/31] fixing all the related functions for using user defined no data value --- .../weights_of_evidence/calculate_weights.py | 7 +++-- .../weights_calculations.py | 9 ++++-- .../weights_of_evidence/weights_type.py | 11 ++++---- notebooks/weights_of_evidence.ipynb | 28 +++++++++---------- 4 files changed, 31 insertions(+), 24 deletions(-) diff --git a/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py b/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py index 8fa8f5aa..c3d7fb16 100644 --- a/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py +++ b/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py @@ -12,11 +12,12 @@ def _calculate_weights( ev_rst: rasterio.io.DatasetReader, bsc_clc: pd.DataFrame, + nan_val: float, w_type: int = 0, stud_cont: float = 2 ) -> Tuple[pd.DataFrame, List, dict]: df_wgts_test, df_nan = weights_type( - bsc_clc, w_type) # df_nan is not needed + bsc_clc, nan_val, w_type) # df_nan is not needed wpls_df = positive_weights(df_wgts_test) wmns_df = negative_weights(wpls_df, w_type) contrast_df = contrast(wmns_df) @@ -36,6 +37,7 @@ def _calculate_weights( def calculate_weights( ev_rst: rasterio.io.DatasetReader, bsc_clc: pd.DataFrame, + nan_val:float, w_type: int = 0, stud_cont: float = 2 ) -> Tuple[pd.DataFrame, List, dict]: """ Calculates weights of spatial associations. @@ -43,6 +45,7 @@ def calculate_weights( Args: ev_rst (rasterio.io.DatasetReader): The evidential raster. bsc_clc(pd.DataFrame): Dataframe obtained from basic_calculations function. + nan_val (float): value of no data w_type (int, optional): Accepted values are 0 for unique weights, 1 for cumulative ascending weights, 2 for cumulative descending weights. Defaults to 0. stud_cont (float, optional): studentized contrast value to be used for genralization of classes. Not needed if w_type = 0. Defaults to 2. @@ -56,5 +59,5 @@ def calculate_weights( """ weights_df, gen_arrys, raster_meta = _calculate_weights( - ev_rst, bsc_clc, w_type, stud_cont) + ev_rst, bsc_clc, nan_val, w_type, stud_cont) return weights_df, gen_arrys, raster_meta diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py b/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py index de0c8d58..5ebe0175 100644 --- a/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py +++ b/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py @@ -10,19 +10,21 @@ def _weights_calculations( ev_rst: rasterio.io.DatasetReader, dep_rst: rasterio.io.DatasetReader, + nan_val: float, w_type: int = 0, stud_cont: float = 2 ) -> Tuple[pd.DataFrame, List, dict]: - bsc_clc_df = basic_calculations(ev_rst, dep_rst) + bsc_clc_df = basic_calculations(ev_rst, dep_rst, nan_val) weights_df, raster_gen, raster_meta = calculate_weights( - ev_rst, bsc_clc_df, w_type, stud_cont) + ev_rst, bsc_clc_df, nan_val, w_type, stud_cont) return weights_df, raster_gen, raster_meta def weights_calculations( ev_rst: rasterio.io.DatasetReader, dep_rst: rasterio.io.DatasetReader, + nan_val: float, w_type: int = 0, stud_cont: float = 2 ) -> Tuple[pd.DataFrame, List, dict]: @@ -31,6 +33,7 @@ def weights_calculations( Args: ev_rst (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the dep_rst. dep_rst (rasterio.io.DatasetReader): Raster representing the mineral deposits or occurences point data. + nan_val (float): value of no data w_type (int, optional): Accepted values are 0 for unique weights, 1 for cumulative ascending weights, 2 for cumulative descending weights. Defaults to 0. stud_cont (float, optional): studentized contrast value to be used for genralization of classes. Not needed if w_type = 0. Defaults to 2. @@ -58,7 +61,7 @@ def weights_calculations( ): raise NonMatchingCrsException """ - weights_df, raster_gen, raster_meta = _weights_calculations(ev_rst, dep_rst, w_type, stud_cont) + weights_df, raster_gen, raster_meta = _weights_calculations(ev_rst, dep_rst, nan_val, w_type, stud_cont) return weights_df, raster_gen, raster_meta diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_type.py b/eis_toolkit/prediction/weights_of_evidence/weights_type.py index 39cf2675..e0d8f17f 100644 --- a/eis_toolkit/prediction/weights_of_evidence/weights_type.py +++ b/eis_toolkit/prediction/weights_of_evidence/weights_type.py @@ -2,11 +2,11 @@ import pandas as pd def _weights_type( - df: pd.DataFrame, w_type: int = 0 + df: pd.DataFrame, nan_val: float, w_type: int = 0 ) -> Tuple [pd.DataFrame, pd.DataFrame]: - df.loc[df.Class <= -1000000000.0, 'N_cls'] = 'NaN' # not needed as such - df.loc[df.Class > -1000000000.0, 'N_cls'] = 'Data' + df.loc[df.Class <= nan_val, 'N_cls'] = 'NaN' # not needed as such + df.loc[df.Class > nan_val, 'N_cls'] = 'Data' df_rcl=df.groupby('N_cls') df_rcl_dt = df_rcl.get_group('Data') df_rcl_nan = df_rcl.get_group('NaN') @@ -33,12 +33,13 @@ def _weights_type( ) def weights_type( - df: pd.DataFrame, w_type: int = 0 + df: pd.DataFrame, nan_val: float, w_type: int = 0 ) -> Tuple[pd.DataFrame, pd.DataFrame]: """ Identifies NoData and separates it out from subsequent calculations. Based on the type of weights selected by the user, the function performs the sorting and cumulative count calculations. Args: df (pandas.DataFrame): The dataframe with basic calculations performed in the basic_calculations function + nan_val (float): value of no data w_type(int, def = 0): 0 = unique weights, 1 = cumulative ascending weights, 2 = cumulative descending weights Returns: df_data (pandas.DataFrame): The dataframe with data values and sorted is weights calculations type is numerical (i.e., w_type = 1 or 2) @@ -50,5 +51,5 @@ def weights_type( if w_type not in w_type_acc: raise ValueError("Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively") else: - df_data, df_nan = _weights_type(df, w_type) + df_data, df_nan = _weights_type(df, nan_val, w_type) return df_data, df_nan diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb index 886edb10..6e9d37f0 100644 --- a/notebooks/weights_of_evidence.ipynb +++ b/notebooks/weights_of_evidence.ipynb @@ -73,7 +73,7 @@ "metadata": {}, "outputs": [], "source": [ - "test_wgt_un_, test_gen_un_, test_rst_meta = weights_calculations(test_ev, test_dep, 0, 2)" + "test_wgt_un_, test_gen_un_, test_rst_meta = weights_calculations(test_ev, test_dep, -1000000000.0, 0, 2)" ] }, { @@ -90,7 +90,7 @@ "metadata": {}, "outputs": [], "source": [ - "test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_calculations(test_ev, test_dep, 1, 2)" + "test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_calculations(test_ev, test_dep, -1000000000.0, 1, 2)" ] }, { @@ -107,7 +107,7 @@ "metadata": {}, "outputs": [], "source": [ - "test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_calculations(test_ev, test_dep, 2, 2)" + "test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_calculations(test_ev, test_dep, -1000000000.0, 2, 2)" ] }, { @@ -288,7 +288,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -347,7 +347,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -356,7 +356,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -365,7 +365,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -382,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -391,7 +391,7 @@ "" ] }, - "execution_count": 15, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, @@ -424,7 +424,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -433,7 +433,7 @@ "" ] }, - "execution_count": 16, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, @@ -466,7 +466,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -475,7 +475,7 @@ "" ] }, - "execution_count": 17, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, @@ -508,7 +508,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 21, "metadata": {}, "outputs": [ { From b9320824ba2e46172e0638617010855888f2e642 Mon Sep 17 00:00:00 2001 From: chudasama-bijal Date: Tue, 8 Aug 2023 12:48:42 +0300 Subject: [PATCH 05/31] miscellaneous minor changes --- eis_toolkit/exceptions.py | 5 +++++ .../weights_of_evidence/basic_calculations.py | 2 -- .../weights_of_evidence/calculate_responses.py | 2 -- .../weights_of_evidence/generalized_weights.py | 1 - .../weights_of_evidence/post_probabilities.py | 4 ---- .../prediction/weights_of_evidence/weights.py | 3 +-- .../weights_of_evidence/weights_arrays.py | 18 +++++++++--------- .../weights_generalizations.py | 3 +-- 8 files changed, 16 insertions(+), 22 deletions(-) diff --git a/eis_toolkit/exceptions.py b/eis_toolkit/exceptions.py index 8f6d4737..03d3ffe2 100644 --- a/eis_toolkit/exceptions.py +++ b/eis_toolkit/exceptions.py @@ -49,4 +49,9 @@ class UnFavorableClassDoesntExistException(Exception): class FavorableClassDoesntExistException(Exception): """Exception error class for failure to generalize classes using the given studentised contrast threshold value. Class 2 (favorable class) doesn't exist""" + pass + +class NonMatchingCrsException(Exception): + """Exception error class for crs mismatches.""" + pass \ No newline at end of file diff --git a/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py b/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py index 83d0ab7b..411397d6 100644 --- a/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py +++ b/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py @@ -58,8 +58,6 @@ def basic_calculations( Returns: basic_clcs (pandas.DataFrame): dataframe with basic calculations. - Raises: None - """ basic_clcs = _basic_calculations(ev_rst, dep_rst, nan_val) return basic_clcs diff --git a/eis_toolkit/prediction/weights_of_evidence/calculate_responses.py b/eis_toolkit/prediction/weights_of_evidence/calculate_responses.py index 6c665d24..61059e70 100644 --- a/eis_toolkit/prediction/weights_of_evidence/calculate_responses.py +++ b/eis_toolkit/prediction/weights_of_evidence/calculate_responses.py @@ -34,8 +34,6 @@ def calculate_responses( pprb_conf(np.ndarray): Confidence of the prospectivity values obtained in the posterior probability array. array_meta (dict): Resulting raster array's metadata (for visualizations and writing the array to raster file). - Raises: - """ pprb_array, pprb_std, pprb_conf, array_meta = _calculate_responses( dep_rst, rasters_gen) diff --git a/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py b/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py index c4045e83..f4d5d0c7 100644 --- a/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py +++ b/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py @@ -23,7 +23,6 @@ def weights_generalization( stud_cont (float, def = 2): studentized contrast value to be used for genralization of classes Returns: wgts_fnl (pandas.DataFrame): dataframe with generalized weights and generalized classes - Raises: """ wgts_fnl=_weights_generalization(df_wgts, w_type, stud_cont) return wgts_fnl diff --git a/eis_toolkit/prediction/weights_of_evidence/post_probabilities.py b/eis_toolkit/prediction/weights_of_evidence/post_probabilities.py index 656794f6..a6eb5946 100644 --- a/eis_toolkit/prediction/weights_of_evidence/post_probabilities.py +++ b/eis_toolkit/prediction/weights_of_evidence/post_probabilities.py @@ -39,7 +39,6 @@ def extract_arrays( Returns: gen_wgts_sum (np.ndarray): Array of sum of generalized weights of all input evidential raster arrays var_gen_sum (np.ndarray)]: Array of sum of generalized variance of all input evidential raster arrays - Raises: """ wgts_gen_ev = [row[1] for row in rasters_gen] @@ -63,8 +62,6 @@ def pprb( Returns: pprb_array (np.ndarray): Array of posterior probabilites of presence of the targeted mineral deposit for the given evidential layers. - Raises: - """ #e = 2.718281828 #pprb_array =(e**(gen_wgts_sum + prior_odds))/(1+(e**(gen_wgts_sum + prior_odds))) @@ -89,7 +86,6 @@ def pprb_stat( pprb_std (np.ndarray): Standard deviations in the posterior probability calculations because of the deviations in weights of the evidential rasters. pprb_conf(np.ndarray): Confidence of the prospectivity values obtained in the posterior probability array. - Raises: """ pprb_sqr = np.square(pprb_array) diff --git a/eis_toolkit/prediction/weights_of_evidence/weights.py b/eis_toolkit/prediction/weights_of_evidence/weights.py index 6a6ff0fb..930391c3 100644 --- a/eis_toolkit/prediction/weights_of_evidence/weights.py +++ b/eis_toolkit/prediction/weights_of_evidence/weights.py @@ -73,8 +73,7 @@ def contrast(df: pd.DataFrame Args: df (pandas.DataFrame): The dataframe containing the positive and negative weights of spatial associations; obtained from the negative_weights function Returns: - df_cont (pandas.DataFrame): The dataframe with contrast and studentized contrast values - Raises: + df_cont (pandas.DataFrame): The dataframe with contrast and studentized contrast values """ df_cont = (df diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_arrays.py b/eis_toolkit/prediction/weights_of_evidence/weights_arrays.py index 3f634202..dae6e362 100644 --- a/eis_toolkit/prediction/weights_of_evidence/weights_arrays.py +++ b/eis_toolkit/prediction/weights_of_evidence/weights_arrays.py @@ -7,8 +7,8 @@ def _raster_array( - ev_rst: rasterio.io.DatasetReader, - df_wgts_nan: pd.DataFrame, col: str + ev_rst: rasterio.io.DatasetReader, + df_wgts_nan: pd.DataFrame, col: str ) -> np.ndarray: #rstr_meta = ev_rst.meta.copy() rstr_arry = np.array(ev_rst.read(1)) @@ -26,8 +26,8 @@ def _raster_array( def raster_array( - ev_rst: rasterio.io.DatasetReader, - df_wgts_nan: pd.DataFrame, col: str + ev_rst: rasterio.io.DatasetReader, + df_wgts_nan: pd.DataFrame, col: str ) -> np.ndarray: """Converts the generalized weights dataaframe to numpy arrays with the extent and shape of the input raster @@ -44,9 +44,9 @@ def raster_array( def _weights_arrays( - ev_rst: rasterio.io.DatasetReader, - df_wgts: pd.DataFrame, - col_names: List + ev_rst: rasterio.io.DatasetReader, + df_wgts: pd.DataFrame, + col_names: List ) -> Tuple[List, dict]: rstr_meta = ev_rst.meta.copy() list_cols = list(df_wgts.columns) @@ -61,8 +61,8 @@ def _weights_arrays( return gen_arrys, rstr_meta def weights_arrays( - ev_rst: rasterio.io.DatasetReader, - df_wgts: pd.DataFrame, col_names: List + ev_rst: rasterio.io.DatasetReader, + df_wgts: pd.DataFrame, col_names: List ) -> Tuple[List, dict]: """Calls the raster_arrays function to convert the generalized weights dataaframe to numpy arrays. diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py b/eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py index 549f04eb..ca49245a 100644 --- a/eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py +++ b/eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py @@ -90,8 +90,7 @@ def gen_weights_finalization( gen_cls = [1, 2] gw_1, gw_2 = map(functools.partial(gen_weights, df), gen_cls) gw = pd.concat([gw_1, gw_2]) - for i in range(len(gen_cls)): - clss = gen_cls[i] + for i, clss in enumerate(gen_cls): w = gw.iloc[i, 31] s_w = gw.iloc[i, 33] v_w = gw.iloc[i, 32] From 6cb4b0c3042ec546718fa67b015c38ae1f3a0001 Mon Sep 17 00:00:00 2001 From: chudasama-bijal Date: Tue, 8 Aug 2023 12:51:10 +0300 Subject: [PATCH 06/31] renamed 'save_weights' to 'weights_cleanup' --- .../generalized_weights.py | 4 +- .../weights_of_evidence/weights_cleanup.py | 65 +++++++++++++++++++ 2 files changed, 67 insertions(+), 2 deletions(-) create mode 100644 eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py diff --git a/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py b/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py index f4d5d0c7..3ae4e369 100644 --- a/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py +++ b/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py @@ -1,7 +1,7 @@ import pandas as pd from eis_toolkit.prediction.weights_of_evidence.weights_generalizations import reclass_gen, gen_weights_finalization -from eis_toolkit.prediction.weights_of_evidence.save_weights import save_weights +from eis_toolkit.prediction.weights_of_evidence.weights_cleanup import weights_cleanup def _weights_generalization( df_wgts: pd.DataFrame, w_type: int, stud_cont: float = 2 @@ -9,7 +9,7 @@ def _weights_generalization( rcls_df = reclass_gen(df_wgts, stud_cont) wgts_gen = gen_weights_finalization(rcls_df) - wgts_fnl = save_weights(wgts_gen, w_type) + wgts_fnl = weights_cleanup(wgts_gen, w_type) return wgts_fnl def weights_generalization( diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py b/eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py new file mode 100644 index 00000000..bc2a7bf4 --- /dev/null +++ b/eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py @@ -0,0 +1,65 @@ +import pandas as pd + + +def _weights_cleanup( + df: pd.DataFrame, w_type: int = 0 +) -> pd.DataFrame: + + drop_cols = ['No_Dep_Cnt', 'Total_Area', 'Total_Deposits', 'Tot_No_Dep_Cnt', + 'Dep_outsidefeat', 'Non_feat_Pxls', 'Non_Feat_Non_Dep', + 'N_cls', 'Num_wpls', 'Deno_wpls', 'var_wpls', 'Num_wmns', + 'Non_Feat_Pxls_cm', 'Deno_wmns', 'var_wmns', 'var_wpls_gen', + 'cmltv_dep_cnt', 'cmltv_cnt', 'cmltv_no_dep_cnt' + ] + + if w_type != 0: + cols_rename = {'Class': 'Class', + 'Point_Count': 'Cmltv. Point Count', + 'Count': 'Cmltv. Count', + 'Act_Count': 'Count_', + 'Act_Point_Count': 'Point Count_', + 'wpls': 'WPlus', + 's_wpls': 'S_WPlus', + 'wmns': 'WMinus', + 's_wmns': 'S_WMinus', + 'contrast': 'Contrast', + 's_contrast': 'S_Contrast', + 'Stud_Cont': 'Stud. Contrast', + 'Rcls': 'Gen_Class', + 'W_Gen': 'Gen_Weights', + 's_wpls_gen': 'S_Gen_Weights' + } + else: + cols_rename = {'Class': 'Class', + 'Point_Count': 'Point Count', + 'Count': 'Count', + 'wpls': 'WPlus', + 's_wpls': 'S_WPlus', + 'wmns': 'WMinus', + 's_wmns': 'S_WMinus', + 'contrast': 'Contrast', + 's_contrast': 'S_Contrast', + 'Stud_Cont': 'Stud. Contrast', + } + df = df.drop([col for col in drop_cols if col in df.columns], + axis=1).rename(columns=cols_rename).round(4) + return df + + +def weights_cleanup( + df: pd.DataFrame, w_type: int = 0 +) -> pd.DataFrame: + """ Removes unnecessary columns and creates a clean dataframe with important spatial associations quantities. + For caterogical data with weights calculations type 'unique', this function is called after the weights calculations. + For numerical data this function is called after reclassification and generalized weights calculations. + + Args: + df (pandas.DataFrame): Data frame with all the calculations; obtained from the contrast function (for categorical data) or from the generalized weights function (for ordinal data) + w_type (int, def = 0): 0 = unique weights, 1 = cumulative ascending weights, 2 = cumulative descending weights + Returns: + df_weights (pandas.DataFrame): Final dataframe with only the necessary values. + + """ + + df_weights = _weights_cleanup(df, w_type) + return df_weights From 674da66f7f610e6c61743a480ba1fc215f516f3f Mon Sep 17 00:00:00 2001 From: chudasama-bijal Date: Tue, 8 Aug 2023 12:53:17 +0300 Subject: [PATCH 07/31] renaming tests and corresponding functions --- .../wofe/wofe_calculate_responses_test.py | 46 +++++++++++++++++++ .../wofe/wofe_calculate_weights_test.py | 46 +++++++++++++++++++ 2 files changed, 92 insertions(+) create mode 100644 tests/prediction/wofe/wofe_calculate_responses_test.py create mode 100644 tests/prediction/wofe/wofe_calculate_weights_test.py diff --git a/tests/prediction/wofe/wofe_calculate_responses_test.py b/tests/prediction/wofe/wofe_calculate_responses_test.py new file mode 100644 index 00000000..50f1d594 --- /dev/null +++ b/tests/prediction/wofe/wofe_calculate_responses_test.py @@ -0,0 +1,46 @@ +import pytest +import numpy as np +from pathlib import Path +import rasterio +import pandas as pd +from pandas.testing import assert_frame_equal + +from eis_toolkit.prediction.weights_of_evidence.calculate_responses import calculate_responses + +parent_dir = Path(__file__).parent.parent.parent +print(parent_dir) + +# Paths of files to be used as inputs to the calculate responses function +wgts_rst_un_path = parent_dir.joinpath("data/remote/wofe/Merged_Unique.tif") +wgts_rst_asc_path = parent_dir.joinpath("data/remote/wofe/Merged_Ascending_.tif") +wgts_rst_dsc_path = parent_dir.joinpath("data/remote/wofe/Merged_Descending_.tif") +dep_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_dep_nan_.tif") + +# Path to the file to compare the results of the calculates responses function +merged_pprb_path = parent_dir.joinpath("data/remote/wofe/Merged_pprbs.tif") + +# Actual testing function +def test_calculate_responses(): + """Tests if calculate_responses function works as intended""" + # expected arrays + pprb_rstrs = rasterio.open(merged_pprb_path) + pprb, std, conf = np.array(pprb_rstrs.read(1)), np.array(pprb_rstrs.read(2)), np.array(pprb_rstrs.read(3)) + exp_pprbs = [pprb, std, conf] + + #input to calculate_responses function + test_dep = rasterio.open(dep_rst_path) + wgts_rstr_paths = [wgts_rst_un_path, wgts_rst_asc_path, wgts_rst_dsc_path] + arrys_list_from_wgts = [] + for path_rst in wgts_rstr_paths: + wgts_rst_o = rasterio.open(path_rst) + pprb_, std_, conf_ = np.array(wgts_rst_o.read(1)), np.array(wgts_rst_o.read(2)), np.array(wgts_rst_o.read(3)) + list_one_block = [pprb_, std_, conf_] + arrys_list_from_wgts.append(list_one_block) + + # Call the calculate_responses function + t_pprb_array, t_pprb_std, t_pprb_conf, array_meta = calculate_responses(test_dep, arrys_list_from_wgts) + result_pprbs = [t_pprb_array, t_pprb_std, t_pprb_conf] + + #compare the results + for res, exp in zip(result_pprbs, exp_pprbs): + assert res.all() == exp.all() diff --git a/tests/prediction/wofe/wofe_calculate_weights_test.py b/tests/prediction/wofe/wofe_calculate_weights_test.py new file mode 100644 index 00000000..d0066628 --- /dev/null +++ b/tests/prediction/wofe/wofe_calculate_weights_test.py @@ -0,0 +1,46 @@ +import pytest +import numpy as np +from pathlib import Path +import rasterio +import pandas as pd +from pandas.testing import assert_frame_equal + +from eis_toolkit.prediction.weights_of_evidence.calculate_weights import calculate_weights + +parent_dir = Path(__file__).parent.parent.parent +print(parent_dir) + +# Paths of files to be used as inputs to the weights_calculations function +ev_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_ev_nan.tif") +dep_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_dep_nan_.tif") + +# Paths to the files to compare the results of the weigths_calculations function to +wgts_rst_un_path = parent_dir.joinpath("data/remote/wofe/Merged_Unique.tif") +wgts_rst_asc_path = parent_dir.joinpath("data/remote/wofe/Merged_Ascending_.tif") +wgts_rst_dsc_path = parent_dir.joinpath("data/remote/wofe/Merged_Descending_.tif") + +wgts_un_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_un.csv") +wgts_asc_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_asc.csv") +wgts_dsc_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_dsc.csv") + +@pytest.mark.parametrize("wgts_type, wgts_df_path, expected", [(0, wgts_un_path, wgts_rst_un_path), (1, wgts_asc_path, wgts_rst_asc_path), (2, wgts_dsc_path, wgts_rst_dsc_path)]) + +def test_calculate_weights( wgts_type, wgts_df_path, expected): + """Tests if calculate_weights function runs as intended; tests for all three weights type""" + #expected results + # weights dataframe + wgts_ = pd.read_csv(wgts_df_path).set_index('Clss') + exp_wgts_df = pd.DataFrame(wgts_) + # weights arrays + wgts_rstr_ = rasterio.open(expected) + clss, wgts, std = np.array(wgts_rstr_.read(1)), np.array(wgts_rstr_.read(2)), np.array(wgts_rstr_.read(3)) + exp_list_arr = [clss, wgts, std] + #inputs to function + ev_rst_ = rasterio.open(ev_rst_path) + dep_rst_ = rasterio.open(dep_rst_path) + #Calling the function + wgts_df, wgts_arr, rst_meta = calculate_weights(ev_rst=ev_rst_, dep_rst= dep_rst_, nan_val = -1000000000.0, w_type=wgts_type, stud_cont=2) + assert_frame_equal(wgts_df, exp_wgts_df, check_dtype=False, check_index_type=False) + for res, exp in zip(wgts_arr, exp_list_arr): + assert res.all() == exp.all() + \ No newline at end of file From 2444e7e0aa9127428c7fa6146401f6e2df7f10a7 Mon Sep 17 00:00:00 2001 From: chudasama-bijal Date: Tue, 8 Aug 2023 12:56:19 +0300 Subject: [PATCH 08/31] file names and corresponding function names were interchanged. And some other minor changes --- .../weights_of_evidence/calculate_weights.py | 92 +++++++++--------- .../weights_calculations.py | 95 +++++++++++-------- 2 files changed, 101 insertions(+), 86 deletions(-) diff --git a/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py b/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py index c3d7fb16..516aaf88 100644 --- a/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py +++ b/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py @@ -1,63 +1,67 @@ -from typing import Tuple, List +from typing import Tuple, List, Dict import rasterio import pandas as pd - -from eis_toolkit.prediction.weights_of_evidence.generalized_weights import weights_generalization -from eis_toolkit.prediction.weights_of_evidence.weights_arrays import weights_arrays -from eis_toolkit.prediction.weights_of_evidence.save_weights import save_weights -from eis_toolkit.prediction.weights_of_evidence.weights import positive_weights, negative_weights, contrast -from eis_toolkit.prediction.weights_of_evidence.weights_type import weights_type +from eis_toolkit.prediction.weights_of_evidence.weights_calculations import weights_calculations +from eis_toolkit.prediction.weights_of_evidence.basic_calculations import basic_calculations +from eis_toolkit.checks.crs import check_matching_crs +#from eis_toolkit.exceptions import NonMatchingCrsException def _calculate_weights( - ev_rst: rasterio.io.DatasetReader, - bsc_clc: pd.DataFrame, - nan_val: float, - w_type: int = 0, stud_cont: float = 2 -) -> Tuple[pd.DataFrame, List, dict]: - - df_wgts_test, df_nan = weights_type( - bsc_clc, nan_val, w_type) # df_nan is not needed - wpls_df = positive_weights(df_wgts_test) - wmns_df = negative_weights(wpls_df, w_type) - contrast_df = contrast(wmns_df) - - if w_type == 0: - cat_wgts = save_weights(contrast_df) - col_names = ['Class', 'WPlus', 'S_WPlus'] - gen_arrys, rstr_meta = weights_arrays(ev_rst, cat_wgts, col_names) - return cat_wgts, gen_arrys, rstr_meta - else: - num_weights = weights_generalization(contrast_df, w_type, stud_cont,) - col_names = ['Gen_Class', 'Gen_Weights', 'S_Gen_Weights'] - gen_arrys, rstr_meta = weights_arrays(ev_rst, num_weights, col_names) - return num_weights, gen_arrys, rstr_meta + ev_rst: rasterio.io.DatasetReader, + dep_rst: rasterio.io.DatasetReader, + nan_val: float, + w_type: int = 0, + stud_cont: float = 2 +) -> Tuple[pd.DataFrame, List, Dict]: + + bsc_clc_df = basic_calculations(ev_rst, dep_rst, nan_val) + weights_df, raster_gen, raster_meta = weights_calculations( + ev_rst, bsc_clc_df, nan_val, w_type, stud_cont) + return weights_df, raster_gen, raster_meta def calculate_weights( - ev_rst: rasterio.io.DatasetReader, - bsc_clc: pd.DataFrame, - nan_val:float, - w_type: int = 0, stud_cont: float = 2 -) -> Tuple[pd.DataFrame, List, dict]: - """ Calculates weights of spatial associations. + ev_rst: rasterio.io.DatasetReader, + dep_rst: rasterio.io.DatasetReader, + nan_val: float, + w_type: int = 0, + stud_cont: float = 2 +) -> Tuple[pd.DataFrame, List, Dict]: + """Calculates weights of spatial associations. Args: - ev_rst (rasterio.io.DatasetReader): The evidential raster. - bsc_clc(pd.DataFrame): Dataframe obtained from basic_calculations function. + ev_rst (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the dep_rst. + dep_rst (rasterio.io.DatasetReader): Raster representing the mineral deposits or occurences point data. nan_val (float): value of no data w_type (int, optional): Accepted values are 0 for unique weights, 1 for cumulative ascending weights, 2 for cumulative descending weights. Defaults to 0. stud_cont (float, optional): studentized contrast value to be used for genralization of classes. Not needed if w_type = 0. Defaults to 2. Returns: - weights_df (pd.DataFrame): Dataframe with weights of spatial association between the input rasters. - gen_arrays (List): List of output raster arrays with generalized or unique classes, generalized weights and standard deviation of generalized weights. - raster_meta (dict): Raster array's metadata. + weights_df (pd.DataFrame): Dataframe with weights of spatial association between the input rasters + raster_gen (List): List of output raster arrays with generalized or unique classes, generalized weights and standard deviation of generalized weights + raster_meta (Dict): Raster array's metadata. - Raises: + Raises: + ValueError: Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. + The below exceptions will be incorporated into the function later as the development for other related functions progresses in the toolkit. + NonMatchingCrsException: The input rasters are not in the same crs + InvalidParameterValueException: Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. (status - pending) + NonMatchingTransformException: The input rasters do not have the same cell size and/or same extent (status - pending) + NonMatchingCoRegistrationException: The input rasters are not coregistered (status - pending) + """ + w_type_acc = [0, 1, 2] + if w_type not in w_type_acc: + raise ValueError( + "Invalid parameter values. Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively") """ + if not check_matching_crs( + objects=[ev_rst, dep_rst] + ): + raise NonMatchingCrsException + """ + weights_df, raster_gen, raster_meta = _calculate_weights(ev_rst, dep_rst, nan_val, w_type, stud_cont) + + return weights_df, raster_gen, raster_meta - weights_df, gen_arrys, raster_meta = _calculate_weights( - ev_rst, bsc_clc, nan_val, w_type, stud_cont) - return weights_df, gen_arrys, raster_meta diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py b/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py index 5ebe0175..da8dcc32 100644 --- a/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py +++ b/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py @@ -1,67 +1,78 @@ from typing import Tuple, List import rasterio import pandas as pd +from enum import Enum -from eis_toolkit.prediction.weights_of_evidence.calculate_weights import calculate_weights -from eis_toolkit.prediction.weights_of_evidence.basic_calculations import basic_calculations -from eis_toolkit.checks.crs import check_matching_crs -from eis_toolkit.exceptions import NonMatchingCrsException +from eis_toolkit.prediction.weights_of_evidence.generalized_weights import weights_generalization +from eis_toolkit.prediction.weights_of_evidence.weights_arrays import weights_arrays +from eis_toolkit.prediction.weights_of_evidence.weights_cleanup import weights_cleanup +from eis_toolkit.prediction.weights_of_evidence.weights import positive_weights, negative_weights, contrast +from eis_toolkit.prediction.weights_of_evidence.weights_type import weights_type + +class WeightsOfEvidenceType(Enum): + Unique = 0 + CumulativeAscending = 1 + CumulativeDescending = 2 + + def __str__(self): + return f'{self.name.lower()}({self.value})' + + def __eq__(self, other): + if isinstance(other, int): + return self.value == other + + if isinstance(other, WeightsOfEvidenceType): + return self is other + + return False def _weights_calculations( ev_rst: rasterio.io.DatasetReader, - dep_rst: rasterio.io.DatasetReader, + bsc_clc: pd.DataFrame, nan_val: float, - w_type: int = 0, - stud_cont: float = 2 + w_type: int = 0, stud_cont: float = 2 ) -> Tuple[pd.DataFrame, List, dict]: - bsc_clc_df = basic_calculations(ev_rst, dep_rst, nan_val) - weights_df, raster_gen, raster_meta = calculate_weights( - ev_rst, bsc_clc_df, nan_val, w_type, stud_cont) - return weights_df, raster_gen, raster_meta + df_wgts_test, df_nan = weights_type( + bsc_clc, nan_val, w_type) # df_nan is not needed + wpls_df = positive_weights(df_wgts_test) + wmns_df = negative_weights(wpls_df, w_type) + contrast_df = contrast(wmns_df) + + if w_type == WeightsOfEvidenceType.Unique: + cat_wgts = weights_cleanup(contrast_df) + col_names = ['Class', 'WPlus', 'S_WPlus'] + gen_arrys, rstr_meta = weights_arrays(ev_rst, cat_wgts, col_names) + return cat_wgts, gen_arrys, rstr_meta + else: + num_weights = weights_generalization(contrast_df, w_type, stud_cont,) + col_names = ['Gen_Class', 'Gen_Weights', 'S_Gen_Weights'] + gen_arrys, rstr_meta = weights_arrays(ev_rst, num_weights, col_names) + return num_weights, gen_arrys, rstr_meta def weights_calculations( - ev_rst: rasterio.io.DatasetReader, - dep_rst: rasterio.io.DatasetReader, - nan_val: float, - w_type: int = 0, - stud_cont: float = 2 + ev_rst: rasterio.io.DatasetReader, + bsc_clc: pd.DataFrame, + nan_val:float, + w_type: int = 0, stud_cont: float = 2 ) -> Tuple[pd.DataFrame, List, dict]: - """Calculates weights of spatial associations. + """ Calculates weights of spatial associations. Args: - ev_rst (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the dep_rst. - dep_rst (rasterio.io.DatasetReader): Raster representing the mineral deposits or occurences point data. + ev_rst (rasterio.io.DatasetReader): The evidential raster. + bsc_clc(pd.DataFrame): Dataframe obtained from basic_calculations function. nan_val (float): value of no data w_type (int, optional): Accepted values are 0 for unique weights, 1 for cumulative ascending weights, 2 for cumulative descending weights. Defaults to 0. stud_cont (float, optional): studentized contrast value to be used for genralization of classes. Not needed if w_type = 0. Defaults to 2. Returns: - weights_df (pd.DataFrame): Dataframe with weights of spatial association between the input rasters - raster_gen (List): List of output raster arrays with generalized or unique classes, generalized weights and standard deviation of generalized weights + weights_df (pd.DataFrame): Dataframe with weights of spatial association between the input rasters. + gen_arrays (List): List of output raster arrays with generalized or unique classes, generalized weights and standard deviation of generalized weights. raster_meta (dict): Raster array's metadata. - Raises: - ValueError: Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. - The below exceptions will be incorporated into the function later as the development for other related functions progresses in the toolkit. - NonMatchingCrsException: The input rasters are not in the same crs - InvalidParameterValueException: Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. (status - pending) - NonMatchingTransformException: The input rasters do not have the same cell size and/or same extent (status - pending) - NonMatchingCoRegistrationException: The input rasters are not coregistered (status - pending) """ - w_type_acc = [0, 1, 2] - if w_type not in w_type_acc: - raise ValueError( - "Invalid parameter values. Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively") - """ - if not check_matching_crs( - objects=[ev_rst, dep_rst] - ): - raise NonMatchingCrsException - """ - weights_df, raster_gen, raster_meta = _weights_calculations(ev_rst, dep_rst, nan_val, w_type, stud_cont) - - return weights_df, raster_gen, raster_meta - + weights_df, gen_arrys, raster_meta = _weights_calculations( + ev_rst, bsc_clc, nan_val, w_type, stud_cont) + return weights_df, gen_arrys, raster_meta From ea8aabd2964344d40b00e4483b4199de4923e2ce Mon Sep 17 00:00:00 2001 From: chudasama-bijal Date: Tue, 8 Aug 2023 12:57:09 +0300 Subject: [PATCH 09/31] added Class Weightsof EvidenceType --- .../weights_of_evidence/weights_type.py | 39 ++++++++++++++----- 1 file changed, 29 insertions(+), 10 deletions(-) diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_type.py b/eis_toolkit/prediction/weights_of_evidence/weights_type.py index e0d8f17f..8bae0c8d 100644 --- a/eis_toolkit/prediction/weights_of_evidence/weights_type.py +++ b/eis_toolkit/prediction/weights_of_evidence/weights_type.py @@ -1,5 +1,23 @@ from typing import Tuple import pandas as pd +from enum import Enum + +class WeightsOfEvidenceType(Enum): + Unique = 0 + CumulativeAscending = 1 + CumulativeDescending = 2 + + def __str__(self): + return f'{self.name.lower()}({self.value})' + + def __eq__(self, other): + if isinstance(other, int): + return self.value == other + + if isinstance(other, WeightsOfEvidenceType): + return self is other + + return False def _weights_type( df: pd.DataFrame, nan_val: float, w_type: int = 0 @@ -12,25 +30,27 @@ def _weights_type( df_rcl_nan = df_rcl.get_group('NaN') pd.set_option('mode.chained_assignment', None) - if (w_type == 0): + if w_type == WeightsOfEvidenceType.Unique: #returns the df with the data classes for categorical weights calculations return df_rcl_dt, df_rcl_nan #for sorting of classes for numerical weights calculations - elif (w_type != 0): + else: #w_type != 0: df_rcl_dt.rename(columns = {"Point_Count":"Act_Point_Count"}, inplace = True) - if (w_type == 1): + if w_type == WeightsOfEvidenceType.CumulativeAscending: df_srtd = df_rcl_dt.sort_values(by = "Class", ascending=True) #return df_srtd - elif (w_type == 2): + elif w_type == WeightsOfEvidenceType.CumulativeDescending: df_srtd = df_rcl_dt.sort_values(by = "Class", ascending=False) pd.set_option('mode.chained_assignment', None) - return (df_srtd + df_data_srtd = (df_srtd .assign(Point_Count = lambda df_srtd: df_srtd.Act_Point_Count.cumsum().replace(0,0.0001)) .assign(cmltv_cnt = lambda df_srtd: df_srtd.Count.cumsum()) - .assign(No_Dep_Cnt = lambda df_srtd: df_srtd.No_Dep_Cnt.cumsum().replace(0, 0.0001)), - df_rcl_nan - ) + .assign(No_Dep_Cnt = lambda df_srtd: df_srtd.No_Dep_Cnt.cumsum().replace(0, 0.0001)) + ) + return df_data_srtd, df_rcl_nan + + def weights_type( df: pd.DataFrame, nan_val: float, w_type: int = 0 @@ -44,8 +64,7 @@ def weights_type( Returns: df_data (pandas.DataFrame): The dataframe with data values and sorted is weights calculations type is numerical (i.e., w_type = 1 or 2) df_nan (pandas.DataFrame): The dataframe with information on NoData - Raises: - + """ w_type_acc = [0,1,2] if w_type not in w_type_acc: From b5a8cdb7f5ac26713672c087d09f8adc005201e2 Mon Sep 17 00:00:00 2001 From: chudasama-bijal Date: Tue, 8 Aug 2023 13:00:58 +0300 Subject: [PATCH 10/31] minor changes related to function renaming --- notebooks/weights_of_evidence.ipynb | 34 ++++++++++++++--------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb index 6e9d37f0..b792d40d 100644 --- a/notebooks/weights_of_evidence.ipynb +++ b/notebooks/weights_of_evidence.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ @@ -52,11 +52,11 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ - "from eis_toolkit.prediction.weights_of_evidence.weights_calculations import weights_calculations " + "from eis_toolkit.prediction.weights_of_evidence.calculate_weights import calculate_weights " ] }, { @@ -69,11 +69,11 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ - "test_wgt_un_, test_gen_un_, test_rst_meta = weights_calculations(test_ev, test_dep, -1000000000.0, 0, 2)" + "test_wgt_un_, test_gen_un_, test_rst_meta = calculate_weights(test_ev, test_dep, -1000000000.0, 0, 2)" ] }, { @@ -86,11 +86,11 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 45, "metadata": {}, "outputs": [], "source": [ - "test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_calculations(test_ev, test_dep, -1000000000.0, 1, 2)" + "test_wgt_asc_, test_gen_asc_, test_rst_meta = calculate_weights(test_ev, test_dep, -1000000000.0, 1, 2)" ] }, { @@ -103,11 +103,11 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ - "test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_calculations(test_ev, test_dep, -1000000000.0, 2, 2)" + "test_wgt_dsc_, test_gen_dsc_, test_rst_meta = calculate_weights(test_ev, test_dep, -1000000000.0, 2, 2)" ] }, { @@ -148,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 47, "metadata": {}, "outputs": [ { @@ -157,7 +157,7 @@ "" ] }, - "execution_count": 8, + "execution_count": 47, "metadata": {}, "output_type": "execute_result" }, @@ -190,7 +190,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 48, "metadata": {}, "outputs": [ { @@ -199,7 +199,7 @@ "" ] }, - "execution_count": 9, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" }, @@ -232,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 49, "metadata": {}, "outputs": [ { @@ -241,7 +241,7 @@ "" ] }, - "execution_count": 10, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" }, From 20517f281ddeb7e77b50941fdd735af6b07bee6f Mon Sep 17 00:00:00 2001 From: chudasama-bijal Date: Tue, 8 Aug 2023 13:17:13 +0300 Subject: [PATCH 11/31] Minor edits --- .../prediction/weights_of_evidence/weights_cleanup.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py b/eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py index bc2a7bf4..306d53ad 100644 --- a/eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py +++ b/eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py @@ -41,8 +41,10 @@ def _weights_cleanup( 's_contrast': 'S_Contrast', 'Stud_Cont': 'Stud. Contrast', } - df = df.drop([col for col in drop_cols if col in df.columns], - axis=1).rename(columns=cols_rename).round(4) + df = (df.drop([col for col in drop_cols if col in df.columns], axis=1) + .rename(columns=cols_rename) + .round(4) + ) return df From fe49952e9023d91f38765f7a1e3e238962e646b0 Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Fri, 11 Aug 2023 11:21:05 +0300 Subject: [PATCH 12/31] New version of wofe, unique weights work, WIP --- eis_toolkit/exceptions.py | 4 +- eis_toolkit/prediction/wofe_new_new.py | 189 ++++++++++ eis_toolkit/prediction/wofe_new_old.py | 466 +++++++++++++++++++++++++ 3 files changed, 657 insertions(+), 2 deletions(-) create mode 100644 eis_toolkit/prediction/wofe_new_new.py create mode 100644 eis_toolkit/prediction/wofe_new_old.py diff --git a/eis_toolkit/exceptions.py b/eis_toolkit/exceptions.py index b393a727..bbc74877 100644 --- a/eis_toolkit/exceptions.py +++ b/eis_toolkit/exceptions.py @@ -48,11 +48,11 @@ class InvalidColumnIndexException(Exception): class UnFavorableClassDoesntExistException(Exception): """Exception error class for failure to generalize classes using the given studentised contrast threshold value. Class 1 (unfavorable class) doesn't exist""" - + class FavorableClassDoesntExistException(Exception): """Exception error class for failure to generalize classes using the given studentised contrast threshold value. Class 2 (favorable class) doesn't exist""" - + class NotApplicableGeometryTypeException(Exception): """Exception error class for not suitable geometry types.""" diff --git a/eis_toolkit/prediction/wofe_new_new.py b/eis_toolkit/prediction/wofe_new_new.py new file mode 100644 index 00000000..d514c379 --- /dev/null +++ b/eis_toolkit/prediction/wofe_new_new.py @@ -0,0 +1,189 @@ +import numpy as np +import pandas as pd +import rasterio +from typing import Literal, Tuple, List, Union, Optional +from numbers import Number +from beartype import beartype +from functools import partial + + +SMALL_NUMBER = 0.0001 +LARGE_NUMBER = 1.0001 +# NODATA_THRESHOLD = 0.0000001 + + +def read_and_preprocess_raster(raster: rasterio.io.DatasetReader, nodata: Optional[Number]) -> np.ndarray: + """Read raster data and handle NoData values.""" + array = np.array(raster.read(1), dtype=np.float32) + + if nodata is not None: + nan_mask = np.isclose(array, np.full(raster.shape, nodata)) + array[nan_mask] = np.nan + elif raster.meta["nodata"] is not None: + array[array == raster.meta["nodata"]] = np.nan + + return array + + +def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray): + A = np.sum(np.logical_and(deposits == 1, evidence == 1)) # Deposit and evidence present + B = np.sum(np.logical_and(deposits == 1, evidence == 0)) # Depsoti present and evidence absent + C = np.sum(np.logical_and(deposits == 0, evidence == 1)) # Deposit absent and evidence present + D = np.sum(np.logical_and(deposits == 0, evidence == 0)) # Depsoti and evidence absent + + CONSTANT = 0.5 + LAPLACE_SMOOTHING = False + REPLACE = True + + if A + B == 0: + raise Exception("No deposits") + if C + D == 0: + raise Exception("No evidence") + + if LAPLACE_SMOOTHING: + p_A = (A + CONSTANT) / (A + B + 2*CONSTANT) + p_C = (C + CONSTANT) / (C + D + 2*CONSTANT) + elif REPLACE: + # The 4 lines below are not needed to avoid errors, but are needed to replicate the original implementation + if A == 0: + A = SMALL_NUMBER + if C == 1: + C = LARGE_NUMBER + p_A = A / (A + B) + p_C = C / (C + D) + if p_A == 0: + p_A = SMALL_NUMBER + elif p_A == 1: + p_A = LARGE_NUMBER + if p_C == 0: + p_C = SMALL_NUMBER + elif p_C == 1: + p_C = LARGE_NUMBER + else: + p_A = A / (A + B) # probability of presence of evidence given the presence of mineral deposit + p_C = C / (C + D) # probability of presence of evidence given the absence of mineral deposit + + w_plus = np.log(p_A / p_C) if p_A != 0 and p_C != 0 else 0 + w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0 + contrast = w_plus - w_minus + + s_w_plus = np.sqrt((1 / A if A != 0 else 0) + (1 / C if C != 0 else 0)) + s_w_minus = np.sqrt((1 / B if B != 0 else 0) + (1 / D if D != 0 else 0)) + s_contrast = np.sqrt(s_w_plus**2 + s_w_minus**2) + + return A, B, C, D, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast + + +def unique_weights(event: np.ndarray, condition: np.ndarray) -> dict: + classes = np.unique(condition[~np.isnan(condition)]) + return {cls: calculate_metrics_for_class(event, condition == cls) for cls in classes} + + +def cumulative_weights(event: np.ndarray, condition: np.ndarray, ascending: bool = True) -> dict: + classes = sorted(np.unique(condition[~np.isnan(condition)]), reverse=not ascending) + cumulative_classes = [classes[:i+1] for i in range(len(classes))] + return {tuple(cls): calculate_metrics_for_class(event, np.isin(condition, cls)) for cls in cumulative_classes} + + +def reclass_by_studentized_contrast(df: pd.DataFrame, studentized_contrast_threshold: float): + """Reclassifies based on the studentized contrast value.""" + df['Reclassified'] = np.where(df['Studentized contrast'] >= studentized_contrast_threshold, 2, 1) + + # Check if both classes are present + unique_classes = df['Reclassified'].unique() + if 1 not in unique_classes: + raise ValueError("Reclassification failed: 'Unfavorable' class (Class 1) doesn't exist.") + elif 2 not in unique_classes: + raise ValueError("Reclassification failed: 'Favorable' class (Class 2) doesn't exist.") + + +# def generate_raster_for_metric(condition: np.ndarray, classes: Union[int, Tuple[int, ...]], metric_value: float) -> np.ndarray: +# """ +# Generates a raster where cells of specified classes are replaced with a metric value. +# Other cells are set to NaN. +# """ +# raster = np.full(condition.shape, np.nan) +# mask = np.isin(condition, classes) +# raster[mask] = metric_value +# return raster + + +# def generate_rasters_from_metrics(evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str] = ["Class", "WPlus", "S_WPlus"]) -> dict: +# """ +# Generates rasters for defined metrics based on the Weights of Evidence calculations. +# """ +# raster_dict = {} +# for metric in metrics_to_include: +# raster = np.full(evidence.shape, np.nan) +# for cls in df["Class"]: +# mask = np.isin(evidence, cls) +# raster[mask] = df["Class"][metric] +# return raster_dict + + +def generate_rasters_from_metrics(evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str] = ["Class", "WPlus", "S_WPlus"]) -> dict: + """ + Generates rasters for defined metrics based on the Weights of Evidence calculations. + """ + raster_dict = {} + for metric in metrics_to_include: + raster = np.full(evidence.shape, np.nan) + for _, row in df.iterrows(): + mask = np.isin(evidence, row["Class"]) + raster[mask] = row[metric] + raster_dict[metric] = raster + return raster_dict + + +# @beartype +def weights_of_evidence( + evidential_raster: rasterio.io.DatasetReader, + deposit_raster: rasterio.io.DatasetReader, + weights_type: Literal['unique', 'ascending', 'descending'] = 'unique', + studentized_contrast: float = 2, +) -> Tuple[pd.DataFrame, dict, dict]: + + # 1. Data preprocessing + deposits = read_and_preprocess_raster(deposit_raster) + evidence = read_and_preprocess_raster(evidential_raster) + + # 2. WoE Calculation + if weights_type == 'unique': + woe_weights = unique_weights(deposits, evidence) + elif weights_type == 'ascending': + woe_weights = cumulative_weights(deposits, evidence, ascending=True) + elif weights_type == 'descending': + woe_weights = cumulative_weights(deposits, evidence, ascending=False) + + # Calculate additional columns based on adjusted_weights + df_entries = [] + for classes, metrics in woe_weights.items(): + metrics = [round(metric, 4) for metric in metrics] + A, _, C, _, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast = metrics + + df_entries.append({ + 'Class': classes, + 'Count': A + C, + 'Point Count': A, + 'WPlus': w_plus, + 'S_WPlus': s_w_plus, + 'WMinus': w_minus, + 'S_WMinus': s_w_minus, + 'Contrast': contrast, + 'S_Contrast': s_contrast, + 'Studentized contrast': contrast / s_contrast + }) + + # 4. Create DataFrame + weights_df = pd.DataFrame(df_entries) + + if weights_type != 'unique': + reclass_by_studentized_contrast(weights_df, studentized_contrast) + + # After the woe_weights computation in the weights_of_evidence function + raster_dict = generate_rasters_from_metrics(evidence, weights_df, ["Class", "WPlus", "S_WPlus"]) + + # 6. Extract raster metadata + raster_meta = evidential_raster.meta + + return weights_df, raster_dict, raster_meta \ No newline at end of file diff --git a/eis_toolkit/prediction/wofe_new_old.py b/eis_toolkit/prediction/wofe_new_old.py new file mode 100644 index 00000000..e0c6b0c2 --- /dev/null +++ b/eis_toolkit/prediction/wofe_new_old.py @@ -0,0 +1,466 @@ +import numpy as np +import functools + +from eis_toolkit import exceptions +from typing import Dict, List, Tuple, Literal + +import pandas as pd +import rasterio + + +SMALL_VALUE = 0.0001 +LARGE_VALUE = 1.0001 + + + +def weights_of_evidence( + evidential_raster: rasterio.io.DatasetReader, + deposit_raster: rasterio.io.DatasetReader, + weights_type: Literal['unique', 'ascending', 'descending'] = 'unique', + studentized_contrast: float = 2, +) -> Tuple[pd.DataFrame, List, Dict]: + """Calculates weights of spatial associations. + + Args: + evidential_raster: The evidential raster with spatial resolution and extent identical to that of the deposit_raster. + deposit_raster: Raster representing the mineral deposits or occurences point data. + weights_type: Accepted values are 'unique' for unique weights, 'ascending' for cumulative ascending weights, + 'descending' for cumulative descending weights. Defaults to 'unique'. + studentized_contrast: Studentized contrast value to be used for genralization of classes. + Not needed if weights_type is 'unique'. Defaults to 2. + + Returns: + weights_df: Dataframe with weights of spatial association between the input rasters + raster_gen: List of output raster arrays with generalized or unique classes, generalized weights + and standard deviation of generalized weights + raster_meta: Raster array's metadata. + + Raises: + ValueError: Accepted values of weights_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. + The below exceptions will be incorporated into the function later as the development for other related functions progresses in the toolkit. + NonMatchingCrsException: The input rasters are not in the same crs + InvalidParameterValueException: Accepted values of weights_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. (status - pending) + NonMatchingTransformException: The input rasters do not have the same cell size and/or same extent (status - pending) + NonMatchingCoRegistrationException: The input rasters are not coregistered (status - pending) + """ + + basic_calculations_df = _basic_calculations(evidential_raster, deposit_raster) + weights_df, raster_gen, raster_meta = _weights_calculations( + evidential_raster, + basic_calculations_df, + weights_type, + studentized_contrast + ) + return weights_df, raster_gen, raster_meta + + +def _basic_calculations( + evidential_raster: rasterio.io.DatasetReader, deposit_raster: rasterio.io.DatasetReader +) -> pd.DataFrame: + """Performs basic calculations about the number of point pixels per class of the input raster. + + Args: + evidential_raster (rasterio.io.DatasetReader): The evidential raster. + deposit_raster (rasterio.io.DatasetReader): Deposit raster. + + Returns: + basic_calculations_df (pandas.DataFrame): dataframe with basic calculations. + """ + + # Read raster data + evidential_array, deposit_array = np.array(evidential_raster.read(1)), np.array(deposit_raster.read(1)) + + # Convert nodata values to np.nan + evidential_array[evidential_array == evidential_raster.meta.nodata] = np.nan + deposit_array[deposit_array == deposit_raster.meta.nodata] = np.nan + + total_pixels = np.size(evidential_array) - np.isnan(evidential_array).sum() + dep1s, dep0s = np.count_nonzero(deposit_array == 1), np.count_nonzero(deposit_array == 0) # CHECK + + df_flat = pd.DataFrame( + {"Class": evidential_array.flatten(), + "Deposits": deposit_array.flatten()} + ) + + geol_dep = df_flat.groupby("Class")["Deposits"] + geol_count = geol_dep.count() + geol_dep_sum = geol_dep.sum() + + basic_calculations_df = pd.DataFrame( + { + "Class": np.unique(evidential_array), + "Count": geol_count, + "Point_Count": geol_dep_sum, + "No_Dep_Cnt": geol_count - geol_dep_sum, + "Total_Area": total_pixels, + "Total_Deposits": dep1s, + "Tot_No_Dep_Cnt": dep0s, + 'Dep_outsidefeat': dep1s - geol_dep_sum, + 'Non_feat_pixels': total_pixels - geol_count, + } + ) + basic_calculations_df['Non_Feat_Non_Dep'] = basic_calculations_df['Non_feat_pixels'] - basic_calculations_df['Dep_outsidefeat'] + + return basic_calculations_df + + +def _weights_calculations( + evidential_raster: rasterio.io.DatasetReader, + basic_calculations_df: pd.DataFrame, + weight_type: Literal['unique', 'ascending', 'descending'], + studentized_contrast: float +) -> Tuple[pd.DataFrame, List, dict]: + """Calculates weights of spatial associations. + + Args: + evidential_raster: The evidential raster. + basic_calculations_df: Dataframe obtained from basic_calculations function. + weights_type: Accepted values are 'unique' for unique weights, 'ascending' for cumulative ascending weights, + 'descending' for cumulative descending weights. + studentized_contrast: Studentized contrast value to be used for genralization of classes. + Not needed if weight_type = 'unique'. + + Returns: + weights_df (pd.DataFrame): Dataframe with weights of spatial association between the input rasters. + gen_arrays (List): List of output raster arrays with generalized or unique classes, generalized weights and standard deviation of generalized weights. + raster_meta (dict): Raster array's metadata. + + """ + weights_df_test = _weights_type(basic_calculations_df, weight_type) + wpls_df = _positive_weights(weights_df_test) + wmns_df = _negative_weights(wpls_df, weight_type) + contrast_df = _contrast(wmns_df) + + if weight_type == 'unique': + cat_wgts = _weights_cleanup(contrast_df) + col_names = ["Class", "WPlus", "S_WPlus"] + gen_arrys, raster_meta = _weights_arrays(evidential_raster, cat_wgts, col_names) + return cat_wgts, gen_arrys, raster_meta + else: + num_weights = _weights_generalization( + contrast_df, + weight_type, + studentized_contrast, + ) + col_names = ["Gen_Class", "Gen_Weights", "S_Gen_Weights"] + gen_arrys, raster_meta = _weights_arrays(evidential_raster, num_weights, col_names) + return num_weights, gen_arrys, raster_meta + + + +def _weights_type(df: pd.DataFrame, weight_type: Literal['unique', 'ascending', 'descending']) -> pd.DataFrame: + """ + Based on the type of weights selected by the user, the function performs the sorting and cumulative count calculations. + + Args: + df (pandas.DataFrame): The dataframe with basic calculations performed in the basic_calculations function + weight_type(str): 'unique' = unique weights, 'ascending' = cumulative ascending weights, + 'descending' = cumulative descending weights + + Returns: + df_data: The dataframe with data values sorted if weights calculation type is numerical + (i.e., weight_type = 'ascending' or 'descending') + """ + # To replace: Point_Count, No_Dep_Cnt + df_data = df.dropna(subset=['Class']) + + if weight_type != 'unique': + df_data = df_data.copy() # Avoid SettingWithCopyWarning + df_data.rename(columns={"Point_Count": "Act_Point_Count"}, inplace=True) + df_data.sort_values(by="Class", ascending=(weight_type == 'ascending'), inplace=True) + df_data['Point_Count'] = df_data['Act_Point_Count'].cumsum() + df_data['cmltv_cnt'] = df_data['Count'].cumsum() + df_data['No_Dep_Cnt'] = df_data['No_Dep_Cnt'].cumsum() + + return df_data + + +def _positive_weights(df: pd.DataFrame) -> pd.DataFrame: + """Calculates positive weights of spatial associations between the input data and the points. + + Args: + df: The dataframe containing data values, obtained from the weights_type function + Returns: + df: The dataframe with positive weights of spatial associaton for each data class + """ + # To replace: Point_Count, Num_wpls (also LARGE) + df['Deno_wpls'] = df['No_Dep_Cnt'] / df['Tot_No_Dep_Cnt'] + df['wpls'] = np.log(df['Num_wpls']) - np.log(df['Deno_wpls']) + df['var_wpls'] = (1 / df['Point_Count']) + (1 / df['No_Dep_Cnt']) + df['s_wpls'] = np.sqrt(df['var_wpls']) + return df + + +def _negative_weights(df_: pd.DataFrame, weight_type: Literal['unique', 'ascending', 'descending']) -> pd.DataFrame: + """Calculates negative weights of spatial associations between the input data and the points. + + Args: + df: The dataframe containing already the positive weights for the data values. + weight_type: 'unique' = unique weights, 'ascending' = cumulative ascending weights, + 'descending' = cumulative descending weights + Returns: + df_wmns: The dataframe with the negative weights of spatial association for each class. + """ + # To replace: Num_wmns, Dep_outsidefeat, Non_Feat_Pxls_cm, Non_Feat_Non_Dep, Deno_wmns + df = df_.copy() + # if weight_type != 0: + # df.rename(columns={"Count": "Act_Count", "cmltv_cnt": "Count"}, inplace=True) + + df["Num_wmns"] = df['Total_Deposits'] - (df['Point_Count'] / df['Total_Deposits']) + df['Dep_outsidefeat'] = df['Total_Deposits'] - df['Point_Count'] + df['Non_Feat_Pxls_cm'] = df['Total_Area'] - df['Count'] + df['Non_Feat_Non_Dep'] = df['Non_Feat_Pxls_cm'] - df['Dep_outsidefeat'] + df['Deno_wmns'] = df['Non_Feat_Pxls_cm'] - (df['Dep_outsidefeat'] / df['Tot_No_Dep_Cnt']) + df['wmns'] = np.log(df['Num_wmns']) - np.log(df['Deno_wmns']) + df['var_wmns'] = (1 / df['Dep_outsidefeat']) + (1 / df['Non_Feat_Non_Dep']) + df['s_wmns'] = np.sqrt(df['var_wmns']) + + df = df.round(4) + + df.loc[df["Num_wmns"] == df["Deno_wmns"], "Num_wmns"] = LARGE_VALUE + return df + + +def _contrast(df: pd.DataFrame) -> pd.DataFrame: + """ + Calculates the contrast and the studentized contrast values from the postive and negative spatial + associations quantified as weights in the positive_weights and negative_weights functions. + + Args: + df: The dataframe containing the positive and negative weights of spatial associations. + Returns: + Dataframe with contrast and studentized contrast values. + """ + df['contrast'] = df['wpls'] - df['wmns'] + df['s_contrast'] = np.sqrt(df['var_wpls'] + df['var_wmns']) + df['Stud_Cont'] = df['contrast'] / df['s_contrast'] + + df = df.round(3) + return df + + + + + + + + + + +def _weights_cleanup(df: pd.DataFrame, weight_type: int = 0) -> pd.DataFrame: + """ + Removes unnecessary columns and creates a clean dataframe with important spatial associations quantities. + For caterogical data with weights calculations type 'unique', this function is called after the weights calculations. + For numerical data this function is called after reclassification and generalized weights calculations. + + Args: + df: Dataframe with all the calculations; obtained from the contrast function (for categorical data) or from the generalized weights function (for ordinal data) + weight_type: + Returns: + Final dataframe with only the necessary values. + """ + + drop_cols = [ + "No_Dep_Cnt", + "Total_Area", + "Total_Deposits", + "Tot_No_Dep_Cnt", + "Dep_outsidefeat", + "Non_feat_pixels", + "Non_Feat_Non_Dep", + "N_cls", + "Num_wpls", + "Deno_wpls", + "var_wpls", + "Num_wmns", + "Non_Feat_Pxls_cm", + "Deno_wmns", + "var_wmns", + "var_wpls_gen", + "cmltv_dep_cnt", + "cmltv_cnt", + "cmltv_no_dep_cnt", + ] + + if weight_type != 0: + cols_rename = { + "Class": "Class", + "Point_Count": "Cmltv. Point Count", + "Count": "Cmltv. Count", + "Act_Count": "Count_", + "Act_Point_Count": "Point Count_", + "wpls": "WPlus", + "s_wpls": "S_WPlus", + "wmns": "WMinus", + "s_wmns": "S_WMinus", + "contrast": "Contrast", + "s_contrast": "S_Contrast", + "Stud_Cont": "Stud. Contrast", + "Rcls": "Gen_Class", + "W_Gen": "Gen_Weights", + "s_wpls_gen": "S_Gen_Weights", + } + else: + cols_rename = { + "Class": "Class", + "Point_Count": "Point Count", + "Count": "Count", + "wpls": "WPlus", + "s_wpls": "S_WPlus", + "wmns": "WMinus", + "s_wmns": "S_WMinus", + "contrast": "Contrast", + "s_contrast": "S_Contrast", + "Stud_Cont": "Stud. Contrast", + } + df = df.drop([col for col in drop_cols if col in df.columns], axis=1).rename(columns=cols_rename).round(4) + return df + + +def _weights_generalization(weights_df: pd.DataFrame, weight_type: int, studentized_contrast: float = 2) -> pd.DataFrame: + """Identifies the favourable and unfavorable classes based on the weights for ascending and descending weights and recalculates the generalized weitghts + Args: + weights_df (pandas.DataFrame): dataframe with the weights + studentized_contrast (float, def = 2): studentized contrast value to be used for genralization of classes + Returns: + wgts_fnl (pandas.DataFrame): dataframe with generalized weights and generalized classes + """ + + rcls_df = _reclass_gen(weights_df, studentized_contrast) + wgts_gen = gen_weights_finalization(rcls_df) + wgts_fnl = _weights_cleanup(wgts_gen, weight_type) + return wgts_fnl + + +def _reclass_gen(df: pd.DataFrame, studentized_contrast: float = 2) -> pd.DataFrame: + """Performs reclassification of classes into favourable and unfavourable categories for ordianl data, based on studentized contrast values provided by the user. + Args: + df (pandas.DataFrame): The dataframe with all the weights calculations; obtained from the contrast function + studentized_contrast (float, def = 2): The threshold for studentized contrast for reclassification + Returns: + df_rcls (pandas.DataFrame): The dataframe with data classes categorized as favourable and unfavourable + Raises: + UnFavorableClassDoesntExistException: Failure to generalize classes using the given studentised contrast threshold value. Class 1 (unfavorable class) doesn't exist + FavorableClassDoesntExistException: Failure to generalize classes using the given studentised contrast threshold value. Class 2 (favorable class) doesn't exist + """ + + df["Rcls"] = df.Stud_Cont.ge(studentized_contrast)[::-1].cummax() + 1 + + df_studentized_contrast = df[["Class", "contrast", "Stud_Cont", "Rcls"]].round(4) + + if 1 not in df["Rcls"].values: + print(df_studentized_contrast) + raise exceptions.UnFavorableClassDoesntExistException( + """Exception error: Class doesn't exist. + For the given studentized contrast value, none of the classes were classified to the 'Unfavorable' class, i.e., class 1. + Check the displayed studentized contrast values ('Stud_Cont') and run weights calculations again using a suitable threshold value.""" + ) + + elif 2 not in df["Rcls"].values: + print(df_studentized_contrast) + raise exceptions.FavorableClassDoesntExistException( + """Exception error: Class doesn't exist. + For the given studentized contrast value none of the classes were classified to the 'Favorable' class, i.e., class 2. + Check the displayed studentized contrast values ('Stud_Cont') and run weights calculations again using a suitable threshold value.""" + ) + + else: + df_ = df.round(4).sort_values(by="Class", ascending=True) + return df_ + + +def gen_weights_finalization(df: pd.DataFrame) -> pd.DataFrame: + """Calls the gen_weights function and calculates positives weights of associations for each generalized class + + Args: + df (pd.DataFrame): Dataframe with weights of associations + Returns: + df (pd.DataFrame): Dataframe with positives weights of associations for generalized classes + """ + gen_cls = [1, 2] + gw_1, gw_2 = map(functools.partial(gen_weights, df), gen_cls) + gw = pd.concat([gw_1, gw_2]) + for i, clss in enumerate(gen_cls): + w = gw.iloc[i, 31] + s_w = gw.iloc[i, 33] + v_w = gw.iloc[i, 32] + df.loc[df.Rcls == clss, "W_Gen"] = w + df.loc[df.Rcls == clss, "s_wpls_gen"] = s_w + df.loc[df.Rcls == clss, "var_wpls_gen"] = v_w + df.round(4) + return df + + +def gen_weights(df: pd.DataFrame, gen_cls: int) -> pd.DataFrame: + """_summary_ + Args: + df (pd.DataFrame): + gen_cls (int): List of generalized class values + Returns: + df_gen_wgts (pd.DataFrame): Dataframe with positives weights of associations for generalized classes + Raises: + + """ + df_rc = df.groupby("Rcls") + df_rc_ = df_rc.get_group(gen_cls) + df_gen_wgts = ( + df_rc_.assign(cmltv_dep_cnt=lambda df_rc_: df_rc_.Point_Count.cumsum()) + .assign(cmltv_cnt=lambda df_rc_: df_rc_.Count.cumsum()) + .assign(cmltv_no_dep_cnt=lambda df_rc_: df_rc_.No_Dep_Cnt.cumsum()) + .iloc[[-1]] + ) + + return ( + df_gen_wgts.assign(Num_wpls=lambda df_gen_wgts: df_gen_wgts.cmltv_dep_cnt / df_gen_wgts.Total_Deposits) + .assign(Deno_wpls=lambda df_gen_wgts: df_gen_wgts.cmltv_no_dep_cnt / df_gen_wgts.Tot_No_Dep_Cnt) + .assign(W_Gen=lambda df_gen_wgts: np.log(df_gen_wgts.Num_wpls) - np.log(df_gen_wgts.Deno_wpls)) + .assign(var_wpls_gen=lambda df_gen_wgts: (1 / df_gen_wgts.cmltv_dep_cnt) + (1 / df_gen_wgts.cmltv_no_dep_cnt)) + .assign(s_wpls_gen=lambda df_gen_wgts: np.sqrt(df_gen_wgts.var_wpls_gen)) + ) + + +def _weights_arrays(evidential_raster: rasterio.io.DatasetReader, weights_df: pd.DataFrame, col_names: List) -> Tuple[List, dict]: + """Calls the raster_arrays function to convert the generalized weights dataaframe to numpy arrays. + + Args: + evidential_raster (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the deposit_raster. + weights_df (pd.DataFrame): Dataframe with the weights. + col_names (List): Columns to generate the arrays from. + + Returns: + gen_arrys (List): List of individual raster object arrays for generalized or unique classes, generalized weights and standard deviation of generalized weights + raster_meta (dict): Raster array's metadata. + """ + raster_meta = evidential_raster.meta.copy() + list_cols = list(weights_df.columns) + nan_row = {val: -1.0e09 for val in list_cols} + nan_row_df = pd.DataFrame.from_dict(nan_row, orient="index") + nan_row_df_t = nan_row_df.T + weights_df_nan = pd.concat([nan_row_df_t, weights_df]) + class_rstr, w_gen_rstr, std_rstr = map(functools.partial(_raster_array, evidential_raster, weights_df_nan), col_names) + gen_arrys = [class_rstr, w_gen_rstr, std_rstr] + return gen_arrys, raster_meta + + +def _raster_array(evidential_raster: rasterio.io.DatasetReader, weights_df_nan: pd.DataFrame, col: str) -> np.ndarray: + """Converts the generalized weights dataframe to numpy arrays with the extent and shape of the input raster + + Args: + evidential_raster (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the deposit_raster. + weights_df_nan (pd.DataFrame): Generalized weights dataframe with info on NaN data also. + col (str): Columns to use for generation of raster object arrays. + + Returns: + np.ndarray: Individual raster object arrays for generalized or unique classes, generalized weights and standard deviation of generalized weights + """ + # raster_meta = evidential_raster.meta.copy() + raster_array = np.array(evidential_raster.read(1)) + weights_mapping_dict = {} + weights_mapping_dict = pd.Series(weights_df_nan.loc[:, col], index=weights_df_nan.Class).to_dict() + replace_array = np.array([list(weights_mapping_dict.keys()), list(weights_mapping_dict.values())]) + raster_array_wgts = raster_array.reshape(-1) + mask_array = np.isin(raster_array_wgts, replace_array[0, :]) + ss_rplc_array = np.searchsorted(replace_array[0, :], raster_array_wgts[mask_array]) + raster_array_replaced = replace_array[1, ss_rplc_array] + raster_array_replaced = raster_array_replaced.reshape(raster_array.shape) + return raster_array_replaced From 78847423ac55f86f813ae0fb7c154d990fc29d4d Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Mon, 14 Aug 2023 09:07:14 +0300 Subject: [PATCH 13/31] Rename, add notebook --- eis_toolkit/prediction/wofe_new.py | 270 +++++++++++ eis_toolkit/prediction/wofe_new_new.py | 189 -------- notebooks/wofe_new.ipynb | 616 +++++++++++++++++++++++++ 3 files changed, 886 insertions(+), 189 deletions(-) create mode 100644 eis_toolkit/prediction/wofe_new.py delete mode 100644 eis_toolkit/prediction/wofe_new_new.py create mode 100644 notebooks/wofe_new.ipynb diff --git a/eis_toolkit/prediction/wofe_new.py b/eis_toolkit/prediction/wofe_new.py new file mode 100644 index 00000000..34996eb4 --- /dev/null +++ b/eis_toolkit/prediction/wofe_new.py @@ -0,0 +1,270 @@ +from numbers import Number +from typing import List, Literal, Optional, Sequence, Tuple, Union + +import numpy as np +import pandas as pd +import rasterio + +# from beartype import beartype + +# REPLACE signifies if we use replacement of 0 and 1 with the values below +# If REPLACE is False but laplace_smoothing is set to True, we use the SMOOTH_CONSTANT to compute p_A and p_C +REPLACE = True +SMALL_NUMBER = 0.0001 +LARGE_NUMBER = 1.0001 + +SMOOTH_CONSTANT = 0.5 + +# NODATA_THRESHOLD = 0.0000001 + + +def read_and_preprocess_raster(raster: rasterio.io.DatasetReader, nodata: Optional[Number] = None) -> np.ndarray: + """Read raster data and handle NoData values.""" + array = np.array(raster.read(1), dtype=np.float32) + + if nodata is not None: + nan_mask = np.isclose(array, np.full(raster.shape, nodata)) + array[nan_mask] = np.nan + elif raster.meta["nodata"] is not None: + array[array == raster.meta["nodata"]] = np.nan + + return array + + +def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray, laplace_smoothing: False): + """Calculate weights/metrics for given data.""" + A = np.sum(np.logical_and(deposits == 1, evidence == 1)) # Deposit and evidence present + B = np.sum(np.logical_and(deposits == 1, evidence == 0)) # Depsoti present and evidence absent + C = np.sum(np.logical_and(deposits == 0, evidence == 1)) # Deposit absent and evidence present + D = np.sum(np.logical_and(deposits == 0, evidence == 0)) # Depsoti and evidence absent + + original_mask_counts = (A, B, C, D) # Save originals to return Laplace smoothing is applied in calculations + + if A + B == 0: + raise Exception("No deposits") + if C + D == 0: + raise Exception("No evidence") + + if not laplace_smoothing: + p_A = A / (A + B) # probability of presence of evidence given the presence of mineral deposit + p_C = C / (C + D) # probability of presence of evidence given the absence of mineral deposit + + else: + if not REPLACE: + p_A = (A + SMOOTH_CONSTANT) / (A + B + 2 * SMOOTH_CONSTANT) + p_C = (C + SMOOTH_CONSTANT) / (C + D + 2 * SMOOTH_CONSTANT) + else: + # NOTE: The 4 lines below are not needed to avoid errors, but are needed to mimic the old implementation + if A == 0: + A = SMALL_NUMBER + if C == 1: + C = LARGE_NUMBER + + p_A = A / (A + B) + p_C = C / (C + D) + if p_A == 0: + p_A = SMALL_NUMBER + elif p_A == 1: + p_A = LARGE_NUMBER + if p_C == 0: + p_C = SMALL_NUMBER + elif p_C == 1: + p_C = LARGE_NUMBER + + # Calculate metrics + w_plus = np.log(p_A / p_C) if p_A != 0 and p_C != 0 else 0 + w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0 + contrast = w_plus - w_minus + + # Calculate signifigance metrics + s_w_plus = np.sqrt((1 / A if A != 0 else 0) + (1 / C if C != 0 else 0)) + s_w_minus = np.sqrt((1 / B if B != 0 else 0) + (1 / D if D != 0 else 0)) + s_contrast = np.sqrt(s_w_plus**2 + s_w_minus**2) + + # Calculate studentized contrast + studentized_contrast = contrast / s_contrast + + return *original_mask_counts, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast, studentized_contrast + + +def unique_weights(deposits: np.ndarray, evidence: np.ndarray, laplace_smoothing: bool) -> dict: + """Calculate unique weights for each class.""" + classes = np.unique(evidence[~np.isnan(evidence)]) + return {cls: calculate_metrics_for_class(deposits, evidence == cls, laplace_smoothing) for cls in classes} + + +def cumulative_weights( + deposits: np.ndarray, evidence: np.ndarray, laplace_smoothing: bool, ascending: bool = True +) -> dict: + """Calculate cumulative weights (ascending or descending) for each class.""" + classes = sorted(np.unique(evidence[~np.isnan(evidence)]), reverse=not ascending) + cumulative_classes = [classes[: i + 1] for i in range(len(classes))] + return { + cls[i]: calculate_metrics_for_class(deposits, np.isin(evidence, cls), laplace_smoothing) + for i, cls in enumerate(cumulative_classes) + } + + +def reclassify_by_studentized_contrast(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: + """Create generalized classes based on the studentized contrast threhsold value.""" + df["Generalized class"] = np.where(df["Studentized contrast"] >= studentized_contrast_threshold, 2, 1) + + # Check if both classes are present + unique_classes = df["Generalized class"].unique() + if 1 not in unique_classes: + raise ValueError("Reclassification failed: 'Unfavorable' class (Class 1) doesn't exist.") + elif 2 not in unique_classes: + raise ValueError("Reclassification failed: 'Favorable' class (Class 2) doesn't exist.") + + +def calculate_generalized_weights(weights_df: pd.DataFrame) -> None: + """ + Calculate generalized weights. + + Implementation for generalized weights that uses a DIFFERENT logic than the original implementation. + """ + generalized_weights = [] + generalized_s_weights = [] + + for gen_cls in weights_df["Generalized class"].tolist(): + subset_df = weights_df[weights_df["Generalized class"] == gen_cls] + + weighted_w_plus_sum = sum(subset_df["WPlus"] * subset_df["Count"]) + total_count = subset_df["Count"].sum() + + generalized_weights.append(round(weighted_w_plus_sum / total_count, 4) if total_count else 0) + + weights_df["Generalized WPlus"] = generalized_weights + weights_df["Generalized S_WPlus"] = generalized_s_weights + + +def calculate_generalized_weights_alternative(weights_df: pd.DataFrame, deposits) -> None: + """ + Calculate generalized weights. + + Implementation for generalized weights that uses the SAME logic as the original implementation. + """ + total_deposits = np.sum(deposits == 1) + total_no_deposits = deposits.size - total_deposits + + generalized_weights = [] + generalized_s_weights = [] + + for gen_cls in weights_df["Generalized class"].tolist(): + subset_df = weights_df[weights_df["Generalized class"] == gen_cls] + + cumulative_deposit_count = subset_df["Point Count"].sum() + cumulative_no_deposit_count = subset_df["Count"].sum() - cumulative_deposit_count + + W_Gen = np.log(cumulative_deposit_count / total_deposits) - np.log( + cumulative_no_deposit_count / total_no_deposits + ) + s_wpls_gen = np.sqrt((1 / cumulative_deposit_count) + (1 / cumulative_no_deposit_count)) + + generalized_weights.append(round(W_Gen, 4)) + generalized_s_weights.append(round(s_wpls_gen, 4)) + + weights_df["Generalized WPlus"] = generalized_weights + weights_df["Generalized S_WPlus"] = generalized_s_weights + + +def generate_rasters_from_metrics( + evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str] = ["Class", "WPlus", "S_WPlus"] +) -> dict: + """Generate rasters for defined metrics based.""" + raster_dict = {} + for metric in metrics_to_include: + raster = np.full(evidence.shape, np.nan) + for _, row in df.iterrows(): + mask = np.isin(evidence, row["Class"]) + raster[mask] = row[metric] + raster_dict[metric] = raster + return raster_dict + + +# @beartype +def weights_of_evidence( + evidential_raster: rasterio.io.DatasetReader, + deposit_raster: rasterio.io.DatasetReader, + weights_type: Literal["unique", "ascending", "descending"] = "unique", + studentized_contrast_threshold: Number = 2, + laplace_smoothing: bool = False, + rasters_to_generate: Union[Sequence[str], str, None] = None, +) -> Tuple[pd.DataFrame, dict, dict]: + """ + Calculate weights of spatial associations. + + Args: + evidential_raster: The evidential raster with spatial resolution and extent dentical + to that of the deposit_raster. + deposit_raster: Raster representing the mineral deposits or occurences point data. + weights_type: Accepted values are 'unique' for unique weights, 'ascending' for cumulative ascending weights, + 'descending' for cumulative descending weights. Defaults to 'unique'. + studentized_contrast_threshold: Studentized contrast threshold value used to reclassify all classes. + Reclassification is used when creating generalized rasters with cumulative weight type selection. + Not needed if weights_type is 'unique'. Defaults to 2. + laplace_smoothing: If smoothing is applied in logarithmic calculations. If no smoothing is applied, + the problematic cases result into weight value of 0 for the class. Defaults to False. + rasters_to_generate: Rasters to generate from the computed weight metrics. All column names + in the produced weights_df are valid choices. If None, defaults to ["Class", "WPlus", "S_WPlus"] + for "unique" weights_type or ["Class", "WPlus", "S_WPlus", "Generalized WPlus", "Generalized S_WPlus"] + for the cumulative weight types. + + Returns: + Dataframe with weights of spatial association between the input rasters. + Dictionary of output raster arrays. + Raster metadata. + """ + + # 1. Data preprocessing + deposits = read_and_preprocess_raster(deposit_raster) + evidence = read_and_preprocess_raster(evidential_raster) + + # 2. WofE calculations + if weights_type == "unique": + wofe_weights = unique_weights(deposits, evidence, laplace_smoothing) + elif weights_type == "ascending": + wofe_weights = cumulative_weights(deposits, evidence, laplace_smoothing, ascending=True) + elif weights_type == "descending": + wofe_weights = cumulative_weights(deposits, evidence, laplace_smoothing, ascending=False) + + # 3. Create dataframe based on calculated metrics + df_entries = [] + for cls, metrics in wofe_weights.items(): + metrics = [round(metric, 3) if isinstance(metric, np.floating) else metric for metric in metrics] + A, _, C, _, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast, studentized_contrast = metrics + df_entries.append( + { + "Class": cls, + "Count": A + C, + "Point Count": A, + "WPlus": w_plus, + "S_WPlus": s_w_plus, + "WMinus": w_minus, + "S_WMinus": s_w_minus, + "Contrast": contrast, + "S_Contrast": s_contrast, + "Studentized contrast": studentized_contrast, + } + ) + weights_df = pd.DataFrame(df_entries) + + # 4. If we use cumulative weights type, reclassify and calculate generalized weights + if weights_type != "unique": + reclassify_by_studentized_contrast(weights_df, studentized_contrast_threshold) + # calculate_generalized_weights(weights_df) + calculate_generalized_weights_alternative(weights_df, deposits) + + metrics_to_rasters = rasters_to_generate + if metrics_to_rasters is None: + metrics_to_rasters = ["Class", "WPlus", "S_WPlus"] + if weights_type != "unique": + metrics_to_rasters += ["Generalized WPlus", "Generalized S_WPlus"] + + # 5. After the wofe_weights computation in the weights_of_evidence function + raster_dict = generate_rasters_from_metrics(evidence, weights_df, metrics_to_rasters) + + # 6. Extract raster metadata + raster_meta = evidential_raster.meta + + return weights_df, raster_dict, raster_meta diff --git a/eis_toolkit/prediction/wofe_new_new.py b/eis_toolkit/prediction/wofe_new_new.py deleted file mode 100644 index d514c379..00000000 --- a/eis_toolkit/prediction/wofe_new_new.py +++ /dev/null @@ -1,189 +0,0 @@ -import numpy as np -import pandas as pd -import rasterio -from typing import Literal, Tuple, List, Union, Optional -from numbers import Number -from beartype import beartype -from functools import partial - - -SMALL_NUMBER = 0.0001 -LARGE_NUMBER = 1.0001 -# NODATA_THRESHOLD = 0.0000001 - - -def read_and_preprocess_raster(raster: rasterio.io.DatasetReader, nodata: Optional[Number]) -> np.ndarray: - """Read raster data and handle NoData values.""" - array = np.array(raster.read(1), dtype=np.float32) - - if nodata is not None: - nan_mask = np.isclose(array, np.full(raster.shape, nodata)) - array[nan_mask] = np.nan - elif raster.meta["nodata"] is not None: - array[array == raster.meta["nodata"]] = np.nan - - return array - - -def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray): - A = np.sum(np.logical_and(deposits == 1, evidence == 1)) # Deposit and evidence present - B = np.sum(np.logical_and(deposits == 1, evidence == 0)) # Depsoti present and evidence absent - C = np.sum(np.logical_and(deposits == 0, evidence == 1)) # Deposit absent and evidence present - D = np.sum(np.logical_and(deposits == 0, evidence == 0)) # Depsoti and evidence absent - - CONSTANT = 0.5 - LAPLACE_SMOOTHING = False - REPLACE = True - - if A + B == 0: - raise Exception("No deposits") - if C + D == 0: - raise Exception("No evidence") - - if LAPLACE_SMOOTHING: - p_A = (A + CONSTANT) / (A + B + 2*CONSTANT) - p_C = (C + CONSTANT) / (C + D + 2*CONSTANT) - elif REPLACE: - # The 4 lines below are not needed to avoid errors, but are needed to replicate the original implementation - if A == 0: - A = SMALL_NUMBER - if C == 1: - C = LARGE_NUMBER - p_A = A / (A + B) - p_C = C / (C + D) - if p_A == 0: - p_A = SMALL_NUMBER - elif p_A == 1: - p_A = LARGE_NUMBER - if p_C == 0: - p_C = SMALL_NUMBER - elif p_C == 1: - p_C = LARGE_NUMBER - else: - p_A = A / (A + B) # probability of presence of evidence given the presence of mineral deposit - p_C = C / (C + D) # probability of presence of evidence given the absence of mineral deposit - - w_plus = np.log(p_A / p_C) if p_A != 0 and p_C != 0 else 0 - w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0 - contrast = w_plus - w_minus - - s_w_plus = np.sqrt((1 / A if A != 0 else 0) + (1 / C if C != 0 else 0)) - s_w_minus = np.sqrt((1 / B if B != 0 else 0) + (1 / D if D != 0 else 0)) - s_contrast = np.sqrt(s_w_plus**2 + s_w_minus**2) - - return A, B, C, D, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast - - -def unique_weights(event: np.ndarray, condition: np.ndarray) -> dict: - classes = np.unique(condition[~np.isnan(condition)]) - return {cls: calculate_metrics_for_class(event, condition == cls) for cls in classes} - - -def cumulative_weights(event: np.ndarray, condition: np.ndarray, ascending: bool = True) -> dict: - classes = sorted(np.unique(condition[~np.isnan(condition)]), reverse=not ascending) - cumulative_classes = [classes[:i+1] for i in range(len(classes))] - return {tuple(cls): calculate_metrics_for_class(event, np.isin(condition, cls)) for cls in cumulative_classes} - - -def reclass_by_studentized_contrast(df: pd.DataFrame, studentized_contrast_threshold: float): - """Reclassifies based on the studentized contrast value.""" - df['Reclassified'] = np.where(df['Studentized contrast'] >= studentized_contrast_threshold, 2, 1) - - # Check if both classes are present - unique_classes = df['Reclassified'].unique() - if 1 not in unique_classes: - raise ValueError("Reclassification failed: 'Unfavorable' class (Class 1) doesn't exist.") - elif 2 not in unique_classes: - raise ValueError("Reclassification failed: 'Favorable' class (Class 2) doesn't exist.") - - -# def generate_raster_for_metric(condition: np.ndarray, classes: Union[int, Tuple[int, ...]], metric_value: float) -> np.ndarray: -# """ -# Generates a raster where cells of specified classes are replaced with a metric value. -# Other cells are set to NaN. -# """ -# raster = np.full(condition.shape, np.nan) -# mask = np.isin(condition, classes) -# raster[mask] = metric_value -# return raster - - -# def generate_rasters_from_metrics(evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str] = ["Class", "WPlus", "S_WPlus"]) -> dict: -# """ -# Generates rasters for defined metrics based on the Weights of Evidence calculations. -# """ -# raster_dict = {} -# for metric in metrics_to_include: -# raster = np.full(evidence.shape, np.nan) -# for cls in df["Class"]: -# mask = np.isin(evidence, cls) -# raster[mask] = df["Class"][metric] -# return raster_dict - - -def generate_rasters_from_metrics(evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str] = ["Class", "WPlus", "S_WPlus"]) -> dict: - """ - Generates rasters for defined metrics based on the Weights of Evidence calculations. - """ - raster_dict = {} - for metric in metrics_to_include: - raster = np.full(evidence.shape, np.nan) - for _, row in df.iterrows(): - mask = np.isin(evidence, row["Class"]) - raster[mask] = row[metric] - raster_dict[metric] = raster - return raster_dict - - -# @beartype -def weights_of_evidence( - evidential_raster: rasterio.io.DatasetReader, - deposit_raster: rasterio.io.DatasetReader, - weights_type: Literal['unique', 'ascending', 'descending'] = 'unique', - studentized_contrast: float = 2, -) -> Tuple[pd.DataFrame, dict, dict]: - - # 1. Data preprocessing - deposits = read_and_preprocess_raster(deposit_raster) - evidence = read_and_preprocess_raster(evidential_raster) - - # 2. WoE Calculation - if weights_type == 'unique': - woe_weights = unique_weights(deposits, evidence) - elif weights_type == 'ascending': - woe_weights = cumulative_weights(deposits, evidence, ascending=True) - elif weights_type == 'descending': - woe_weights = cumulative_weights(deposits, evidence, ascending=False) - - # Calculate additional columns based on adjusted_weights - df_entries = [] - for classes, metrics in woe_weights.items(): - metrics = [round(metric, 4) for metric in metrics] - A, _, C, _, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast = metrics - - df_entries.append({ - 'Class': classes, - 'Count': A + C, - 'Point Count': A, - 'WPlus': w_plus, - 'S_WPlus': s_w_plus, - 'WMinus': w_minus, - 'S_WMinus': s_w_minus, - 'Contrast': contrast, - 'S_Contrast': s_contrast, - 'Studentized contrast': contrast / s_contrast - }) - - # 4. Create DataFrame - weights_df = pd.DataFrame(df_entries) - - if weights_type != 'unique': - reclass_by_studentized_contrast(weights_df, studentized_contrast) - - # After the woe_weights computation in the weights_of_evidence function - raster_dict = generate_rasters_from_metrics(evidence, weights_df, ["Class", "WPlus", "S_WPlus"]) - - # 6. Extract raster metadata - raster_meta = evidential_raster.meta - - return weights_df, raster_dict, raster_meta \ No newline at end of file diff --git a/notebooks/wofe_new.ipynb b/notebooks/wofe_new.ipynb new file mode 100644 index 00000000..bcfc1217 --- /dev/null +++ b/notebooks/wofe_new.ipynb @@ -0,0 +1,616 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import rasterio\n", + "from matplotlib import pyplot as plt\n", + "from rasterio.plot import show\n", + "\n", + "import sys\n", + "sys.path.insert(0, \"..\")\n", + "\n", + "from eis_toolkit.prediction.wofe_new_new import weights_of_evidence" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/niko/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:73: RuntimeWarning: invalid value encountered in log\n", + " w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0\n", + "/home/niko/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:73: RuntimeWarning: invalid value encountered in log\n", + " w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Reclassification failed: 'Favorable' class (Class 2) doesn't exist.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[2], line 5\u001b[0m\n\u001b[1;32m 3\u001b[0m test_wgt_un_, test_gen_un_, test_rst_meta \u001b[39m=\u001b[39m weights_of_evidence(test_ev, test_dep, \u001b[39m'\u001b[39m\u001b[39munique\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m2\u001b[39m, laplace_smoothing\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 4\u001b[0m test_wgt_asc_, test_gen_asc_, test_rst_meta \u001b[39m=\u001b[39m weights_of_evidence(test_ev, test_dep, \u001b[39m'\u001b[39m\u001b[39mascending\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m2\u001b[39m, laplace_smoothing\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[0;32m----> 5\u001b[0m test_wgt_dsc_, test_gen_dsc_, test_rst_meta \u001b[39m=\u001b[39m weights_of_evidence(test_ev, test_dep, \u001b[39m'\u001b[39;49m\u001b[39mdescending\u001b[39;49m\u001b[39m'\u001b[39;49m, \u001b[39m2\u001b[39;49m, laplace_smoothing\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n", + "File \u001b[0;32m~/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:228\u001b[0m, in \u001b[0;36mweights_of_evidence\u001b[0;34m(evidential_raster, deposit_raster, weights_type, studentized_contrast_threshold, laplace_smoothing, rasters_to_generate)\u001b[0m\n\u001b[1;32m 226\u001b[0m \u001b[39m# 4. If we use cumulative weights type, reclassify and calculate generalized weights\u001b[39;00m\n\u001b[1;32m 227\u001b[0m \u001b[39mif\u001b[39;00m weights_type \u001b[39m!=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39munique\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[0;32m--> 228\u001b[0m reclass_by_studentized_contrast(weights_df, studentized_contrast_threshold)\n\u001b[1;32m 229\u001b[0m \u001b[39m# calculate_generalized_weights(weights_df)\u001b[39;00m\n\u001b[1;32m 230\u001b[0m calculate_generalized_weights_alternative(weights_df, deposits)\n", + "File \u001b[0;32m~/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:107\u001b[0m, in \u001b[0;36mreclass_by_studentized_contrast\u001b[0;34m(df, studentized_contrast_threshold)\u001b[0m\n\u001b[1;32m 105\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mReclassification failed: \u001b[39m\u001b[39m'\u001b[39m\u001b[39mUnfavorable\u001b[39m\u001b[39m'\u001b[39m\u001b[39m class (Class 1) doesn\u001b[39m\u001b[39m'\u001b[39m\u001b[39mt exist.\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 106\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39m2\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m unique_classes:\n\u001b[0;32m--> 107\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mReclassification failed: \u001b[39m\u001b[39m'\u001b[39m\u001b[39mFavorable\u001b[39m\u001b[39m'\u001b[39m\u001b[39m class (Class 2) doesn\u001b[39m\u001b[39m'\u001b[39m\u001b[39mt exist.\u001b[39m\u001b[39m\"\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: Reclassification failed: 'Favorable' class (Class 2) doesn't exist." + ] + } + ], + "source": [ + "with rasterio.open(\"../tests/data/remote/wofe/wofe_ev_nan.tif\") as test_ev:\n", + " with rasterio.open(\"../tests/data/remote/wofe/wofe_dep_nan_.tif\") as test_dep:\n", + " test_wgt_un_, test_gen_un_, test_rst_meta = weights_of_evidence(test_ev, test_dep, 'unique', 2, laplace_smoothing=True)\n", + " test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_of_evidence(test_ev, test_dep, 'ascending', 2, laplace_smoothing=True)\n", + " test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_of_evidence(test_ev, test_dep, 'descending', 2, laplace_smoothing=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ClassCountPoint CountWPlusS_WPlusWMinusS_WMinusContrastS_ContrastStudentized contrast
01.027590.8220.339-0.5430.3801.3650.5092.682
12.0110-7.400100.0000.0100.252-7.410100.001-0.074
23.03965-0.1510.4500.0770.304-0.2280.543-0.419
35.04310.4711.012-0.0250.2600.4951.0450.474
46.010-5.002100.0050.0010.252-5.003100.005-0.050
58.0430-8.763100.0000.0410.252-8.804100.000-0.088
610.0214.2081.414-0.0640.2604.2721.4382.971
713.0100-7.305100.0000.0090.252-7.314100.001-0.073
\n", + "
" + ], + "text/plain": [ + " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", + "0 1.0 275 9 0.822 0.339 -0.543 0.380 1.365 \n", + "1 2.0 11 0 -7.400 100.000 0.010 0.252 -7.410 \n", + "2 3.0 396 5 -0.151 0.450 0.077 0.304 -0.228 \n", + "3 5.0 43 1 0.471 1.012 -0.025 0.260 0.495 \n", + "4 6.0 1 0 -5.002 100.005 0.001 0.252 -5.003 \n", + "5 8.0 43 0 -8.763 100.000 0.041 0.252 -8.804 \n", + "6 10.0 2 1 4.208 1.414 -0.064 0.260 4.272 \n", + "7 13.0 10 0 -7.305 100.000 0.009 0.252 -7.314 \n", + "\n", + " S_Contrast Studentized contrast \n", + "0 0.509 2.682 \n", + "1 100.001 -0.074 \n", + "2 0.543 -0.419 \n", + "3 1.045 0.474 \n", + "4 100.005 -0.050 \n", + "5 100.000 -0.088 \n", + "6 1.438 2.971 \n", + "7 100.001 -0.073 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# UNIQUE\n", + "test_wgt_un_" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/niko/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:73: RuntimeWarning: invalid value encountered in log\n", + " w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ClassCountPoint CountWPlusS_WPlusWMinusS_WMinusContrastS_ContrastStudentized contrastGeneralized classGeneralized WPlusGeneralized S_WPlus
01.027590.8220.339-0.5430.3801.3650.5092.68220.80170.2396
12.028690.7820.339-0.5290.3801.3110.5092.57620.80170.2396
23.0682140.3430.270-1.1100.7091.4530.7591.91510.33840.1059
35.0725150.3510.261-1.6941.0012.0451.0351.97710.33840.1059
46.0726150.3500.261-1.6911.0012.0411.0351.97310.33840.1059
58.0769150.2910.261-1.5661.0021.8571.0351.79510.33840.1059
610.0771160.3540.253NaN0.056NaN0.259NaN10.33840.1059
713.0781160.3410.253NaN0.057NaN0.259NaN10.33840.1059
\n", + "
" + ], + "text/plain": [ + " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", + "0 1.0 275 9 0.822 0.339 -0.543 0.380 1.365 \n", + "1 2.0 286 9 0.782 0.339 -0.529 0.380 1.311 \n", + "2 3.0 682 14 0.343 0.270 -1.110 0.709 1.453 \n", + "3 5.0 725 15 0.351 0.261 -1.694 1.001 2.045 \n", + "4 6.0 726 15 0.350 0.261 -1.691 1.001 2.041 \n", + "5 8.0 769 15 0.291 0.261 -1.566 1.002 1.857 \n", + "6 10.0 771 16 0.354 0.253 NaN 0.056 NaN \n", + "7 13.0 781 16 0.341 0.253 NaN 0.057 NaN \n", + "\n", + " S_Contrast Studentized contrast Generalized class Generalized WPlus \\\n", + "0 0.509 2.682 2 0.8017 \n", + "1 0.509 2.576 2 0.8017 \n", + "2 0.759 1.915 1 0.3384 \n", + "3 1.035 1.977 1 0.3384 \n", + "4 1.035 1.973 1 0.3384 \n", + "5 1.035 1.795 1 0.3384 \n", + "6 0.259 NaN 1 0.3384 \n", + "7 0.259 NaN 1 0.3384 \n", + "\n", + " Generalized S_WPlus \n", + "0 0.2396 \n", + "1 0.2396 \n", + "2 0.1059 \n", + "3 0.1059 \n", + "4 0.1059 \n", + "5 0.1059 \n", + "6 0.1059 \n", + "7 0.1059 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ASCENDING\n", + "test_wgt_asc_" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/niko/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:73: RuntimeWarning: invalid value encountered in log\n", + " w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Reclassification failed: 'Favorable' class (Class 2) doesn't exist.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m test_wgt_dsc_, test_gen_dsc_, test_rst_meta \u001b[39m=\u001b[39m weights_of_evidence(test_ev, test_dep, \u001b[39m'\u001b[39;49m\u001b[39mdescending\u001b[39;49m\u001b[39m'\u001b[39;49m, \u001b[39m2\u001b[39;49m, laplace_smoothing\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n\u001b[1;32m 2\u001b[0m test_wgt_dsc_\n", + "File \u001b[0;32m~/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:228\u001b[0m, in \u001b[0;36mweights_of_evidence\u001b[0;34m(evidential_raster, deposit_raster, weights_type, studentized_contrast_threshold, laplace_smoothing, rasters_to_generate)\u001b[0m\n\u001b[1;32m 226\u001b[0m \u001b[39m# 4. If we use cumulative weights type, reclassify and calculate generalized weights\u001b[39;00m\n\u001b[1;32m 227\u001b[0m \u001b[39mif\u001b[39;00m weights_type \u001b[39m!=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39munique\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[0;32m--> 228\u001b[0m reclass_by_studentized_contrast(weights_df, studentized_contrast_threshold)\n\u001b[1;32m 229\u001b[0m \u001b[39m# calculate_generalized_weights(weights_df)\u001b[39;00m\n\u001b[1;32m 230\u001b[0m calculate_generalized_weights_alternative(weights_df, deposits)\n", + "File \u001b[0;32m~/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:107\u001b[0m, in \u001b[0;36mreclass_by_studentized_contrast\u001b[0;34m(df, studentized_contrast_threshold)\u001b[0m\n\u001b[1;32m 105\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mReclassification failed: \u001b[39m\u001b[39m'\u001b[39m\u001b[39mUnfavorable\u001b[39m\u001b[39m'\u001b[39m\u001b[39m class (Class 1) doesn\u001b[39m\u001b[39m'\u001b[39m\u001b[39mt exist.\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 106\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39m2\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m unique_classes:\n\u001b[0;32m--> 107\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mReclassification failed: \u001b[39m\u001b[39m'\u001b[39m\u001b[39mFavorable\u001b[39m\u001b[39m'\u001b[39m\u001b[39m class (Class 2) doesn\u001b[39m\u001b[39m'\u001b[39m\u001b[39mt exist.\u001b[39m\u001b[39m\"\u001b[39m)\n", + "\u001b[0;31mValueError\u001b[0m: Reclassification failed: 'Favorable' class (Class 2) doesn't exist." + ] + } + ], + "source": [ + "# DESCENDING\n", + "test_wgt_dsc_" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (10,10))\n", + "ax.set_title(\"Generalized weights\")\n", + "clrbar = ax.imshow(test_gen_un_[\"WPlus\"], cmap='terrain')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(test_gen_un_[\"WPlus\"], ax = ax, transform = test_ev.transform, cmap='terrain')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (10,10))\n", + "ax.set_title(\"Generalized weights\")\n", + "clrbar = ax.imshow(test_gen_asc_[\"Generalized WPlus\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(test_gen_asc_[\"Generalized WPlus\"], ax = ax, transform = test_ev.transform, cmap='viridis')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize = (10,10))\n", + "ax.set_title(\"Generalized weights\")\n", + "clrbar = ax.imshow(test_gen_dsc_[\"Generalized WPlus\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(test_gen_dsc_[\"Generalized WPlus\"], ax = ax, transform = test_ev.transform, cmap='viridis')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "eis_toolkit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From bce9d0a4831983476be6074d178cca8c211cbbb4 Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Mon, 21 Aug 2023 15:27:09 +0300 Subject: [PATCH 14/31] New versions of wofe --- eis_toolkit/prediction/wofe_new.py | 97 +++-- notebooks/wofe_new.ipynb | 570 ++++++++++++++++++----------- 2 files changed, 409 insertions(+), 258 deletions(-) diff --git a/eis_toolkit/prediction/wofe_new.py b/eis_toolkit/prediction/wofe_new.py index 34996eb4..1e4967b3 100644 --- a/eis_toolkit/prediction/wofe_new.py +++ b/eis_toolkit/prediction/wofe_new.py @@ -1,75 +1,56 @@ from numbers import Number from typing import List, Literal, Optional, Sequence, Tuple, Union +import geopandas as gpd import numpy as np import pandas as pd import rasterio +from eis_toolkit.vector_processing.rasterize_vector import rasterize_vector + # from beartype import beartype # REPLACE signifies if we use replacement of 0 and 1 with the values below # If REPLACE is False but laplace_smoothing is set to True, we use the SMOOTH_CONSTANT to compute p_A and p_C -REPLACE = True +REPLACE = False SMALL_NUMBER = 0.0001 LARGE_NUMBER = 1.0001 -SMOOTH_CONSTANT = 0.5 +SMOOTH_CONSTANT = 1.0 # NODATA_THRESHOLD = 0.0000001 -def read_and_preprocess_raster(raster: rasterio.io.DatasetReader, nodata: Optional[Number] = None) -> np.ndarray: +def read_and_preprocess_evidence(raster: rasterio.io.DatasetReader, nodata: Optional[Number] = None) -> np.ndarray: """Read raster data and handle NoData values.""" array = np.array(raster.read(1), dtype=np.float32) if nodata is not None: - nan_mask = np.isclose(array, np.full(raster.shape, nodata)) - array[nan_mask] = np.nan + array[array == nodata] = np.nan elif raster.meta["nodata"] is not None: array[array == raster.meta["nodata"]] = np.nan return array -def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray, laplace_smoothing: False): +def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray, laplace_smoothing: bool): """Calculate weights/metrics for given data.""" - A = np.sum(np.logical_and(deposits == 1, evidence == 1)) # Deposit and evidence present - B = np.sum(np.logical_and(deposits == 1, evidence == 0)) # Depsoti present and evidence absent - C = np.sum(np.logical_and(deposits == 0, evidence == 1)) # Deposit absent and evidence present - D = np.sum(np.logical_and(deposits == 0, evidence == 0)) # Depsoti and evidence absent - - original_mask_counts = (A, B, C, D) # Save originals to return Laplace smoothing is applied in calculations + A = np.sum(np.logical_and(deposits == 1, evidence == 1)) + B = np.sum(np.logical_and(deposits == 1, evidence == 0)) + C = np.sum(np.logical_and(deposits == 0, evidence == 1)) + D = np.sum(np.logical_and(deposits == 0, evidence == 0)) if A + B == 0: raise Exception("No deposits") if C + D == 0: - raise Exception("No evidence") + raise Exception("All included cells have deposits") if not laplace_smoothing: p_A = A / (A + B) # probability of presence of evidence given the presence of mineral deposit p_C = C / (C + D) # probability of presence of evidence given the absence of mineral deposit - else: - if not REPLACE: - p_A = (A + SMOOTH_CONSTANT) / (A + B + 2 * SMOOTH_CONSTANT) - p_C = (C + SMOOTH_CONSTANT) / (C + D + 2 * SMOOTH_CONSTANT) - else: - # NOTE: The 4 lines below are not needed to avoid errors, but are needed to mimic the old implementation - if A == 0: - A = SMALL_NUMBER - if C == 1: - C = LARGE_NUMBER - - p_A = A / (A + B) - p_C = C / (C + D) - if p_A == 0: - p_A = SMALL_NUMBER - elif p_A == 1: - p_A = LARGE_NUMBER - if p_C == 0: - p_C = SMALL_NUMBER - elif p_C == 1: - p_C = LARGE_NUMBER + p_A = (A + SMOOTH_CONSTANT) / (A + B + 2 * SMOOTH_CONSTANT) + p_C = (C + SMOOTH_CONSTANT) / (C + D + 2 * SMOOTH_CONSTANT) # Calculate metrics w_plus = np.log(p_A / p_C) if p_A != 0 and p_C != 0 else 0 @@ -84,12 +65,12 @@ def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray, lapl # Calculate studentized contrast studentized_contrast = contrast / s_contrast - return *original_mask_counts, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast, studentized_contrast + return A, B, C, D, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast, studentized_contrast def unique_weights(deposits: np.ndarray, evidence: np.ndarray, laplace_smoothing: bool) -> dict: """Calculate unique weights for each class.""" - classes = np.unique(evidence[~np.isnan(evidence)]) + classes = np.unique(evidence) return {cls: calculate_metrics_for_class(deposits, evidence == cls, laplace_smoothing) for cls in classes} @@ -97,7 +78,7 @@ def cumulative_weights( deposits: np.ndarray, evidence: np.ndarray, laplace_smoothing: bool, ascending: bool = True ) -> dict: """Calculate cumulative weights (ascending or descending) for each class.""" - classes = sorted(np.unique(evidence[~np.isnan(evidence)]), reverse=not ascending) + classes = sorted(np.unique(evidence), reverse=not ascending) cumulative_classes = [classes[: i + 1] for i in range(len(classes))] return { cls[i]: calculate_metrics_for_class(deposits, np.isin(evidence, cls), laplace_smoothing) @@ -185,7 +166,7 @@ def generate_rasters_from_metrics( # @beartype def weights_of_evidence( evidential_raster: rasterio.io.DatasetReader, - deposit_raster: rasterio.io.DatasetReader, + deposits: gpd.GeoDataFrame, weights_type: Literal["unique", "ascending", "descending"] = "unique", studentized_contrast_threshold: Number = 2, laplace_smoothing: bool = False, @@ -195,9 +176,8 @@ def weights_of_evidence( Calculate weights of spatial associations. Args: - evidential_raster: The evidential raster with spatial resolution and extent dentical - to that of the deposit_raster. - deposit_raster: Raster representing the mineral deposits or occurences point data. + evidential_raster: The evidential raster. + deposits: Vector data representing the mineral deposits or occurences point data. weights_type: Accepted values are 'unique' for unique weights, 'ascending' for cumulative ascending weights, 'descending' for cumulative descending weights. Defaults to 'unique'. studentized_contrast_threshold: Studentized contrast threshold value used to reclassify all classes. @@ -217,16 +197,34 @@ def weights_of_evidence( """ # 1. Data preprocessing - deposits = read_and_preprocess_raster(deposit_raster) - evidence = read_and_preprocess_raster(evidential_raster) + + # Read evidence raster + evidence_array = read_and_preprocess_evidence(evidential_raster) + + # Extract raster metadata + raster_meta = evidential_raster.meta + + # Rasterize deposits + deposit_array, _ = rasterize_vector( + geodataframe=deposits, default_value=1.0, base_raster_profile=raster_meta, fill_value=0.0 + ) + + # Mask NaN out of the array + nodata_mask = np.isnan(evidence_array) + masked_evidence_array = evidence_array[~nodata_mask] + masked_deposit_array = deposit_array[~nodata_mask] # 2. WofE calculations if weights_type == "unique": - wofe_weights = unique_weights(deposits, evidence, laplace_smoothing) + wofe_weights = unique_weights(masked_deposit_array, masked_evidence_array, laplace_smoothing) elif weights_type == "ascending": - wofe_weights = cumulative_weights(deposits, evidence, laplace_smoothing, ascending=True) + wofe_weights = cumulative_weights( + masked_deposit_array, masked_evidence_array, laplace_smoothing, ascending=True + ) elif weights_type == "descending": - wofe_weights = cumulative_weights(deposits, evidence, laplace_smoothing, ascending=False) + wofe_weights = cumulative_weights( + masked_deposit_array, masked_evidence_array, laplace_smoothing, ascending=False + ) # 3. Create dataframe based on calculated metrics df_entries = [] @@ -253,7 +251,7 @@ def weights_of_evidence( if weights_type != "unique": reclassify_by_studentized_contrast(weights_df, studentized_contrast_threshold) # calculate_generalized_weights(weights_df) - calculate_generalized_weights_alternative(weights_df, deposits) + calculate_generalized_weights_alternative(weights_df, masked_deposit_array) metrics_to_rasters = rasters_to_generate if metrics_to_rasters is None: @@ -262,9 +260,6 @@ def weights_of_evidence( metrics_to_rasters += ["Generalized WPlus", "Generalized S_WPlus"] # 5. After the wofe_weights computation in the weights_of_evidence function - raster_dict = generate_rasters_from_metrics(evidence, weights_df, metrics_to_rasters) - - # 6. Extract raster metadata - raster_meta = evidential_raster.meta + raster_dict = generate_rasters_from_metrics(evidence_array, weights_df, metrics_to_rasters) return weights_df, raster_dict, raster_meta diff --git a/notebooks/wofe_new.ipynb b/notebooks/wofe_new.ipynb index bcfc1217..fe270a80 100644 --- a/notebooks/wofe_new.ipynb +++ b/notebooks/wofe_new.ipynb @@ -9,53 +9,33 @@ "import rasterio\n", "from matplotlib import pyplot as plt\n", "from rasterio.plot import show\n", + "import geopandas as gpd\n", "\n", "import sys\n", "sys.path.insert(0, \"..\")\n", "\n", - "from eis_toolkit.prediction.wofe_new_new import weights_of_evidence" + "from eis_toolkit.prediction.wofe_new import weights_of_evidence" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/niko/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:73: RuntimeWarning: invalid value encountered in log\n", - " w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0\n", - "/home/niko/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:73: RuntimeWarning: invalid value encountered in log\n", - " w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0\n" - ] - }, - { - "ename": "ValueError", - "evalue": "Reclassification failed: 'Favorable' class (Class 2) doesn't exist.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[2], line 5\u001b[0m\n\u001b[1;32m 3\u001b[0m test_wgt_un_, test_gen_un_, test_rst_meta \u001b[39m=\u001b[39m weights_of_evidence(test_ev, test_dep, \u001b[39m'\u001b[39m\u001b[39munique\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m2\u001b[39m, laplace_smoothing\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 4\u001b[0m test_wgt_asc_, test_gen_asc_, test_rst_meta \u001b[39m=\u001b[39m weights_of_evidence(test_ev, test_dep, \u001b[39m'\u001b[39m\u001b[39mascending\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m2\u001b[39m, laplace_smoothing\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[0;32m----> 5\u001b[0m test_wgt_dsc_, test_gen_dsc_, test_rst_meta \u001b[39m=\u001b[39m weights_of_evidence(test_ev, test_dep, \u001b[39m'\u001b[39;49m\u001b[39mdescending\u001b[39;49m\u001b[39m'\u001b[39;49m, \u001b[39m2\u001b[39;49m, laplace_smoothing\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n", - "File \u001b[0;32m~/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:228\u001b[0m, in \u001b[0;36mweights_of_evidence\u001b[0;34m(evidential_raster, deposit_raster, weights_type, studentized_contrast_threshold, laplace_smoothing, rasters_to_generate)\u001b[0m\n\u001b[1;32m 226\u001b[0m \u001b[39m# 4. If we use cumulative weights type, reclassify and calculate generalized weights\u001b[39;00m\n\u001b[1;32m 227\u001b[0m \u001b[39mif\u001b[39;00m weights_type \u001b[39m!=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39munique\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[0;32m--> 228\u001b[0m reclass_by_studentized_contrast(weights_df, studentized_contrast_threshold)\n\u001b[1;32m 229\u001b[0m \u001b[39m# calculate_generalized_weights(weights_df)\u001b[39;00m\n\u001b[1;32m 230\u001b[0m calculate_generalized_weights_alternative(weights_df, deposits)\n", - "File \u001b[0;32m~/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:107\u001b[0m, in \u001b[0;36mreclass_by_studentized_contrast\u001b[0;34m(df, studentized_contrast_threshold)\u001b[0m\n\u001b[1;32m 105\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mReclassification failed: \u001b[39m\u001b[39m'\u001b[39m\u001b[39mUnfavorable\u001b[39m\u001b[39m'\u001b[39m\u001b[39m class (Class 1) doesn\u001b[39m\u001b[39m'\u001b[39m\u001b[39mt exist.\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 106\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39m2\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m unique_classes:\n\u001b[0;32m--> 107\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mReclassification failed: \u001b[39m\u001b[39m'\u001b[39m\u001b[39mFavorable\u001b[39m\u001b[39m'\u001b[39m\u001b[39m class (Class 2) doesn\u001b[39m\u001b[39m'\u001b[39m\u001b[39mt exist.\u001b[39m\u001b[39m\"\u001b[39m)\n", - "\u001b[0;31mValueError\u001b[0m: Reclassification failed: 'Favorable' class (Class 2) doesn't exist." - ] - } - ], + "outputs": [], "source": [ - "with rasterio.open(\"../tests/data/remote/wofe/wofe_ev_nan.tif\") as test_ev:\n", - " with rasterio.open(\"../tests/data/remote/wofe/wofe_dep_nan_.tif\") as test_dep:\n", - " test_wgt_un_, test_gen_un_, test_rst_meta = weights_of_evidence(test_ev, test_dep, 'unique', 2, laplace_smoothing=True)\n", - " test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_of_evidence(test_ev, test_dep, 'ascending', 2, laplace_smoothing=True)\n", - " test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_of_evidence(test_ev, test_dep, 'descending', 2, laplace_smoothing=True)" + "# with rasterio.open(\"../tests/data/remote/wofe/wofe_ev_nan.tif\") as test_ev:\n", + "# with rasterio.open(\"../tests/data/remote/wofe/wofe_dep_nan_.tif\") as test_dep:\n", + "with rasterio.open(\"../tests/data/local/Int_wofe_ev_nan.tif\") as test_ev:\n", + " # with rasterio.open(\"../tests/data/local/wofe_dep_new.tif\") as test_dep:\n", + " gdf = gpd.read_file(\"../tests/data/local/Dep1s.shp\")\n", + " test_wgt_un_, test_gen_un_, test_rst_meta = weights_of_evidence(test_ev, gdf, 'unique')\n", + " test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_of_evidence(test_ev, gdf, 'ascending', 1)\n", + " test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_of_evidence(test_ev, gdf, 'descending', 1)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -97,104 +77,104 @@ " 1.0\n", " 275\n", " 9\n", - " 0.822\n", + " 0.481\n", " 0.339\n", - " -0.543\n", - " 0.380\n", - " 1.365\n", - " 0.509\n", - " 2.682\n", + " -0.399\n", + " 0.381\n", + " 0.880\n", + " 0.510\n", + " 1.728\n", " \n", " \n", " 1\n", " 2.0\n", " 11\n", " 0\n", - " -7.400\n", - " 100.000\n", - " 0.010\n", - " 0.252\n", - " -7.410\n", - " 100.001\n", - " -0.074\n", + " 0.000\n", + " 0.302\n", + " 0.014\n", + " 0.253\n", + " -0.014\n", + " 0.393\n", + " -0.037\n", " \n", " \n", " 2\n", " 3.0\n", " 396\n", " 5\n", - " -0.151\n", + " -0.492\n", " 0.450\n", - " 0.077\n", - " 0.304\n", - " -0.228\n", - " 0.543\n", - " -0.419\n", + " 0.341\n", + " 0.306\n", + " -0.833\n", + " 0.544\n", + " -1.531\n", " \n", " \n", " 3\n", " 5.0\n", " 43\n", " 1\n", - " 0.471\n", + " 0.130\n", " 1.012\n", - " -0.025\n", - " 0.260\n", - " 0.495\n", + " -0.008\n", + " 0.261\n", + " 0.138\n", " 1.045\n", - " 0.474\n", + " 0.132\n", " \n", " \n", " 4\n", " 6.0\n", " 1\n", " 0\n", - " -5.002\n", - " 100.005\n", + " 0.000\n", + " 1.000\n", " 0.001\n", - " 0.252\n", - " -5.003\n", - " 100.005\n", - " -0.050\n", + " 0.253\n", + " -0.001\n", + " 1.031\n", + " -0.001\n", " \n", " \n", " 5\n", " 8.0\n", " 43\n", " 0\n", - " -8.763\n", - " 100.000\n", - " 0.041\n", - " 0.252\n", - " -8.804\n", - " 100.000\n", - " -0.088\n", + " 0.000\n", + " 0.152\n", + " 0.058\n", + " 0.253\n", + " -0.058\n", + " 0.295\n", + " -0.196\n", " \n", " \n", " 6\n", " 10.0\n", " 2\n", " 1\n", - " 4.208\n", + " 3.867\n", " 1.414\n", - " -0.064\n", - " 0.260\n", - " 4.272\n", + " -0.063\n", + " 0.261\n", + " 3.931\n", " 1.438\n", - " 2.971\n", + " 2.733\n", " \n", " \n", " 7\n", " 13.0\n", " 10\n", " 0\n", - " -7.305\n", - " 100.000\n", - " 0.009\n", - " 0.252\n", - " -7.314\n", - " 100.001\n", - " -0.073\n", + " 0.000\n", + " 0.316\n", + " 0.013\n", + " 0.253\n", + " -0.013\n", + " 0.405\n", + " -0.033\n", " \n", " \n", "\n", @@ -202,24 +182,24 @@ ], "text/plain": [ " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", - "0 1.0 275 9 0.822 0.339 -0.543 0.380 1.365 \n", - "1 2.0 11 0 -7.400 100.000 0.010 0.252 -7.410 \n", - "2 3.0 396 5 -0.151 0.450 0.077 0.304 -0.228 \n", - "3 5.0 43 1 0.471 1.012 -0.025 0.260 0.495 \n", - "4 6.0 1 0 -5.002 100.005 0.001 0.252 -5.003 \n", - "5 8.0 43 0 -8.763 100.000 0.041 0.252 -8.804 \n", - "6 10.0 2 1 4.208 1.414 -0.064 0.260 4.272 \n", - "7 13.0 10 0 -7.305 100.000 0.009 0.252 -7.314 \n", + "0 1.0 275 9 0.481 0.339 -0.399 0.381 0.880 \n", + "1 2.0 11 0 0.000 0.302 0.014 0.253 -0.014 \n", + "2 3.0 396 5 -0.492 0.450 0.341 0.306 -0.833 \n", + "3 5.0 43 1 0.130 1.012 -0.008 0.261 0.138 \n", + "4 6.0 1 0 0.000 1.000 0.001 0.253 -0.001 \n", + "5 8.0 43 0 0.000 0.152 0.058 0.253 -0.058 \n", + "6 10.0 2 1 3.867 1.414 -0.063 0.261 3.931 \n", + "7 13.0 10 0 0.000 0.316 0.013 0.253 -0.013 \n", "\n", " S_Contrast Studentized contrast \n", - "0 0.509 2.682 \n", - "1 100.001 -0.074 \n", - "2 0.543 -0.419 \n", - "3 1.045 0.474 \n", - "4 100.005 -0.050 \n", - "5 100.000 -0.088 \n", - "6 1.438 2.971 \n", - "7 100.001 -0.073 " + "0 0.510 1.728 \n", + "1 0.393 -0.037 \n", + "2 0.544 -1.531 \n", + "3 1.045 0.132 \n", + "4 1.031 -0.001 \n", + "5 0.295 -0.196 \n", + "6 1.438 2.733 \n", + "7 0.405 -0.033 " ] }, "execution_count": 3, @@ -234,17 +214,9 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/niko/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:73: RuntimeWarning: invalid value encountered in log\n", - " w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0\n" - ] - }, { "data": { "text/html": [ @@ -287,15 +259,15 @@ " 1.0\n", " 275\n", " 9\n", - " 0.822\n", + " 0.481\n", " 0.339\n", - " -0.543\n", - " 0.380\n", - " 1.365\n", - " 0.509\n", - " 2.682\n", + " -0.399\n", + " 0.381\n", + " 0.880\n", + " 0.510\n", + " 1.728\n", " 2\n", - " 0.8017\n", + " 0.4605\n", " 0.2396\n", " \n", " \n", @@ -303,15 +275,15 @@ " 2.0\n", " 286\n", " 9\n", - " 0.782\n", + " 0.440\n", " 0.339\n", - " -0.529\n", - " 0.380\n", - " 1.311\n", - " 0.509\n", - " 2.576\n", + " -0.377\n", + " 0.381\n", + " 0.818\n", + " 0.510\n", + " 1.605\n", " 2\n", - " 0.8017\n", + " 0.4605\n", " 0.2396\n", " \n", " \n", @@ -319,15 +291,15 @@ " 3.0\n", " 682\n", " 14\n", - " 0.343\n", + " 0.002\n", " 0.270\n", - " -1.110\n", - " 0.709\n", - " 1.453\n", - " 0.759\n", - " 1.915\n", + " -0.014\n", + " 0.714\n", + " 0.016\n", + " 0.764\n", + " 0.021\n", " 1\n", - " 0.3384\n", + " -0.0028\n", " 0.1059\n", " \n", " \n", @@ -335,15 +307,15 @@ " 5.0\n", " 725\n", " 15\n", - " 0.351\n", + " 0.010\n", " 0.261\n", - " -1.694\n", - " 1.001\n", - " 2.045\n", - " 1.035\n", - " 1.977\n", + " -0.140\n", + " 1.009\n", + " 0.150\n", + " 1.042\n", + " 0.144\n", " 1\n", - " 0.3384\n", + " -0.0028\n", " 0.1059\n", " \n", " \n", @@ -351,15 +323,15 @@ " 6.0\n", " 726\n", " 15\n", - " 0.350\n", + " 0.009\n", " 0.261\n", - " -1.691\n", - " 1.001\n", - " 2.041\n", - " 1.035\n", - " 1.973\n", + " -0.122\n", + " 1.009\n", + " 0.130\n", + " 1.042\n", + " 0.125\n", " 1\n", - " 0.3384\n", + " -0.0028\n", " 0.1059\n", " \n", " \n", @@ -367,15 +339,15 @@ " 8.0\n", " 769\n", " 15\n", - " 0.291\n", + " -0.050\n", " 0.261\n", - " -1.566\n", - " 1.002\n", - " 1.857\n", - " 1.035\n", - " 1.795\n", + " 1.469\n", + " 1.044\n", + " -1.519\n", + " 1.077\n", + " -1.411\n", " 1\n", - " 0.3384\n", + " -0.0028\n", " 0.1059\n", " \n", " \n", @@ -383,15 +355,15 @@ " 10.0\n", " 771\n", " 16\n", - " 0.354\n", + " 0.013\n", " 0.253\n", - " NaN\n", - " 0.056\n", - " NaN\n", - " 0.259\n", - " NaN\n", + " 0.000\n", + " 0.316\n", + " 0.013\n", + " 0.405\n", + " 0.033\n", " 1\n", - " 0.3384\n", + " -0.0028\n", " 0.1059\n", " \n", " \n", @@ -399,15 +371,15 @@ " 13.0\n", " 781\n", " 16\n", - " 0.341\n", + " 0.000\n", " 0.253\n", - " NaN\n", - " 0.057\n", - " NaN\n", - " 0.259\n", - " NaN\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.253\n", + " 0.000\n", " 1\n", - " 0.3384\n", + " -0.0028\n", " 0.1059\n", " \n", " \n", @@ -416,24 +388,24 @@ ], "text/plain": [ " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", - "0 1.0 275 9 0.822 0.339 -0.543 0.380 1.365 \n", - "1 2.0 286 9 0.782 0.339 -0.529 0.380 1.311 \n", - "2 3.0 682 14 0.343 0.270 -1.110 0.709 1.453 \n", - "3 5.0 725 15 0.351 0.261 -1.694 1.001 2.045 \n", - "4 6.0 726 15 0.350 0.261 -1.691 1.001 2.041 \n", - "5 8.0 769 15 0.291 0.261 -1.566 1.002 1.857 \n", - "6 10.0 771 16 0.354 0.253 NaN 0.056 NaN \n", - "7 13.0 781 16 0.341 0.253 NaN 0.057 NaN \n", + "0 1.0 275 9 0.481 0.339 -0.399 0.381 0.880 \n", + "1 2.0 286 9 0.440 0.339 -0.377 0.381 0.818 \n", + "2 3.0 682 14 0.002 0.270 -0.014 0.714 0.016 \n", + "3 5.0 725 15 0.010 0.261 -0.140 1.009 0.150 \n", + "4 6.0 726 15 0.009 0.261 -0.122 1.009 0.130 \n", + "5 8.0 769 15 -0.050 0.261 1.469 1.044 -1.519 \n", + "6 10.0 771 16 0.013 0.253 0.000 0.316 0.013 \n", + "7 13.0 781 16 0.000 0.253 0.000 0.000 0.000 \n", "\n", " S_Contrast Studentized contrast Generalized class Generalized WPlus \\\n", - "0 0.509 2.682 2 0.8017 \n", - "1 0.509 2.576 2 0.8017 \n", - "2 0.759 1.915 1 0.3384 \n", - "3 1.035 1.977 1 0.3384 \n", - "4 1.035 1.973 1 0.3384 \n", - "5 1.035 1.795 1 0.3384 \n", - "6 0.259 NaN 1 0.3384 \n", - "7 0.259 NaN 1 0.3384 \n", + "0 0.510 1.728 2 0.4605 \n", + "1 0.510 1.605 2 0.4605 \n", + "2 0.764 0.021 1 -0.0028 \n", + "3 1.042 0.144 1 -0.0028 \n", + "4 1.042 0.125 1 -0.0028 \n", + "5 1.077 -1.411 1 -0.0028 \n", + "6 0.405 0.033 1 -0.0028 \n", + "7 0.253 0.000 1 -0.0028 \n", "\n", " Generalized S_WPlus \n", "0 0.2396 \n", @@ -458,29 +430,213 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/niko/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:73: RuntimeWarning: invalid value encountered in log\n", - " w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0\n" - ] - }, - { - "ename": "ValueError", - "evalue": "Reclassification failed: 'Favorable' class (Class 2) doesn't exist.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[5], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m test_wgt_dsc_, test_gen_dsc_, test_rst_meta \u001b[39m=\u001b[39m weights_of_evidence(test_ev, test_dep, \u001b[39m'\u001b[39;49m\u001b[39mdescending\u001b[39;49m\u001b[39m'\u001b[39;49m, \u001b[39m2\u001b[39;49m, laplace_smoothing\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n\u001b[1;32m 2\u001b[0m test_wgt_dsc_\n", - "File \u001b[0;32m~/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:228\u001b[0m, in \u001b[0;36mweights_of_evidence\u001b[0;34m(evidential_raster, deposit_raster, weights_type, studentized_contrast_threshold, laplace_smoothing, rasters_to_generate)\u001b[0m\n\u001b[1;32m 226\u001b[0m \u001b[39m# 4. If we use cumulative weights type, reclassify and calculate generalized weights\u001b[39;00m\n\u001b[1;32m 227\u001b[0m \u001b[39mif\u001b[39;00m weights_type \u001b[39m!=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39munique\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[0;32m--> 228\u001b[0m reclass_by_studentized_contrast(weights_df, studentized_contrast_threshold)\n\u001b[1;32m 229\u001b[0m \u001b[39m# calculate_generalized_weights(weights_df)\u001b[39;00m\n\u001b[1;32m 230\u001b[0m calculate_generalized_weights_alternative(weights_df, deposits)\n", - "File \u001b[0;32m~/code/plugin_dev/eis_toolkit/notebooks/../eis_toolkit/prediction/wofe_new_new.py:107\u001b[0m, in \u001b[0;36mreclass_by_studentized_contrast\u001b[0;34m(df, studentized_contrast_threshold)\u001b[0m\n\u001b[1;32m 105\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mReclassification failed: \u001b[39m\u001b[39m'\u001b[39m\u001b[39mUnfavorable\u001b[39m\u001b[39m'\u001b[39m\u001b[39m class (Class 1) doesn\u001b[39m\u001b[39m'\u001b[39m\u001b[39mt exist.\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 106\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39m2\u001b[39m \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m unique_classes:\n\u001b[0;32m--> 107\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mReclassification failed: \u001b[39m\u001b[39m'\u001b[39m\u001b[39mFavorable\u001b[39m\u001b[39m'\u001b[39m\u001b[39m class (Class 2) doesn\u001b[39m\u001b[39m'\u001b[39m\u001b[39mt exist.\u001b[39m\u001b[39m\"\u001b[39m)\n", - "\u001b[0;31mValueError\u001b[0m: Reclassification failed: 'Favorable' class (Class 2) doesn't exist." - ] + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ClassCountPoint CountWPlusS_WPlusWMinusS_WMinusContrastS_ContrastStudentized contrastGeneralized classGeneralized WPlusGeneralized S_WPlus
013.01000.0000.3160.0130.253-0.0130.405-0.0331-0.19110.1730
110.01211.4691.044-0.0500.2611.5191.0771.41121.46941.0445
28.0551-0.1221.0090.0090.261-0.1301.042-0.1251-0.19110.1730
36.0561-0.1401.0090.0100.261-0.1501.042-0.1441-0.19110.1730
45.0992-0.0140.7140.0020.270-0.0160.764-0.0211-0.19110.1730
53.04957-0.3770.3810.4400.339-0.8180.510-1.6051-0.19110.1730
62.05067-0.3990.3810.4810.339-0.8800.510-1.7281-0.19110.1730
71.0781160.0000.2530.0000.0000.0000.2530.0001-0.19110.1730
\n", + "
" + ], + "text/plain": [ + " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", + "0 13.0 10 0 0.000 0.316 0.013 0.253 -0.013 \n", + "1 10.0 12 1 1.469 1.044 -0.050 0.261 1.519 \n", + "2 8.0 55 1 -0.122 1.009 0.009 0.261 -0.130 \n", + "3 6.0 56 1 -0.140 1.009 0.010 0.261 -0.150 \n", + "4 5.0 99 2 -0.014 0.714 0.002 0.270 -0.016 \n", + "5 3.0 495 7 -0.377 0.381 0.440 0.339 -0.818 \n", + "6 2.0 506 7 -0.399 0.381 0.481 0.339 -0.880 \n", + "7 1.0 781 16 0.000 0.253 0.000 0.000 0.000 \n", + "\n", + " S_Contrast Studentized contrast Generalized class Generalized WPlus \\\n", + "0 0.405 -0.033 1 -0.1911 \n", + "1 1.077 1.411 2 1.4694 \n", + "2 1.042 -0.125 1 -0.1911 \n", + "3 1.042 -0.144 1 -0.1911 \n", + "4 0.764 -0.021 1 -0.1911 \n", + "5 0.510 -1.605 1 -0.1911 \n", + "6 0.510 -1.728 1 -0.1911 \n", + "7 0.253 0.000 1 -0.1911 \n", + "\n", + " Generalized S_WPlus \n", + "0 0.1730 \n", + "1 1.0445 \n", + "2 0.1730 \n", + "3 0.1730 \n", + "4 0.1730 \n", + "5 0.1730 \n", + "6 0.1730 \n", + "7 0.1730 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -490,7 +646,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -499,13 +655,13 @@ "" ] }, - "execution_count": 3, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAAK7CAYAAADBfQ+iAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABVE0lEQVR4nO3de1xU9b7/8fcAclEZBAURRSU1L+WVTohpWlJm7ra2TbM8eSusNlpp+1T+yjSzsLTs5LZydxJ3Wdtqa+ZulyfUbjtNjbySucUUSkUtBbykcvn+/ug4MsFXZ3B0UF7Px2Mej5m1vt/v+qz1nQHerJk1DmOMEQAAAACgggB/FwAAAAAA1RWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAFAtTZ48WQ6Hw21Z8+bNNWLEiPNax7x58+RwOLRz587zut3fGjFihJo3b17lvnXr1vVtQQBQQxCYAOACsmPHDo0ZM0aXXnqpateurdq1a6tdu3ZKS0vTxo0b/V0eLnBHjx7V5MmT9emnn/q7FACoNoL8XQAAwDMffPCBbr31VgUFBWno0KHq2LGjAgIC9N1332nRokV6+eWXtWPHDjVr1szfpZ4zW7duVUBAzfxf36uvvqqysrJzuo2jR4/qiSeekCT16tXrnG4LAC4UBCYAuABs375dQ4YMUbNmzbR8+XI1atTIbf0zzzyjl156qVqHiSNHjqhOnTpnNUZISIiPqrnw1KpVy98lAECNVH1/swIAXJ599lkdOXJEGRkZFcKSJAUFBem+++5TfHy82/LvvvtOt9xyi6KiohQaGqorrrhCS5YscWtz8jM6X375pcaPH6/o6GjVqVNHN998s/bv319hWx999JF69OihOnXqKDw8XP369VN2drZbm5Ofmdm+fbtuvPFGhYeHa+jQoZKkL774QoMGDVLTpk0VEhKi+Ph4jRs3Tr/88ssZj8NvP8PkcDist/KfOfLkOEhSdna2rr32WoWFhalJkyaaOnWqR2d1lixZIofD4fa2yIULF8rhcOgPf/iDW9u2bdvq1ltvdVs2f/58JSYmKiwsTFFRURoyZIh++OEHtzaVfYbp559/1h133CGn06l69epp+PDh2rBhgxwOh+bNm1ehzl27dmnAgAGqW7euoqOj9ac//UmlpaWSpJ07dyo6OlqS9MQTT7iO4+TJkyVJ+fn5GjlypJo0aaKQkBA1atRI/fv39/tnuwDgXOMMEwBcAD744AO1bNlSSUlJHvfJzs7WVVddpcaNG+uRRx5RnTp19M4772jAgAFauHChbr75Zrf2Y8eOVWRkpCZNmqSdO3fqhRde0JgxY/T222+72rzxxhsaPny4+vTpo2eeeUZHjx7Vyy+/rO7du2vdunVuf9CXlJSoT58+6t69u2bMmKHatWtLkt59910dPXpU9957r+rXr681a9Zo1qxZ+vHHH/Xuu+96dVzeeOONCssee+wx7du3z3WRA0+PQ35+vq655hqVlJS42v3lL39RWFjYGevo3r27HA6HPv/8c3Xo0EHSr8EwICBA//rXv1zt9u/fr++++05jxoxxLXvqqac0ceJEDR48WHfddZf279+vWbNm6eqrr9a6detUr169SrdZVlamm266SWvWrNG9996rNm3a6P3339fw4cMrbV9aWqo+ffooKSlJM2bM0LJly/Tcc8+pRYsWuvfeexUdHa2XX35Z9957r26++WZX0Du5PwMHDlR2drbGjh2r5s2ba9++fcrMzFReXl6VL0YBABcEAwCo1goLC40kM2DAgArrDh48aPbv3++6HT161LWud+/epn379ubYsWOuZWVlZaZbt26mVatWrmUZGRlGkklJSTFlZWWu5ePGjTOBgYGmoKDAGGPMoUOHTL169UxqaqpbDfn5+SYiIsJt+fDhw40k88gjj1SouXyNJ6WnpxuHw2Fyc3NdyyZNmmR++2uqWbNmZvjw4RX6n/Tss88aSeb111/3+jg88MADRpJZvXq1a9m+fftMRESEkWR27Nhh3a4xxlx22WVm8ODBrsddunQxgwYNMpLMli1bjDHGLFq0yEgyGzZsMMYYs3PnThMYGGieeuopt7E2bdpkgoKC3JYPHz7cNGvWzPV44cKFRpJ54YUXXMtKS0vNtddeaySZjIwMt76SzJQpU9y207lzZ5OYmOh6vH//fiPJTJo0ya3dwYMHjSQzffr00x4DALgY8ZY8AKjmioqKJKnSy0L36tVL0dHRrtvs2bMlSQcOHNCKFSs0ePBgHTp0SD/99JN++ukn/fzzz+rTp4+2bdumXbt2uY01evRot8t49+jRQ6WlpcrNzZUkZWZmqqCgQLfddptrvJ9++kmBgYFKSkrSJ598UqG+e++9t8Ky8mdsjhw5op9++kndunWTMUbr1q2rwhH61SeffKIJEyZo7NixuuOOO7w+Dh9++KG6du2qK6+80jVmdHS0662EZ9KjRw998cUXkqRDhw5pw4YNGj16tBo0aOBa/sUXX6hevXq6/PLLJUmLFi1SWVmZBg8e7HZMY2Nj1apVq0qP6UlLly5VrVq1lJqa6loWEBCgtLQ0a5977rmnQs3ff//9GfctLCxMwcHB+vTTT3Xw4MEztgeAi0mNDEyff/65brrpJsXFxcnhcGjx4sVej2GM0YwZM3TppZcqJCREjRs31lNPPeX7YgHUeOHh4ZKkw4cPV1g3Z84cZWZmav78+W7Lc3JyZIzRxIkT3QJVdHS0Jk2aJEnat2+fW5+mTZu6PY6MjJQk1x/I27ZtkyRde+21Fcb8+OOPK4wXFBSkJk2aVKg5Ly9PI0aMUFRUlOuzND179pQkFRYWenZQfuPHH3/UrbfeqquuukrPP/98lY5Dbm6uWrVqVWHs1q1be1RDjx49tGfPHuXk5GjlypVyOBxKTk52C1JffPGFrrrqKtfFObZt2yZjjFq1alWhvi1btlQ4puXl5uaqUaNGrrc6ntSyZctK24eGhro+o3RSZGSkRwEoJCREzzzzjD766CM1bNhQV199tZ599lnl5+efsS8AXOhq5GeYjhw5oo4dO2rUqFEVPozrqfvvv18ff/yxZsyYofbt2+vAgQM6cOCAjysFACkiIkKNGjXS5s2bK6w7+Zmm337w/uSFCv70pz+pT58+lY772z+sAwMDK21njHEb84033lBsbGyFdkFB7r9SQkJCKly1r7S0VNddd50OHDighx9+WG3atFGdOnW0a9cujRgxokqXzT5x4oRuueUWhYSE6J133nGroyrHoaq6d+8u6dd/yn3//ffq0qWL6tSpox49eujFF1/U4cOHtW7dOrd/rpWVlcnhcOijjz6q9Pj78stmbfPrqQceeEA33XSTFi9erP/93//VxIkTlZ6erhUrVqhz584+qhIAqp8aGZj69u2rvn37WtcfP35cjz76qP72t7+poKBAl19+uZ555hnXd1Js2bJFL7/8sjZv3uz6z2NCQsL5KB1ADdWvXz/9z//8j9asWeP2ljGbSy65RNKvl6JOSUnxSQ0tWrSQJMXExFR5zE2bNunf//63/vrXv2rYsGGu5ZmZmVWu67777tP69ev1+eefq2HDhm7rvDkOzZo1c51FK2/r1q0e1dG0aVM1bdpUX3zxhb7//nv16NFDknT11Vdr/Pjxevfdd1VaWqqrr77a1adFixYyxighIUGXXnqpR9spX+8nn3yio0ePup1lysnJ8Wqc8sq/JbMyLVq00IMPPqgHH3xQ27ZtU6dOnfTcc89VOMMJABeTGvmWvDMZM2aMVq1apQULFmjjxo0aNGiQbrjhBtcv0n/84x+65JJL9MEHHyghIUHNmzfXXXfdxRkmAOfMQw89pNq1a2vUqFHau3dvhfUnzwKdFBMTo169emnOnDnas2dPhfaVXS78TPr06SOn06mnn35axcXFVRrz5FmO8vUaY/Tf//3fXtcjSRkZGZozZ45mz55daZD05jjceOON+uqrr7RmzRq39W+++abH9fTo0UMrVqzQmjVrXIGpU6dOCg8P17Rp0xQWFqbExERX+z/84Q8KDAzUE088UWEOjTH6+eefrdvq06ePiouL9eqrr7qWlZWVuT7HVhUng1dBQYHb8qNHj+rYsWNuy1q0aKHw8HAdP368ytsDgAtBjTzDdDp5eXnKyMhQXl6e4uLiJP36Vo6lS5cqIyNDTz/9tL7//nvl5ubq3Xff1euvv67S0lKNGzdOt9xyi1asWOHnPQBwMWrVqpXeeust3XbbbWrdurWGDh2qjh07yhijHTt26K233lJAQIDbZ4Zmz56t7t27q3379kpNTdUll1yivXv3atWqVfrxxx+1YcMGr2pwOp16+eWXdccdd6hLly4aMmSIoqOjlZeXp3/+85+66qqr9Oc///m0Y7Rp00YtWrTQn/70J+3atUtOp1MLFy6s0oUEfvrpJ/3xj39Uu3btFBISUuEsx80336w6dep4fBweeughvfHGG7rhhht0//33uy4r3qxZM7fvVzqdHj166M0335TD4XC9RS8wMFDdunXT//7v/6pXr14KDg52tW/RooWmTp2qCRMmaOfOnRowYIDCw8O1Y8cOvffeexo9erT+9Kc/VbqtAQMG6Morr9SDDz6onJwctWnTRkuWLHH98+5MZ4sqExYWpnbt2untt9/WpZdeqqioKF1++eUqKSlR7969NXjwYLVr105BQUF67733tHfvXg0ZMsTr7QDABcUv1+arRiSZ9957z/X4gw8+MJJMnTp13G5BQUGuy8WmpqYaSWbr1q2ufllZWUaS+e677873LgCoQXJycsy9995rWrZsaUJDQ01YWJhp06aNueeee8z69esrtN++fbsZNmyYiY2NNbVq1TKNGzc2v/vd78zf//53V5uTlxVfu3atW99PPvnESDKffPJJheV9+vQxERERJjQ01LRo0cKMGDHCfP311642w4cPN3Xq1Kl0H7799luTkpJi6tataxo0aGBSU1PNhg0bKlwK+0yXFd+xY4eRZL2Vvwy4J8fBGGM2btxoevbsaUJDQ03jxo3Nk08+aV577TWPLitujDHZ2dlGkmnbtq3b8qlTpxpJZuLEiZX2W7hwoenevbvrd06bNm1MWlqa2++Z315W3JhfLwN+++23m/DwcBMREWFGjBhhvvzySyPJLFiwwK1vZfNR2TFeuXKlSUxMNMHBwa5LjP/0008mLS3NtGnTxtSpU8dERESYpKQk884775zxmADAhc5hzG/eA1DDOBwOvffeexowYIAk6e2339bQoUOVnZ1d4QOydevWVWxsrCZNmlThLSm//PKLateurY8//ljXXXfd+dwFAABcFi9erJtvvln/+te/dNVVV/m7HAC44PGWvN/o3LmzSktLtW/fPtf7z3/rqquuUklJibZv3+76EPS///1vSb9+CBcAgPPhl19+cfteq9LSUs2aNUtOp1NdunTxY2UAcPGokYHp8OHDblcR2rFjh9avX6+oqChdeumlGjp0qIYNG6bnnntOnTt31v79+7V8+XJ16NBB/fr1U0pKirp06aJRo0bphRdeUFlZmdLS0nTdddd5fZUjAACqauzYsfrll1+UnJys48ePa9GiRVq5cqWefvpptyAFAKi6GvmWvE8//VTXXHNNheXDhw/XvHnzVFxcrKlTp+r111/Xrl271KBBA3Xt2lVPPPGE2rdvL0navXu3xo4dq48//lh16tRR37599dxzzykqKup87w4AoIZ666239NxzzyknJ0fHjh1Ty5Ytde+992rMmDH+Lg0ALho1MjABAAAAgCf4HiYAAAAAsCAwAQAAAIBFjbnoQ1lZmXbv3q3w8PAqfZkfAAAAgIuDMUaHDh1SXFycAgJOfw6pxgSm3bt3Kz4+3t9lAAAAAKgmfvjhBzVp0uS0bWpMYAoPD5f060FxOp1+rgYAAACAvxQVFSk+Pt6VEU6nxgSmk2/DczqdBCYAAAAAHn1Uh4s+AAAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAI8ncBOGXh7LH+LgH/Z0vWPn+XcFptE2P8XcJpDUyb5e8SAAAAfIIzTAAAAABg4VVgat68uRwOR4VbWlpape3nzZtXoW1oaKhrfXFxsR5++GG1b99ederUUVxcnIYNG6bdu3efcbvTpk2rwu4CAAAAgOe8ekve2rVrVVpa6nq8efNmXXfddRo0aJC1j9Pp1NatW12PHQ6H6/7Ro0f1zTffaOLEierYsaMOHjyo+++/X7///e/19ddfu40zZcoUpaamuh6Hh4d7UzoAAAAAeM2rwBQdHe32eNq0aWrRooV69uxp7eNwOBQbG1vpuoiICGVmZrot+/Of/6wrr7xSeXl5atq0qWt5eHi4dRwAAAAAOBeq/BmmEydOaP78+Ro1apTbWaPfOnz4sJo1a6b4+Hj1799f2dnZpx23sLBQDodD9erVc1s+bdo01a9fX507d9b06dNVUlJy2nGOHz+uoqIitxsAAAAAeKPKV8lbvHixCgoKNGLECGub1q1ba+7cuerQoYMKCws1Y8YMdevWTdnZ2WrSpEmF9seOHdPDDz+s2267TU6n07X8vvvuU5cuXRQVFaWVK1dqwoQJ2rNnj55//nnrttPT0/XEE09UdfcAAAAAQA5jjKlKxz59+ig4OFj/+Mc/PO5TXFystm3b6rbbbtOTTz5ZYd3AgQP1448/6tNPP3ULTL81d+5c3X333Tp8+LBCQkIqbXP8+HEdP37c9bioqEjx8fEqLCw87dj+xGXFqw8uK352uKw4AACozoqKihQREeFRNqjSGabc3FwtW7ZMixYt8qpfrVq11LlzZ+Xk5LgtLy4u1uDBg5Wbm6sVK1acseikpCSVlJRo586dat26daVtQkJCrGEKAAAAADxRpc8wZWRkKCYmRv369fOqX2lpqTZt2qRGjRq5lp0MS9u2bdOyZctUv379M46zfv16BQQEKCamev+XHQAAAMCFzeszTGVlZcrIyNDw4cMVFOTefdiwYWrcuLHS09Ml/Xop8K5du6ply5YqKCjQ9OnTlZubq7vuukvSr2Hplltu0TfffKMPPvhApaWlys/PlyRFRUUpODhYq1at0urVq3XNNdcoPDxcq1at0rhx4/Sf//mfioyMPNv9BwAAAAArrwPTsmXLlJeXp1GjRlVYl5eXp4CAUyetDh48qNTUVOXn5ysyMlKJiYlauXKl2rVrJ0natWuXlixZIknq1KmT21iffPKJevXqpZCQEC1YsECTJ0/W8ePHlZCQoHHjxmn8+PHelg4AAAAAXqnyRR8uNN58sMtfuOhD9cFFH84OF30AAADVmTfZoMrfwwQAAAAAFzsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALLz+4lqcO77+7p/FG3v7dDxfGtBhub9LuKD5+rni6+914jvF4Cm+swsAUN1xhgkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAuHMcb4u4jzoaioSBERESosLJTT6fR3OZW64oq/+LuEC9aADsv9XQLKiYgK9dlYcQnV8/UKeGtg2ix/lwAA+D/eZAPOMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYBHk7wJwyoAOy/1dAuAThQeO+bsEq7gEp79LQA21cPZYf5dwXg1Mm+XvEgDAJzjDBAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAI8ncBOKVtYoxPx9uStc+n4wH+UHjgWLUeLyIq1KfjxSU4fToe4C8LZ4/1dwnn1cC0Wf4uAcA5whkmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsgvxdAABcyAoPHPN3CacVl+D0dwlAjbBw9lifjZWe0d5nY50LX3892t8lAOcVZ5gAAAAAwMKrwNS8eXM5HI4Kt7S0tErbz5s3r0Lb0NBQ1/ri4mI9/PDDat++verUqaO4uDgNGzZMu3fvdhvnwIEDGjp0qJxOp+rVq6c777xThw8frsLuAgAAAIDnvHpL3tq1a1VaWup6vHnzZl133XUaNGiQtY/T6dTWrVtdjx0Oh+v+0aNH9c0332jixInq2LGjDh48qPvvv1+///3v9fXXX7vaDR06VHv27FFmZqaKi4s1cuRIjR49Wm+99ZY35QMAAACAV7wKTNHR0W6Pp02bphYtWqhnz57WPg6HQ7GxsZWui4iIUGZmptuyP//5z7ryyiuVl5enpk2basuWLVq6dKnWrl2rK664QpI0a9Ys3XjjjZoxY4bi4uK82QUAAAAA8FiVP8N04sQJzZ8/X6NGjXI7a/Rbhw8fVrNmzRQfH6/+/fsrOzv7tOMWFhbK4XCoXr16kqRVq1apXr16rrAkSSkpKQoICNDq1aut4xw/flxFRUVuNwAAAADwRpUD0+LFi1VQUKARI0ZY27Ru3Vpz587V+++/r/nz56usrEzdunXTjz/+WGn7Y8eO6eGHH9Ztt90mp/PXKzvl5+crJibGrV1QUJCioqKUn59v3XZ6eroiIiJct/j4eO93EgAAAECNVuXA9Nprr6lv376nfUtccnKyhg0bpk6dOqlnz55atGiRoqOjNWfOnApti4uLNXjwYBlj9PLLL1e1LJcJEyaosLDQdfvhhx/OekwAAAAANUuVvocpNzdXy5Yt06JFi7zqV6tWLXXu3Fk5OTluy0+GpdzcXK1YscJ1dkmSYmNjtW/fPrf2JSUlOnDggPWzUZIUEhKikJAQr+oDAAAAgPKqdIYpIyNDMTEx6tevn1f9SktLtWnTJjVq1Mi17GRY2rZtm5YtW6b69eu79UlOTlZBQYGysrJcy1asWKGysjIlJSVVpXwAAAAA8IjXZ5jKysqUkZGh4cOHKyjIvfuwYcPUuHFjpaenS5KmTJmirl27qmXLliooKND06dOVm5uru+66S9KvYemWW27RN998ow8++EClpaWuzyVFRUUpODhYbdu21Q033KDU1FS98sorKi4u1pgxYzRkyBCukAcAAADgnPI6MC1btkx5eXkaNWpUhXV5eXkKCDh10urgwYNKTU1Vfn6+IiMjlZiYqJUrV6pdu3aSpF27dmnJkiWSpE6dOrmN9cknn6hXr16SpDfffFNjxoxR7969FRAQoIEDB+rFF1/0tnQAAAAA8IrDGGP8XcT5UFRUpIiICBUWFrp9Rqo6WTh7rE/H25K178yNAFQrEVGhPh0vLqF6/rwDYJee0d7fJZzW11+P9ncJwFnzJhtU+Sp5AAAAAHCxIzABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMDC6y+uxbnj6+9NapsY47Ox+E4n+Mvijb19Ot6ADst9Op6vFR445u8STovvdQJwxRV/8XcJpzVh5CZ/l3BaA9Nm+bsEeIkzTAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWDiMMcbfRZwPRUVFioiIUGFhoZxOp7/LqdQVV/zF3yVYDeiw3KfjtU2M8el4W7L2+XS86s7Xx8/XfDkfizf29tlYku+fy9VdRFSoT8eLS6iePz8BnD/pGe39XcJ5NWHkJn+XcMEamDbL3yVYeZMNOMMEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAICFwxhj/F3E+VBUVKSIiAgVFhbK6XT6u5xKTR11q0/HW7yxt8/GmjByk8/GkqQtWft8Ol7bxBifjufr+p5t8pxPx/O1jIbP+HS89Iz2PhtrQIflPhsLZy8iKtSn48UlVM+fxwDOH1/+zrgQ+PpvqppkYNosn43lTTbgDBMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABZB/i4A586ADst9NtaWLJ8NJUlqmxjj2wGruYyGz/h0vC1Z+3w6nhr6dj58+dwDAFzcJozc5NPx0jPa+3Q8gDNMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYBPm7AJzSNjHGp+Ntydrn0/FqEubi7Cze2NtnYw3osNxnY6H62b2jyKfjxSU4fToeAACcYQIAAAAAC68CU/PmzeVwOCrc0tLSKm0/b968Cm1DQ0Pd2ixatEjXX3+96tevL4fDofXr11cYp1evXhXGueeee7wpHQAAAAC85tVb8tauXavS0lLX482bN+u6667ToEGDrH2cTqe2bt3qeuxwONzWHzlyRN27d9fgwYOVmppqHSc1NVVTpkxxPa5du7Y3pQMAAACA17wKTNHR0W6Pp02bphYtWqhnz57WPg6HQ7Gxsdb1d9xxhyRp586dp9127dq1TzsOAAAAAPhalT/DdOLECc2fP1+jRo2qcNaovMOHD6tZs2aKj49X//79lZ2dXaXtvfnmm2rQoIEuv/xyTZgwQUePHj1t++PHj6uoqMjtBgAAAADeqPJV8hYvXqyCggKNGDHC2qZ169aaO3euOnTooMLCQs2YMUPdunVTdna2mjRp4vG2br/9djVr1kxxcXHauHGjHn74YW3dulWLFi2y9klPT9cTTzzhzS4BAAAAgJsqB6bXXntNffv2VVxcnLVNcnKykpOTXY+7deumtm3bas6cOXryySc93tbo0aNd99u3b69GjRqpd+/e2r59u1q0aFFpnwkTJmj8+PGux0VFRYqPj/d4mwAAAABQpcCUm5urZcuWnfYMT2Vq1aqlzp07KycnpyqbdUlKSpIk5eTkWANTSEiIQkJCzmo7AAAAAGq2Kn2GKSMjQzExMerXr59X/UpLS7Vp0yY1atSoKpt1OXnp8bMdBwAAAABOx+szTGVlZcrIyNDw4cMVFOTefdiwYWrcuLHS09MlSVOmTFHXrl3VsmVLFRQUaPr06crNzdVdd93l6nPgwAHl5eVp9+7dkuS6BHlsbKxiY2O1fft2vfXWW7rxxhtVv359bdy4UePGjdPVV1+tDh06VHnHAQAAAOBMvA5My5YtU15enkaNGlVhXV5engICTp20OnjwoFJTU5Wfn6/IyEglJiZq5cqVateunavNkiVLNHLkSNfjIUOGSJImTZqkyZMnKzg4WMuWLdMLL7ygI0eOKD4+XgMHDtRjjz3mbekAAAAA4BWvA9P1118vY0yl6z799FO3xzNnztTMmTNPO96IESNOe6W9+Ph4ffbZZ96WCQAAAABnrcrfwwQAAAAAFzsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALLz+HiacO1uy9vm7BKu2iTH+LuGCxvHDxaLwwDF/l3De+Hpf+TkAABcmzjABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGAR5O8CcErbxBh/l4BzZEvWPn+XcFqLN/b26XgDOiz32Vi+fl1U97nA2Sk8cMxnY0VEhfpsLEnavaPIp+PVNHEJTn+XgAvEhJGbfDpeekb7ajuer/cVleMMEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMAiyN8FoGbakrXP3yWcV882ec6n41364Yc+HW9Ah+U+Hc+XatpzBdVH4YFjPh0vIirUp+PVNNX9Z4Ev5zcuwemzsWqi9Iz2/i7htCaM3OTvEuAlzjABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGAR5O8CcMqWrH3+LuG8aZsY49Pxqvuxu/TDD3063oAOy306nq/5cn6r+9wCnnq09lM+He+po4/6dLzqLiIq1N8lnDe7dxT5dLy4BKdPx6tpJozc5O8S4GecYQIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwCLI3wXglLaJMT4db0vWPp+NVZ1ruxAM6LDc3yXg//j6uexrNe214Wu+nN/qPheFB475dLyIqFCfjudrcQlOf5dwWrt3FPm7BCtfP5er+8/RCSM3+bsEXGQ4wwQAAAAAFl4FpubNm8vhcFS4paWlVdp+3rx5FdqGhrr/B2vRokW6/vrrVb9+fTkcDq1fv77COMeOHVNaWprq16+vunXrauDAgdq7d683pQMAAACA17wKTGvXrtWePXtct8zMTEnSoEGDrH2cTqdbn9zcXLf1R44cUffu3fXMM89Yxxg3bpz+8Y9/6N1339Vnn32m3bt36w9/+IM3pQMAAACA17z6DFN0dLTb42nTpqlFixbq2bOntY/D4VBsbKx1/R133CFJ2rlzZ6XrCwsL9dprr+mtt97StddeK0nKyMhQ27Zt9dVXX6lr167e7AIAAAAAeKzKn2E6ceKE5s+fr1GjRsnhcFjbHT58WM2aNVN8fLz69++v7Oxsr7aTlZWl4uJipaSkuJa1adNGTZs21apVq6z9jh8/rqKiIrcbAAAAAHijyoFp8eLFKigo0IgRI6xtWrdurblz5+r999/X/PnzVVZWpm7duunHH3/0eDv5+fkKDg5WvXr13JY3bNhQ+fn51n7p6emKiIhw3eLj4z3eJgAAAABIZxGYXnvtNfXt21dxcXHWNsnJyRo2bJg6deqknj17atGiRYqOjtacOXOqulmPTZgwQYWFha7bDz/8cM63CQAAAODiUqXvYcrNzdWyZcu0aNEir/rVqlVLnTt3Vk5Ojsd9YmNjdeLECRUUFLidZdq7d+9pPxsVEhKikJAQr+oDAAAAgPKqdIYpIyNDMTEx6tevn1f9SktLtWnTJjVq1MjjPomJiapVq5aWLz/1xZ9bt25VXl6ekpOTvdo+AAAAAHjD6zNMZWVlysjI0PDhwxUU5N592LBhaty4sdLT0yVJU6ZMUdeuXdWyZUsVFBRo+vTpys3N1V133eXqc+DAAeXl5Wn37t2Sfg1D0q9nlmJjYxUREaE777xT48ePV1RUlJxOp8aOHavk5GSukAcAAADgnPI6MC1btkx5eXkaNWpUhXV5eXkKCDh10urgwYNKTU1Vfn6+IiMjlZiYqJUrV6pdu3auNkuWLNHIkSNdj4cMGSJJmjRpkiZPnixJmjlzpgICAjRw4EAdP35cffr00UsvveRt6QAAAADgFa8D0/XXXy9jTKXrPv30U7fHM2fO1MyZM0873ogRI057pT1JCg0N1ezZszV79mxvSgUAAACAs1Llq+QBAAAAwMWOwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAuvv4cJ586WrH0+He/ZJs/5brC9vhtKkh7Sg74dEBettokx/i4B51B1nl+f1+bjn6MRUaG+HdDH4hKc/i4B/6e6P1eA6o4zTAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWAT5uwCc8tjct3074KhbfTteDdI2Mcan423J2ufT8ao7X+6vr+eiuqtp+1uTPHX0UX+XcFpxCU5/l3Be+frnsi9fu7t3FPlsLABnjzNMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYBPm7AJwyddStPh3vsblv+2wsX9dW3W3J2ufvEi5oizf29tlYbRM3+WwswJ/iEpz+LuGCVt1/Llfn+iKiQn063u4dRT4dj9cGqjvOMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYOEwxhh/F3E+FBUVKSIiQoWFhXI6nf4up1KRE3b4u4Tz5sG9j/i7hAva4o29/V3CaU0YucnfJQBnbUvWPn+XcF61TYzxdwnnVU2bX1+qac8VVB8D02b5bCxvsgFnmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsAjydwGomZ5rOM2n4z249xGfjudrbRNjfDzeJp+OBwC+tiVrn79LwDni67n19e9IwNe8OsPUvHlzORyOCre0tLRK28+bN69C29DQULc2xhg9/vjjatSokcLCwpSSkqJt27adcbvTpvn2D24AAAAA+C2vzjCtXbtWpaWlrsebN2/Wddddp0GDBln7OJ1Obd261fXY4XC4rX/22Wf14osv6q9//asSEhI0ceJE9enTR99++61buJoyZYpSU1Ndj8PDw70pHQAAAAC85lVgio6Odns8bdo0tWjRQj179rT2cTgcio2NrXSdMUYvvPCCHnvsMfXv31+S9Prrr6thw4ZavHixhgwZ4mobHh5uHQcAAAAAzoUqX/ThxIkTmj9/vkaNGlXhrFF5hw8fVrNmzRQfH6/+/fsrOzvbtW7Hjh3Kz89XSkqKa1lERISSkpK0atUqt3GmTZum+vXrq3Pnzpo+fbpKSkpOW9/x48dVVFTkdgMAAAAAb1T5og+LFy9WQUGBRowYYW3TunVrzZ07Vx06dFBhYaFmzJihbt26KTs7W02aNFF+fr4kqWHDhm79GjZs6FonSffdd5+6dOmiqKgorVy5UhMmTNCePXv0/PPPW7ednp6uJ554oqq7BwAAAABVD0yvvfaa+vbtq7i4OGub5ORkJScnux5369ZNbdu21Zw5c/Tkk096vK3x48e77nfo0EHBwcG6++67lZ6erpCQkEr7TJgwwa1fUVGR4uPjPd4mAAAAAFTpLXm5ublatmyZ7rrrLq/61apVS507d1ZOTo4kuT6TtHfvXrd2e/fuPe3nlZKSklRSUqKdO3da24SEhMjpdLrdAAAAAMAbVQpMGRkZiomJUb9+/bzqV1paqk2bNqlRo0aSpISEBMXGxmr58uWuNkVFRVq9erXbmanfWr9+vQICAhQTw3X7AQAAAJw7Xr8lr6ysTBkZGRo+fLiCgty7Dxs2TI0bN1Z6erqkXy8F3rVrV7Vs2VIFBQWaPn26cnNzXWemHA6HHnjgAU2dOlWtWrVyXVY8Li5OAwYMkCStWrVKq1ev1jXXXKPw8HCtWrVK48aN03/+538qMjLyLHcfAAAAAOy8DkzLli1TXl6eRo0aVWFdXl6eAgJOnbQ6ePCgUlNTlZ+fr8jISCUmJmrlypVq166dq81DDz2kI0eOaPTo0SooKFD37t21dOlS13cwhYSEaMGCBZo8ebKOHz+uhIQEjRs3zu3zSQAAAABwLjiMMcbfRZwPRUVFioiIUGFhYbX9PFPkhB3+LuGC9eDeR/xdwmm1TeTto8CFZkvWPn+XcF75+udUTTt+qDp+R8JTA9Nm+Wwsb7JBlb+HCQAAAAAudgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwCLI3wXglIPpCf4uwaq6f6nucw2n+XQ8X38RbnX/Ake+NBAXi+r+WqvOOHbA+fFYL9+dr5j6aZnPxoIdZ5gAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFkH+LgAXhoPpCf4u4byKnDDNp+M9uPcRn46Hqhu592GfjpfR8BmfjlfTbMna5+8SAOC8mvppmb9LgJc4wwQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgEWQvwsAqqOD6Qk+HvFtH4/nWwtnj/V3CVZbsvb5dLyH9KBPx1PDGN+OV8O0TfTt8fP18wVARb5+3QLVHWeYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwCPJ3AQD8b2DaLH+XcN5MHXWrv0sAUAXPNnnOp+M99OODPh2vOmubGOPvEoALGmeYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwcBhjjL+LOB+KiooUERGhwsJCOZ1Of5cDABekhbPH+ruE09qStc/fJeAC8djct/1dAgA/8iYbcIYJAAAAACy8CkzNmzeXw+GocEtLS6u0/bx58yq0DQ0NdWtjjNHjjz+uRo0aKSwsTCkpKdq2bZtbmwMHDmjo0KFyOp2qV6+e7rzzTh0+fNjLXQUAAAAA73gVmNauXas9e/a4bpmZmZKkQYMGWfs4nU63Prm5uW7rn332Wb344ot65ZVXtHr1atWpU0d9+vTRsWPHXG2GDh2q7OxsZWZm6oMPPtDnn3+u0aNHe1M6AAAAAHgtyJvG0dHRbo+nTZumFi1aqGfPntY+DodDsbGxla4zxuiFF17QY489pv79+0uSXn/9dTVs2FCLFy/WkCFDtGXLFi1dulRr167VFVdcIUmaNWuWbrzxRs2YMUNxcXHe7AIAAAAAeKzKn2E6ceKE5s+fr1GjRsnhcFjbHT58WM2aNVN8fLz69++v7Oxs17odO3YoPz9fKSkprmURERFKSkrSqlWrJEmrVq1SvXr1XGFJklJSUhQQEKDVq1dbt3v8+HEVFRW53QAAAADAG1UOTIsXL1ZBQYFGjBhhbdO6dWvNnTtX77//vubPn6+ysjJ169ZNP/74oyQpPz9fktSwYUO3fg0bNnSty8/PV0xMjNv6oKAgRUVFudpUJj09XREREa5bfHx8VXYTAAAAQA1W5cD02muvqW/fvqd9S1xycrKGDRumTp06qWfPnlq0aJGio6M1Z86cqm7WYxMmTFBhYaHr9sMPP5zzbQIAAAC4uHj1GaaTcnNztWzZMi1atMirfrVq1VLnzp2Vk5MjSa7PNu3du1eNGjVytdu7d686derkarNvn/v3apSUlOjAgQPWz0ZJUkhIiEJCQryqDwAAAADKq9IZpoyMDMXExKhfv35e9SstLdWmTZtc4SghIUGxsbFavny5q01RUZFWr16t5ORkSb+epSooKFBWVparzYoVK1RWVqakpKSqlA8AAAAAHvH6DFNZWZkyMjI0fPhwBQW5dx82bJgaN26s9PR0SdKUKVPUtWtXtWzZUgUFBZo+fbpyc3N11113Sfr1CnoPPPCApk6dqlatWikhIUETJ05UXFycBgwYIElq27atbrjhBqWmpuqVV15RcXGxxowZoyFDhnCFPAAAAADnlNeBadmyZcrLy9OoUaMqrMvLy1NAwKmTVgcPHlRqaqry8/MVGRmpxMRErVy5Uu3atXO1eeihh3TkyBGNHj1aBQUF6t69u5YuXer2BbdvvvmmxowZo969eysgIEADBw7Uiy++6G3pAAAAAOAVhzHG+LuI86GoqEgREREqLCyU0+n0dzkAcEFaOHusv0s4rS1Z+87cCJD02Ny3/V0CAD/yJhtU+Sp5AAAAAHCxIzABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMDC6y+uBQDUXAPTZvm7BAAAzivOMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsgvxdwPlijJEkFRUV+bkSAAAAAP50MhOczAinU2MC06FDhyRJ8fHxfq4EAAAAQHVw6NAhRUREnLaNw3gSqy4CZWVl2r17t8LDw+VwOPxdTo1VVFSk+Ph4/fDDD3I6nf4up0ZjLqoX5qP6YC6qD+aiemE+qg/m4uwZY3To0CHFxcUpIOD0n1KqMWeYAgIC1KRJE3+Xgf/jdDp5gVcTzEX1wnxUH8xF9cFcVC/MR/XBXJydM51ZOomLPgAAAACABYEJAAAAACwITDivQkJCNGnSJIWEhPi7lBqPuahemI/qg7moPpiL6oX5qD6Yi/Orxlz0AQAAAAC8xRkmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWCC1bRp0+RwOPTAAw+4lv3lL39Rr1695HQ65XA4VFBQUKHfgQMHNHToUDmdTtWrV0933nmnDh8+7NZm48aN6tGjh0JDQxUfH69nn322wjjvvvuu2rRpo9DQULVv314ffvih23pjjB5//HE1atRIYWFhSklJ0bZt23yy79VRVeejefPmcjgcbrdp06a5tWE+vPPbuThw4IDGjh2r1q1bKywsTE2bNtV9992nwsJCt355eXnq16+fateurZiYGP3Xf/2XSkpK3Np8+umn6tKli0JCQtSyZUvNmzevwvZnz56t5s2bKzQ0VElJSVqzZo3b+mPHjiktLU3169dX3bp1NXDgQO3du9enx6A6qep8/PZ14XA4tGDBArc2zId3Kvs5dffdd6tFixYKCwtTdHS0+vfvr++++86tH68N36vqXPC6ODcqm4+TjDHq27evHA6HFi9e7LaO10Y1YYBKrFmzxjRv3tx06NDB3H///a7lM2fONOnp6SY9Pd1IMgcPHqzQ94YbbjAdO3Y0X331lfniiy9My5YtzW233eZaX1hYaBo2bGiGDh1qNm/ebP72t7+ZsLAwM2fOHFebL7/80gQGBppnn33WfPvtt+axxx4ztWrVMps2bXK1mTZtmomIiDCLFy82GzZsML///e9NQkKC+eWXX87JMfGns5mPZs2amSlTppg9e/a4bocPH3atZz68U9lcbNq0yfzhD38wS5YsMTk5OWb58uWmVatWZuDAga5+JSUl5vLLLzcpKSlm3bp15sMPPzQNGjQwEyZMcLX5/vvvTe3atc348ePNt99+a2bNmmUCAwPN0qVLXW0WLFhggoODzdy5c012drZJTU019erVM3v37nW1ueeee0x8fLxZvny5+frrr03Xrl1Nt27dzv3B8YOqzocxxkgyGRkZbq+N8s9X5sM7tp9Tc+bMMZ999pnZsWOHycrKMjfddJOJj483JSUlxhheG+dCVefCGF4X54JtPk56/vnnTd++fY0k895777mW89qoPghMqODQoUOmVatWJjMz0/Ts2bPSF/cnn3xS6R/o3377rZFk1q5d61r20UcfGYfDYXbt2mWMMeall14ykZGR5vjx4642Dz/8sGndurXr8eDBg02/fv3cxk5KSjJ33323McaYsrIyExsba6ZPn+5aX1BQYEJCQszf/va3Ku97dXQ282HMr4Fp5syZ1vGZD895MhcnvfPOOyY4ONgUFxcbY4z58MMPTUBAgMnPz3e1efnll43T6XQd+4ceeshcdtllbuPceuutpk+fPq7HV155pUlLS3M9Li0tNXFxcSY9Pd0Y8+txr1Wrlnn33XddbbZs2WIkmVWrVlV956uhs5kPY0yFP05+i/nwnDdzsWHDBiPJ5OTkGGN4bfja2cyFMbwufO1M87Fu3TrTuHFjs2fPngrHntdG9cFb8lBBWlqa+vXrp5SUFK/7rlq1SvXq1dMVV1zhWpaSkqKAgACtXr3a1ebqq69WcHCwq02fPn20detWHTx40NXmt9vv06ePVq1aJUnasWOH8vPz3dpEREQoKSnJ1eZicTbzcdK0adNUv359de7cWdOnT3c7nc98eM6buSgsLJTT6VRQUJCkX49h+/bt1bBhQ1ebPn36qKioSNnZ2a42pzvOJ06cUFZWllubgIAApaSkuNpkZWWpuLjYrU2bNm3UtGnTi2oupLObj/JjNGjQQFdeeaXmzp0rU+6rCZkPz3k6F0eOHFFGRoYSEhIUHx8videGr53NXJQfg9eFb5xuPo4eParbb79ds2fPVmxsbIX1vDaqj6AzN0FNsmDBAn3zzTdau3Ztlfrn5+crJibGbVlQUJCioqKUn5/vapOQkODW5uQPg/z8fEVGRio/P9/tB8TJNuXHKN+vsjYXg7OdD0m677771KVLF0VFRWnlypWaMGGC9uzZo+eff14S8+Epb+bip59+0pNPPqnRo0e7ltmO4cl1p2tTVFSkX375RQcPHlRpaWmlbU5+DiE/P1/BwcGqV69ehTYXy1xIZz8fkjRlyhRde+21ql27tj7++GP98Y9/1OHDh3XfffdJYj485clcvPTSS3rooYd05MgRtW7dWpmZma5/0vDa8J2znQuJ14UvnWk+xo0bp27duql///6Vrue1UX0QmODyww8/6P7771dmZqZCQ0P9XU6N56v5GD9+vOt+hw4dFBwcrLvvvlvp6ekKCQnxRakXPW/moqioSP369VO7du00efLk81NgDeOr+Zg4caLrfufOnXXkyBFNnz7d9YchzszTuRg6dKiuu+467dmzRzNmzNDgwYP15Zdf8rvGh3w1F7wufONM87FkyRKtWLFC69at80N18BZvyYNLVlaW9u3bpy5duigoKEhBQUH67LPP9OKLLyooKEilpaVnHCM2Nlb79u1zW1ZSUqIDBw64TjfHxsZWuPLKycdnalN+ffl+lbW50PliPiqTlJSkkpIS7dy5UxLz4QlP5+LQoUO64YYbFB4ervfee0+1atVyjXE2x9npdCosLEwNGjRQYGDgGefixIkTFa6YeLHMheSb+ahMUlKSfvzxRx0/flwS8+EJT+ciIiJCrVq10tVXX62///3v+u677/Tee+9J4rXhK76Yi8rwuqiaM81HZmamtm/frnr16rnWS9LAgQPVq1cvSbw2qhMCE1x69+6tTZs2af369a7bFVdcoaFDh2r9+vUKDAw84xjJyckqKChQVlaWa9mKFStUVlampKQkV5vPP/9cxcXFrjaZmZlq3bq1IiMjXW2WL1/uNnZmZqaSk5MlSQkJCYqNjXVrU1RUpNWrV7vaXOh8MR+VWb9+vQICAlxvnWQ+zsyTuSgqKtL111+v4OBgLVmypMJ/FJOTk7Vp0ya3fyhkZmbK6XSqXbt2rjanO87BwcFKTEx0a1NWVqbly5e72iQmJqpWrVpubbZu3aq8vLyLYi4k38xHZdavX6/IyEjXmVfm48yq8nPK/HrBKdcf4Lw2fMMXc1EZXhdVc6b5ePTRR7Vx40a39ZI0c+ZMZWRkSOK1Ua3484oTqP5+e0WXPXv2mHXr1plXX33VSDKff/65Wbdunfn5559dbW644QbTuXNns3r1avOvf/3LtGrVyu2y4gUFBaZhw4bmjjvuMJs3bzYLFiwwtWvXrnAZ66CgIDNjxgyzZcsWM2nSpEovY12vXj3z/vvvm40bN5r+/ftflJexLs/b+Vi5cqWZOXOmWb9+vdm+fbuZP3++iY6ONsOGDXONwXxUTfm5KCwsNElJSaZ9+/YmJyfH7XK8v7108vXXX2/Wr19vli5daqKjoyu9POx//dd/mS1btpjZs2dXennYkJAQM2/ePPPtt9+a0aNHm3r16rldRemee+4xTZs2NStWrDBff/21SU5ONsnJyefnwPiJt/OxZMkS8+qrr5pNmzaZbdu2mZdeesnUrl3bPP74464xmY+qKT8X27dvN08//bT5+uuvTW5urvnyyy/NTTfdZKKiolyXNOa1ce54Oxe8Ls6tM121UJbLivPa8D8CE07rty/uSZMmGUkVbhkZGa42P//8s7nttttM3bp1jdPpNCNHjjSHDh1yG3fDhg2me/fuJiQkxDRu3NhMmzatwrbfeecdc+mll5rg4GBz2WWXmX/+859u68vKyszEiRNNw4YNTUhIiOndu7fZunWrT/e/uvF2PrKyskxSUpKJiIgwoaGhpm3btubpp582x44dcxuX+fBe+bk4eVn3ym47duxw9dm5c6fp27evCQsLMw0aNDAPPvig22WuT47VqVMnExwcbC655BK319ZJs2bNMk2bNjXBwcHmyiuvNF999ZXb+l9++cX88Y9/NJGRkaZ27drm5ptvNnv27PH1IahWvJ2Pjz76yHTq1MnUrVvX1KlTx3Ts2NG88sorprS01G1c5sN75edi165dpm/fviYmJsbUqlXLNGnSxNx+++3mu+++c+vDa+Pc8HYueF2cW94GJmN4bVQXDmPKXSsSAAAAAODCZ5gAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWAT5u4Dz6dixYzpx4oS/ywAAAADgZ8HBwQoNDT1juxoTmI4dO6bw8IYqKSnydykAAAAA/Cw2NlY7duw4Y2iqMYHpxIkTKikpUvv20xQYGCoTGOhaV+Y49c7E8stN4KnlZQG2NoGVtwmovM2v68qPVfm41u0F2Nr4apxytXq7/9bjWH5bDg/anPk4lj+GCiw9dd9R7gxiQLn7gcWVLy/f3lGuTeBvzkSW7xNgGcuTNg4fjXM22yq3n0EOx5nvn+qpQE/al7tf/pkf5NAZ29v7etK+8po97m/Z53PRN9B2LDzqe+Z5sh4Xb/ue4+eHe1+5ORfPkfL3Hca47peVlrtfZlnuSZtTd92WG1t7t+VlljG9q8GjbXlUT7l9Kau8NmMZ09NavV1ubMei/LGz7oNtzs5cg/H6eWCZSw+eW9b5szy3vD625Y6Vo9zv0YAA979TAgLLryt3v9zvYbf7lrHK33eUe5G7tbGNE1j5OO5tKt+uw7LcbUyHbb882He3bdnGtPX1YB/L93XY9sv9UzUezY1breXbVz43Dk/G8WT/PZhvx1mN6d22Ti4vKipSfHy8Tpw4QWD6rcDAUAUGhrn98e3wIAz4qo3kWfhQNWvjcAsogZXeP59tvA9MtrBhCRinDUzl79ey3C/fptzLzFHuvltNgR7cD/DgvuOM9x0OL++fGkUB5ZZ7cr/8Mz/Q8oe47b63ocX2h/jZ9qfv+e97PrZ9TgLTWS338o9sXy33qK93tZ3/fbAFpgvjePnrWJ0+MHn5h7K3IcDbwFStt+X/+s/39i7041V+uae46AMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwCLI3wWcb6WlxyRJRoGuZWVlp3KjMYHl7p9aXhZgaxNYeZuywErvS5Jxa1d5H+tYpZY2geXv29qUGyfgzG1UfkzbOOXvOzxoE+DwoE357VbeRuXaKLD01H3HiXJtyt0PLK58efn2jnJtAsst/22fAMtYnrRx+Gics9iWcZS/7zjz/VOjqKzcck/ul5sZlVssR7kHtvtu3DtXet+o8polz/bTbR/K9fVoPy37XGppU1JuF4LKLS//A9ltebn7gZbltr6BsrT3pK+tvaWvR+2tfeXGk/6BXrYvf99hTj1LykrL3S+zLPekTbknXvnlxtbebXlZ5W28rNOjbXlUT7l9Kau8NmMZ09NavV1ubMei/LGz7oNtzs5cg/H6eWCZSw+eW9b5szy3vD625Y6Vo9zv0YCA8j/1pIByv1cDyrcr93vY7b7bWIGV3neUe5G7tbGNE1j5OO5tKt+uw7LcbUyHbb/K9z1zPQ7rmLa+Huxj+b4O2365n/PwaG7cai3fvvK5cXgyjif778F8O85qTO+2dXJ5UVGRPOUw5X8CXcSOHTumhIQE5efn+7sUAAAAAH4WGxurHTt2KDQ09LTtakxgkn4NTSdOnDhzw2qkqKhI8fHx+uGHH+R0Ov1dDnyIub24Mb8XL+b24sb8XryY24tbVeY3ODj4jGFJqmFvyQsNDfXooFRHTqeTF/dFirm9uDG/Fy/m9uLG/F68mNuL27mYXy76AAAAAAAWBCYAAAAAsCAwVXMhISGaNGmSQkJC/F0KfIy5vbgxvxcv5vbixvxevJjbi9u5nN8addEHAAAAAPAGZ5gAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMF5B///vf6t+/vxo0aCCn06nu3bvrk08+8XdZ8KF//vOfSkpKUlhYmCIjIzVgwAB/lwQfOn78uDp16iSHw6H169f7uxz4wM6dO3XnnXcqISFBYWFhatGihSZNmqQTJ074uzRUwezZs9W8eXOFhoYqKSlJa9as8XdJ8IH09HT9x3/8h8LDwxUTE6MBAwZo69at/i4L58C0adPkcDj0wAMP+HRcAtMF5He/+51KSkq0YsUKZWVlqWPHjvrd736n/Px8f5cGH1i4cKHuuOMOjRw5Uhs2bNCXX36p22+/3d9lwYceeughxcXF+bsM+NB3332nsrIyzZkzR9nZ2Zo5c6ZeeeUV/b//9//8XRq89Pbbb2v8+PGaNGmSvvnmG3Xs2FF9+vTRvn37/F0aztJnn32mtLQ0ffXVV8rMzFRxcbGuv/56HTlyxN+lwYfWrl2rOXPmqEOHDj4fm+9hukD89NNPio6O1ueff64ePXpIkg4dOiSn06nMzEylpKT4uUKcjZKSEjVv3lxPPPGE7rzzTn+Xg3Pgo48+0vjx47Vw4UJddtllWrdunTp16uTvsnAOTJ8+XS+//LK+//57f5cCLyQlJek//uM/9Oc//1mSVFZWpvj4eI0dO1aPPPKIn6uDL+3fv18xMTH67LPPdPXVV/u7HPjA4cOH1aVLF7300kuaOnWqOnXqpBdeeMFn43OG6QJRv359tW7dWq+//rqOHDmikpISzZkzRzExMUpMTPR3eThL33zzjXbt2qWAgAB17txZjRo1Ut++fbV582Z/lwYf2Lt3r1JTU/XGG2+odu3a/i4H51hhYaGioqL8XQa8cOLECWVlZbn98zEgIEApKSlatWqVHyvDuVBYWChJvE4vImlpaerXr985O4FAYLpAOBwOLVu2TOvWrVN4eLhCQ0P1/PPPa+nSpYqMjPR3eThLJ/8TPXnyZD322GP64IMPFBkZqV69eunAgQN+rg5nwxijESNG6J577tEVV1zh73JwjuXk5GjWrFm6++67/V0KvPDTTz+ptLRUDRs2dFvesGFD3vZ+kSkrK9MDDzygq666Spdffrm/y4EPLFiwQN98843S09PP2TYITH72yCOPyOFwnPb23XffyRijtLQ0xcTE6IsvvtCaNWs0YMAA3XTTTdqzZ4+/dwMWns5vWVmZJOnRRx/VwIEDlZiYqIyMDDkcDr377rt+3gtUxtO5nTVrlg4dOqQJEyb4u2R4wdP5LW/Xrl264YYbNGjQIKWmpvqpcgCnk5aWps2bN2vBggX+LgU+8MMPP+j+++/Xm2++qdDQ0HO2HT7D5Gf79+/Xzz//fNo2l1xyib744gtdf/31OnjwoJxOp2tdq1atdOedd/L+6mrK0/n98ssvde211+qLL75Q9+7dXeuSkpKUkpKip5566lyXCi95OreDBw/WP/7xDzkcDtfy0tJSBQYGaujQofrrX/96rktFFXg6v8HBwZKk3bt3q1evXuratavmzZungAD+H3khOXHihGrXrq2///3vblcnHT58uAoKCvT+++/7rzj4zJgxY/T+++/r888/V0JCgr/LgQ8sXrxYN998swIDA13LSktL5XA4FBAQoOPHj7utq6qgsx4BZyU6OlrR0dFnbHf06FFJqvBLOCAgwHV2AtWPp/ObmJiokJAQbd261RWYiouLtXPnTjVr1uxcl4kq8HRuX3zxRU2dOtX1ePfu3erTp4/efvttJSUlncsScRY8nV/p1zNL11xzjevMMGHpwhMcHKzExEQtX77cFZjKysq0fPlyjRkzxr/F4awZYzR27Fi99957+vTTTwlLF5HevXtr06ZNbstGjhypNm3a6OGHH/ZJWJIITBeM5ORkRUZGavjw4Xr88ccVFhamV199VTt27FC/fv38XR7OktPp1D333KNJkyYpPj5ezZo10/Tp0yVJgwYN8nN1OBtNmzZ1e1y3bl1JUosWLdSkSRN/lAQf2rVrl3r16qVmzZppxowZ2r9/v2tdbGysHyuDt8aPH6/hw4friiuu0JVXXqkXXnhBR44c0ciRI/1dGs5SWlqa3nrrLb3//vsKDw93fS4tIiJCYWFhfq4OZyM8PLzCZ9Hq1Kmj+vXr+/QzagSmC0SDBg20dOlSPfroo7r22mtVXFysyy67TO+//746duzo7/LgA9OnT1dQUJDuuOMO/fLLL0pKStKKFSu4qAdQjWVmZionJ0c5OTkVAjDveL+w3Hrrrdq/f78ef/xx5efnq1OnTlq6dGmFC0HgwvPyyy9Lknr16uW2PCMjQyNGjDj/BeGCw2eYAAAAAMCCN1oDAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABg8f8B/dmNtPkteiYAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -524,7 +680,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -533,13 +689,13 @@ "" ] }, - "execution_count": 4, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1QAAAK7CAYAAAD1BM6+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABSG0lEQVR4nO3dfVxUZf7/8fcgAmoMeAMCijehebNpqD1ETNMKI/PXamua5XqTidViN7p9a/1tZlkblnbzq7Vy+yp+W2stNzO3LQ21thtdNZNSMldMoVQ0U8CbFGWu3x99nRhhlLkcmFFez8djHo+Zc65znc8515nBt2fOGYcxxggAAAAA4LOQQBcAAAAAAOcrAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAICg98sgjcjgcHtPatGmjsWPH1mod8+fPl8Ph0M6dO2t1vacbO3as2rRpY73sRRdd5N+CAACSCFQAcF7ZsWOHJk6cqEsuuUQNGzZUw4YN1blzZ2VmZuqrr74KdHk4zx09elSPPPKIPvroo0CXAgDnjdBAFwAAqJ53331XN998s0JDQzVy5EhddtllCgkJ0TfffKPFixfrpZde0o4dO9S6detAl1pjtm7dqpCQuvl/ga+88opcLleNruPo0aN69NFHJUn9+/ev0XUBwIWCQAUA54Ht27drxIgRat26tVauXKn4+HiP+U8++aRefPHFoA4bR44cUaNGjc6pj/DwcD9Vc/6pX79+oEsAAFQheP/yAgDcnnrqKR05ckTZ2dmVwpQkhYaG6p577lFiYqLH9G+++UY33XSTmjRpooiICF1++eVaunSpR5tT1wh99tlnmjx5smJiYtSoUSPdeOON+uGHHyqt6/3331ffvn3VqFEjRUZGatCgQcrLy/Noc+qane3bt+v6669XZGSkRo4cKUn65JNPNGzYMLVq1Urh4eFKTEzUpEmT9NNPP511P5x+DZXD4fD6qHjNU3X2gyTl5eXp6quvVoMGDdSyZUs9/vjj1TortHTpUjkcDo+vXb711ltyOBz6zW9+49G2U6dOuvnmmz2mLViwQD169FCDBg3UpEkTjRgxQt99951Hm6quofrxxx81atQoOZ1ORUdHa8yYMfryyy/lcDg0f/78SnXu2rVLQ4YM0UUXXaSYmBjdf//9Ki8vlyTt3LlTMTExkqRHH33UvR8feeQRSVJRUZFuu+02tWzZUuHh4YqPj9fgwYMDfm0ZAAQaZ6gA4Dzw7rvvql27dkpJSan2Mnl5ebriiivUokUL/eEPf1CjRo305ptvasiQIXrrrbd04403erS/++671bhxY02bNk07d+7Uc889p4kTJ+qNN95wt/nrX/+qMWPGKD09XU8++aSOHj2ql156SX369NHGjRs9/sF/8uRJpaenq0+fPpo1a5YaNmwoSVq0aJGOHj2qu+66S02bNtW6dev0wgsv6Pvvv9eiRYt82i9//etfK0176KGHtG/fPvdNGKq7H4qKinTVVVfp5MmT7nZ/+ctf1KBBg7PW0adPHzkcDn388cfq2rWrpJ+DY0hIiD799FN3ux9++EHffPONJk6c6J72pz/9SVOnTtXw4cM1fvx4/fDDD3rhhRd05ZVXauPGjYqOjq5ynS6XSzfccIPWrVunu+66Sx07dtQ777yjMWPGVNm+vLxc6enpSklJ0axZs7RixQo9/fTTSkpK0l133aWYmBi99NJLuuuuu3TjjTe6g+Cp7Rk6dKjy8vJ09913q02bNtq3b59ycnJUWFhofbMMALggGABAUCspKTGSzJAhQyrNO3jwoPnhhx/cj6NHj7rnXXPNNaZLly7m2LFj7mkul8v07t3btG/f3j0tOzvbSDJpaWnG5XK5p0+aNMnUq1fPFBcXG2OMOXTokImOjjYZGRkeNRQVFZmoqCiP6WPGjDGSzB/+8IdKNVes8ZSsrCzjcDhMQUGBe9q0adPM6X+mWrdubcaMGVNp+VOeeuopI8m8+uqrPu+H++67z0gya9eudU/bt2+fiYqKMpLMjh07vK7XGGN+9atfmeHDh7tfd+/e3QwbNsxIMlu2bDHGGLN48WIjyXz55ZfGGGN27txp6tWrZ/70pz959LVp0yYTGhrqMX3MmDGmdevW7tdvvfWWkWSee+4597Ty8nJz9dVXG0kmOzvbY1lJZvr06R7r6datm+nRo4f79Q8//GAkmWnTpnm0O3jwoJFkZs6cecZ9AAB1EV/5A4AgV1paKklV3va6f//+iomJcT9mz54tSTpw4IBWrVql4cOH69ChQ9q/f7/279+vH3/8Uenp6dq2bZt27drl0deECRM8blPet29flZeXq6CgQJKUk5Oj4uJi3XLLLe7+9u/fr3r16iklJUUffvhhpfruuuuuStMqnvE5cuSI9u/fr969e8sYo40bN1rsoZ99+OGHmjJliu6++26NGjXK5/3w3nvvqVevXurZs6e7z5iYGPdXFc+mb9+++uSTTyRJhw4d0pdffqkJEyaoWbNm7umffPKJoqOjdemll0qSFi9eLJfLpeHDh3vs07i4OLVv377KfXrKsmXLVL9+fWVkZLinhYSEKDMz0+syd955Z6Wav/3227NuW4MGDRQWFqaPPvpIBw8ePGt7AKhL6mSg+vjjj3XDDTcoISFBDodDS5Ys8bkPY4xmzZqlSy65ROHh4WrRooX+9Kc/+b9YAHVeZGSkJOnw4cOV5s2ZM0c5OTlasGCBx/T8/HwZYzR16lSPwBUTE6Np06ZJkvbt2+exTKtWrTxeN27cWJLc/4Detm2bJOnqq6+u1OcHH3xQqb/Q0FC1bNmyUs2FhYUaO3asmjRp4r6Wp1+/fpKkkpKS6u2U03z//fe6+eabdcUVV+iZZ56x2g8FBQVq3759pb47dOhQrRr69u2rPXv2KD8/X6tXr5bD4VBqaqpH0Prkk090xRVXuG8esm3bNhlj1L59+0r1bdmypdI+raigoEDx8fHur1Ke0q5duyrbR0REuK+ROqVx48bVCkjh4eF68skn9f7776t58+a68sor9dRTT6moqOisywLAha5OXkN15MgRXXbZZRo3blyli4Wr695779UHH3ygWbNmqUuXLjpw4IAOHDjg50oBQIqKilJ8fLw2b95cad6pa6pOvzHAqRsp3H///UpPT6+y39P/4V2vXr0q2xljPPr861//qri4uErtQkM9/6SEh4dXuutgeXm5BgwYoAMHDujBBx9Ux44d1ahRI+3atUtjx461ui14WVmZbrrpJoWHh+vNN9/0qMNmP9jq06ePpJ//0+7bb79V9+7d1ahRI/Xt21fPP/+8Dh8+rI0bN3r855vL5ZLD4dD7779f5f7354/xehvf6rrvvvt0ww03aMmSJVq+fLmmTp2qrKwsrVq1St26dfNTlQBw/qmTgWrgwIEaOHCg1/nHjx/XH//4R/3tb39TcXGxLr30Uj355JPu3+TYsmWLXnrpJW3evNn9P5dt27atjdIB1FGDBg3Sf//3f2vdunUeX0nz5uKLL5b0862209LS/FJDUlKSJCk2Nta6z02bNuk///mP/ud//kejR492T8/JybGu65577lFubq4+/vhjNW/e3GOeL/uhdevW7rNwFW3durVadbRq1UqtWrXSJ598om+//VZ9+/aVJF155ZWaPHmyFi1apPLycl155ZXuZZKSkmSMUdu2bXXJJZdUaz0V6/3www919OhRj7NU+fn5PvVTUcWvfFYlKSlJv//97/X73/9e27ZtU3Jysp5++ulKZ0gBoC6pk1/5O5uJEydqzZo1Wrhwob766isNGzZM1113nfsP7T/+8Q9dfPHFevfdd9W2bVu1adNG48eP5wwVgBrzwAMPqGHDhho3bpz27t1baf6ps0inxMbGqn///pozZ4727NlTqX1Vt0M/m/T0dDmdTj3xxBM6ceKEVZ+nzpJUrNcYo//3//6fz/VIUnZ2tubMmaPZs2dXGTR92Q/XX3+9/v3vf2vdunUe81977bVq19O3b1+tWrVK69atcweq5ORkRUZGasaMGWrQoIF69Ojhbv+b3/xG9erV06OPPlppDI0x+vHHH72uKz09XSdOnNArr7zinuZyudzX0dk4FcyKi4s9ph89elTHjh3zmJaUlKTIyEgdP37cen0AcCGok2eozqSwsFDZ2dkqLCxUQkKCpJ+/KrJs2TJlZ2friSee0LfffquCggItWrRIr776qsrLyzVp0iTddNNNWrVqVYC3AMCFqH379nr99dd1yy23qEOHDho5cqQuu+wyGWO0Y8cOvf766woJCfG4Zmn27Nnq06ePunTpooyMDF188cXau3ev1qxZo++//15ffvmlTzU4nU699NJLGjVqlLp3764RI0YoJiZGhYWF+uc//6krrrhCf/7zn8/YR8eOHZWUlKT7779fu3btktPp1FtvvWV1o4P9+/frd7/7nTp37qzw8PBKZ0luvPFGNWrUqNr74YEHHtBf//pXXXfddbr33nvdt01v3bq1x+9LnUnfvn312muvyeFwuL8CWK9ePfXu3VvLly9X//79FRYW5m6flJSkxx9/XFOmTNHOnTs1ZMgQRUZGaseOHXr77bc1YcIE3X///VWua8iQIerZs6d+//vfKz8/Xx07dtTSpUvd/7l3trNNVWnQoIE6d+6sN954Q5dccomaNGmiSy+9VCdPntQ111yj4cOHq3PnzgoNDdXbb7+tvXv3asSIET6vBwAuKAG5t2AQkWTefvtt9+t3333XSDKNGjXyeISGhrpvh5uRkWEkma1bt7qX27Bhg5Fkvvnmm9reBAB1SH5+vrnrrrtMu3btTEREhGnQoIHp2LGjufPOO01ubm6l9tu3bzejR482cXFxpn79+qZFixbm//yf/2P+/ve/u9ucum36+vXrPZb98MMPjSTz4YcfVpqenp5uoqKiTEREhElKSjJjx441n3/+ubvNmDFjTKNGjarchq+//tqkpaWZiy66yDRr1sxkZGSYL7/8stKtvs922/QdO3YYSV4fFW9zXp39YIwxX331lenXr5+JiIgwLVq0MI899piZO3dutW6bbowxeXl5RpLp1KmTx/THH3/cSDJTp06tcrm33nrL9OnTx/03p2PHjiYzM9Pj78zpt0035ufbnN96660mMjLSREVFmbFjx5rPPvvMSDILFy70WLaq8ahqH69evdr06NHDhIWFuW+hvn//fpOZmWk6duxoGjVqZKKiokxKSop58803z7pPAOBC5zDmtO8Y1DEOh0Nvv/22hgwZIkl64403NHLkSOXl5VW6gPeiiy5SXFycpk2bVukrLz/99JMaNmyoDz74QAMGDKjNTQAAwG3JkiW68cYb9emnn+qKK64IdDkAcMHjK3+n6datm8rLy7Vv3z73999Pd8UVV+jkyZPavn27+yLt//znP5J+vkgYAIDa8NNPP3n8rld5ebleeOEFOZ1Ode/ePYCVAUDdUScD1eHDhz3ugrRjxw7l5uaqSZMmuuSSSzRy5EiNHj1aTz/9tLp166YffvhBK1euVNeuXTVo0CClpaWpe/fuGjdunJ577jm5XC5lZmZqwIABPt+lCQAAW3fffbd++uknpaam6vjx41q8eLFWr16tJ554wiNoAQBqTp38yt9HH32kq666qtL0MWPGaP78+Tpx4oQef/xxvfrqq9q1a5eaNWumXr166dFHH1WXLl0kSbt379bdd9+tDz74QI0aNdLAgQP19NNPq0mTJrW9OQCAOur111/X008/rfz8fB07dkzt2rXTXXfdpYkTJwa6NACoM+pkoAIAAAAAf+B3qAAAAADAEoEKAAAAACzVmZtSuFwu7d69W5GRkVY/dggAAADgwmCM0aFDh5SQkKCQkHM7x1RnAtXu3buVmJgY6DIAAAAABInvvvtOLVu2PKc+6kygioyMlPTzTnM6nQGuBgAAAECglJaWKjEx0Z0RzkWdCVSnvubndDoJVAAAAAD8cikQN6UAAAAAAEsEKgAAAACwRKACAAAAAEsEKgAAAACwRKACAAAAAEsEKgAAAACwRKACAAAAAEsEKgAAAACwRKACAAAAAEsEKgAAAACwRKACAAAAAEsEKgAAAACwRKACAAAAAEsEKgAAAACwRKACAAAAAEsEKgAAAACwFBroAvCLASHDAl0C/tfy3bmBLuGM0hOSA13CGeW4FgW6BAAAgFrBGSoAAAAAsORToGrTpo0cDkelR2ZmZpXt58+fX6ltRESEe/6JEyf04IMPqkuXLmrUqJESEhI0evRo7d69+6zrnTFjhsXmAgAAAID/+PSVv/Xr16u8vNz9evPmzRowYICGDfP+VTWn06mtW7e6XzscDvfzo0eP6osvvtDUqVN12WWX6eDBg7r33nv161//Wp9//rlHP9OnT1dGRob7dWRkpC+lAwAAAIDf+RSoYmJiPF7PmDFDSUlJ6tevn9dlHA6H4uLiqpwXFRWlnJwcj2l//vOf1bNnTxUWFqpVq1bu6ZGRkV77AQAAAIBAsL6GqqysTAsWLNC4ceM8zjqd7vDhw2rdurUSExM1ePBg5eXlnbHfkpISORwORUdHe0yfMWOGmjZtqm7dumnmzJk6efLkGfs5fvy4SktLPR4AAAAA4E/Wd/lbsmSJiouLNXbsWK9tOnTooHnz5qlr164qKSnRrFmz1Lt3b+Xl5ally5aV2h87dkwPPvigbrnlFjmdTvf0e+65R927d1eTJk20evVqTZkyRXv27NEzzzzjdd1ZWVl69NFHbTcPAAAAAM7KYYwxNgump6crLCxM//jHP6q9zIkTJ9SpUyfdcssteuyxxyrNGzp0qL7//nt99NFHHoHqdPPmzdMdd9yhw4cPKzw8vMo2x48f1/Hjx92vS0tLlZiYqJKSkjP2HUjcNj14cNv0c8Nt0wEAQDArLS1VVFSUX7KB1RmqgoICrVixQosXL/Zpufr166tbt27Kz8/3mH7ixAkNHz5cBQUFWrVq1Vk3KiUlRSdPntTOnTvVoUOHKtuEh4d7DVsAAAAA4A9W11BlZ2crNjZWgwYN8mm58vJybdq0SfHx8e5pp8LUtm3btGLFCjVt2vSs/eTm5iokJESxsbE+1w4AAAAA/uLzGSqXy6Xs7GyNGTNGoaGei48ePVotWrRQVlaWpJ9vdd6rVy+1a9dOxcXFmjlzpgoKCjR+/HhJP4epm266SV988YXeffddlZeXq6ioSJLUpEkThYWFac2aNVq7dq2uuuoqRUZGas2aNZo0aZJ++9vfqnHjxue6/QAAAABgzedAtWLFChUWFmrcuHGV5hUWFiok5JeTXgcPHlRGRoaKiorUuHFj9ejRQ6tXr1bnzp0lSbt27dLSpUslScnJyR59ffjhh+rfv7/Cw8O1cOFCPfLIIzp+/Ljatm2rSZMmafLkyb6WDgAAAAB+ZX1TivONPy88qynclCJ4cFOKc8NNKQAAQDDzZzaw/h0qAAAAAKjrCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACW+B2qIOIqau/X/oL5t4qC/Xee6ppgPlZwYeM3ywAAgcDvUAEAAABAECBQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWHIYY0ygi6gNpaWlioqKUklJiZxOZ6DLqdKAkGGBLuG8tXx3bqBLQAXpCcmBLgEIOjmuRYEuAQDwv/yZDThDBQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWHMYYE+giakNpaamioqJUUlIip9MZ6HKq5CpqH+gSgKCTnpAc6BIAWMhxLQp0CQDglT+zAWeoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALIUGugD8Ij0h2a/9Ld+d69f+gEAI9uPY3+9b4EIxIGRYoEuoVTmuRYEuAUCAcIYKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAEoEKAAAAACyFBroAADifLd+d69f+0hOS/dofgNoxIGRYoEuoNTmuRYEuAQgqnKECAAAAAEs+Bao2bdrI4XBUemRmZlbZfv78+ZXaRkREuOefOHFCDz74oLp06aJGjRopISFBo0eP1u7duz36OXDggEaOHCmn06no6GjdfvvtOnz4sMXmAgAAAID/+PSVv/Xr16u8vNz9evPmzRowYICGDfN+mtvpdGrr1q3u1w6Hw/386NGj+uKLLzR16lRddtllOnjwoO699179+te/1ueff+5uN3LkSO3Zs0c5OTk6ceKEbrvtNk2YMEGvv/66L+UDAAAAgF/5FKhiYmI8Xs+YMUNJSUnq16+f12UcDofi4uKqnBcVFaWcnByPaX/+85/Vs2dPFRYWqlWrVtqyZYuWLVum9evX6/LLL5ckvfDCC7r++us1a9YsJSQk+LIJAAAAAOA31tdQlZWVacGCBRo3bpzHWafTHT58WK1bt1ZiYqIGDx6svLy8M/ZbUlIih8Oh6OhoSdKaNWsUHR3tDlOSlJaWppCQEK1du9ZrP8ePH1dpaanHAwAAAAD8yTpQLVmyRMXFxRo7dqzXNh06dNC8efP0zjvvaMGCBXK5XOrdu7e+//77KtsfO3ZMDz74oG655RY5nU5JUlFRkWJjYz3ahYaGqkmTJioqKvK67qysLEVFRbkfiYmJvm8kAAAAAJyBdaCaO3euBg4ceMav3KWmpmr06NFKTk5Wv379tHjxYsXExGjOnDmV2p44cULDhw+XMUYvvfSSbVluU6ZMUUlJifvx3XffnXOfAAAAAFCR1e9QFRQUaMWKFVq8eLFPy9WvX1/dunVTfn6+x/RTYaqgoECrVq1yn52SpLi4OO3bt8+j/cmTJ3XgwAGv12ZJUnh4uMLDw32qDwAAAAB8YXWGKjs7W7GxsRo0aJBPy5WXl2vTpk2Kj493TzsVprZt26YVK1aoadOmHsukpqaquLhYGzZscE9btWqVXC6XUlJSbMoHAAAAAL/w+QyVy+VSdna2xowZo9BQz8VHjx6tFi1aKCsrS5I0ffp09erVS+3atVNxcbFmzpypgoICjR8/XtLPYeqmm27SF198oXfffVfl5eXu66KaNGmisLAwderUSdddd50yMjL08ssv68SJE5o4caJGjBjBHf4AAAAABJTPgWrFihUqLCzUuHHjKs0rLCxUSMgvJ70OHjyojIwMFRUVqXHjxurRo4dWr16tzp07S5J27dqlpUuXSpKSk5M9+vrwww/Vv39/SdJrr72miRMn6pprrlFISIiGDh2q559/3tfSAQAAAMCvHMYYE+giakNpaamioqJUUlLicY1WMBkQ4v0Hkm0s353r1/4A1Lz0hORAlwAAZ5TjWhToEoBz5s9sYH2XPwAAAACo6whUAAAAAGCJQAUAAAAAlghUAAAAAGCJQAUAAAAAlghUAAAAAGCJQAUAAAAAlvgdqiDiKmrv1/78+Xs2/KYVAsXfv8tU145lftcKAIILv+MVHPgdKgAAAAAIAgQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAAS6GBLgC/SE9IDnQJtcbf27p8d65f+wt2wX6s1LXxAACgugaEDAt0CbUmx7Uo0CXUCs5QAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlhzHGBLqI2lBaWqqoqCiVlJTI6XQGupwquYra+7W/9IRkv/bnT8t35/q1P39va7DXV5f4eyxwbjiWAQCBkuNa5Le+/JkNOEMFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJZCA10Aas7y3bmBLsGr9ITkQJdwXvP32Pp7PIL52AMAAPAnzlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgKXQQBeAX6QnJPu1v+W7c/3aX13CWJwbf+6/urbvAADA+YUzVAAAAABgyadA1aZNGzkcjkqPzMzMKtvPnz+/UtuIiAiPNosXL9a1116rpk2byuFwKDc3t1I//fv3r9TPnXfe6UvpAAAAAOB3Pn3lb/369SovL3e/3rx5swYMGKBhw4Z5XcbpdGrr1q3u1w6Hw2P+kSNH1KdPHw0fPlwZGRle+8nIyND06dPdrxs2bOhL6QAAAADgdz4FqpiYGI/XM2bMUFJSkvr16+d1GYfDobi4OK/zR40aJUnauXPnGdfdsGHDM/YDAAAAALXN+hqqsrIyLViwQOPGjat01qmiw4cPq3Xr1kpMTNTgwYOVl5dntb7XXntNzZo106WXXqopU6bo6NGjZ2x//PhxlZaWejwAAAAAwJ+s7/K3ZMkSFRcXa+zYsV7bdOjQQfPmzVPXrl1VUlKiWbNmqXfv3srLy1PLli2rva5bb71VrVu3VkJCgr766is9+OCD2rp1qxYvXux1maysLD366KO+bBIAAAAA+MQ6UM2dO1cDBw5UQkKC1zapqalKTU11v+7du7c6deqkOXPm6LHHHqv2uiZMmOB+3qVLF8XHx+uaa67R9u3blZSUVOUyU6ZM0eTJk92vS0tLlZiYWO11AgAAAMDZWAWqgoICrVix4oxniKpSv359devWTfn5+TardUtJSZEk5efnew1U4eHhCg8PP6f1AAAAAMCZWF1DlZ2drdjYWA0aNMin5crLy7Vp0ybFx8fbrNbt1K3Vz7UfAAAAADgXPp+hcrlcys7O1pgxYxQa6rn46NGj1aJFC2VlZUmSpk+frl69eqldu3YqLi7WzJkzVVBQoPHjx7uXOXDggAoLC7V7925Jct9iPS4uTnFxcdq+fbtef/11XX/99WratKm++uorTZo0SVdeeaW6du1qveEAAAAAcK58DlQrVqxQYWGhxo0bV2leYWGhQkJ+Oel18OBBZWRkqKioSI0bN1aPHj20evVqde7c2d1m6dKluu2229yvR4wYIUmaNm2aHnnkEYWFhWnFihV67rnndOTIESUmJmro0KF66KGHfC0dAAAAAPzKYYwxgS6iNpSWlioqKkolJSVyOp2BLqdKA0K8/0CyjeW7c/3anz+lJyQHuoRaFcxjIQX3eAT7vqtrgvlYAQBc2HJci/zWlz+zgfXvUAEAAABAXUegAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsOTzD/ui5gTz7+3w2zPnhv2HC0Uwf05J/n2v+Xtb+RwAgAsTZ6gAAAAAwBKBCgAAAAAsEagAAAAAwBKBCgAAAAAsEagAAAAAwBKBCgAAAAAsEagAAAAAwBKBCgAAAAAsEagAAAAAwBKBCgAAAAAsEagAAAAAwBKBCgAAAAAsEagAAAAAwBKBCgAAAAAsEagAAAAAwBKBCgAAAAAsEagAAAAAwBKBCgAAAAAsEagAAAAAwFJooAvAL9ITkgNdAmrI8t25gS7hjPx97Plze4O5NgSfYD72AAAXJs5QAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWCJQAQAAAIAlAhUAAAAAWAoNdAGom5bvzg10CbUqPSE50CWcUTCPRzDXhgubv4+9YP8cCHbB/lnA+AJ1F2eoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMBSaKALwC+W784NdAm1Jj0h2a/91aV9JwX/9vpzfIN9WwHUDn//3QAAf+EMFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYCg10AfhFekKyX/tbvjvXb30Fc23ng7q2vcHM38eyv3GsnBt/jm+wj4W/6wv29wbscawANYszVAAAAABgyadA1aZNGzkcjkqPzMzMKtvPnz+/UtuIiAiPNosXL9a1116rpk2byuFwKDc3t1I/x44dU2Zmppo2baqLLrpIQ4cO1d69e30pHQAAAAD8zqdAtX79eu3Zs8f9yMnJkSQNGzbM6zJOp9NjmYKCAo/5R44cUZ8+ffTkk0967WPSpEn6xz/+oUWLFulf//qXdu/erd/85je+lA4AAAAAfufTNVQxMTEer2fMmKGkpCT169fP6zIOh0NxcXFe548aNUqStHPnzirnl5SUaO7cuXr99dd19dVXS5Kys7PVqVMn/fvf/1avXr182QQAAAAA8Bvra6jKysq0YMECjRs3Tg6Hw2u7w4cPq3Xr1kpMTNTgwYOVl5fn03o2bNigEydOKC0tzT2tY8eOatWqldasWeN1uePHj6u0tNTjAQAAAAD+ZB2olixZouLiYo0dO9Zrmw4dOmjevHl65513tGDBArlcLvXu3Vvff/99tddTVFSksLAwRUdHe0xv3ry5ioqKvC6XlZWlqKgo9yMxMbHa6wQAAACA6rAOVHPnztXAgQOVkJDgtU1qaqpGjx6t5ORk9evXT4sXL1ZMTIzmzJlju9pqmzJlikpKStyP7777rsbXCQAAAKBusfodqoKCAq1YsUKLFy/2abn69eurW7duys/Pr/YycXFxKisrU3FxscdZqr17957x2qzw8HCFh4f7VB8AAAAA+MLqDFV2drZiY2M1aNAgn5YrLy/Xpk2bFB8fX+1levToofr162vlypXuaVu3blVhYaFSU1N9Wj8AAAAA+JPPZ6hcLpeys7M1ZswYhYZ6Lj569Gi1aNFCWVlZkqTp06erV69eateunYqLizVz5kwVFBRo/Pjx7mUOHDigwsJC7d69W9LPYUn6+cxUXFycoqKidPvtt2vy5Mlq0qSJnE6n7r77bqWmpnKHPwAAAAAB5XOgWrFihQoLCzVu3LhK8woLCxUS8stJr4MHDyojI0NFRUVq3LixevToodWrV6tz587uNkuXLtVtt93mfj1ixAhJ0rRp0/TII49Ikp599lmFhIRo6NChOn78uNLT0/Xiiy/6WjoAAAAA+JXPgeraa6+VMabKeR999JHH62effVbPPvvsGfsbO3bsGe8UKEkRERGaPXu2Zs+e7UupAAAAAFCjrO/yBwAAAAB1HYEKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAks+/Q4Was3x3rl/7S09I9mt/QCBwHF/Ygnl8g7k2KfjrQ/DgWAFqFmeoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMASgQoAAAAALBGoAAAAAMBSaKALwC/SE5L92t/y3bl+7a8uYSzOjT+3199jEezq2vYCgeLvz2Xeu0DdxRkqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALAUGugC8Ivlu3P92l96QrLf+vJ3bcGurm2vv/nz2AMAKfg/l4O5Pj6TgZrFGSoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsBQa6AJQc5bvzg10Cagh6QnJgS4BuODVtc/QYP9c8Xd9dWl8/b2twX6sALWNM1QAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYCk00AUAdUF6QnKgSwCAWrV8d26gS0AN8ffY8jcS5zufzlC1adNGDoej0iMzM7PK9vPnz6/UNiIiwqONMUYPP/yw4uPj1aBBA6WlpWnbtm1nXe+MGTN83FQAAAAA8C+fzlCtX79e5eXl7tebN2/WgAEDNGzYMK/LOJ1Obd261f3a4XB4zH/qqaf0/PPP63/+53/Utm1bTZ06Venp6fr66689wtf06dOVkZHhfh0ZGelL6QAAAADgdz4FqpiYGI/XM2bMUFJSkvr16+d1GYfDobi4uCrnGWP03HPP6aGHHtLgwYMlSa+++qqaN2+uJUuWaMSIEe62kZGRXvsBAAAAgECwvilFWVmZFixYoHHjxlU661TR4cOH1bp1ayUmJmrw4MHKy8tzz9uxY4eKioqUlpbmnhYVFaWUlBStWbPGo58ZM2aoadOm6tatm2bOnKmTJ0+esb7jx4+rtLTU4wEAAAAA/mR9U4olS5aouLhYY8eO9dqmQ4cOmjdvnrp27aqSkhLNmjVLvXv3Vl5enlq2bKmioiJJUvPmzT2Wa968uXueJN1zzz3q3r27mjRpotWrV2vKlCnas2ePnnnmGa/rzsrK0qOPPmq7eQAAAABwVtaBau7cuRo4cKASEhK8tklNTVVqaqr7de/evdWpUyfNmTNHjz32WLXXNXnyZPfzrl27KiwsTHfccYeysrIUHh5e5TJTpkzxWK60tFSJiYnVXicAAAAAnI3VV/4KCgq0YsUKjR8/3qfl6tevr27duik/P1+S3NdE7d2716Pd3r17z3i9VEpKik6ePKmdO3d6bRMeHi6n0+nxAAAAAAB/sgpU2dnZio2N1aBBg3xarry8XJs2bVJ8fLwkqW3btoqLi9PKlSvdbUpLS7V27VqPM1uny83NVUhIiGJjY23KBwAAAAC/8Pkrfy6XS9nZ2RozZoxCQz0XHz16tFq0aKGsrCxJP9/qvFevXmrXrp2Ki4s1c+ZMFRQUuM9sORwO3XfffXr88cfVvn17923TExISNGTIEEnSmjVrtHbtWl111VWKjIzUmjVrNGnSJP32t79V48aNz3HzAQAAAMCez4FqxYoVKiws1Lhx4yrNKywsVEjILye9Dh48qIyMDBUVFalx48bq0aOHVq9erc6dO7vbPPDAAzpy5IgmTJig4uJi9enTR8uWLXP/BlV4eLgWLlyoRx55RMePH1fbtm01adIkj+ujAAAAACAQHMYYE+giakNpaamioqJUUlIStNdTuYraB7oE1JD0hORAlwDAR8t35wa6hFrl78+purb/YI+/kaiuHNciv/Xlz2xg/TtUAAAAAFDXEagAAAAAwBKBCgAAAAAsEagAAAAAwBKBCgAAAAAsEagAAAAAwBKBCgAAAAAsEagAAAAAwFJooAvAL0LitgW6BK/40eFzE+w/cMmPKuJCEezvtWDGvgMAO5yhAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsBQa6AJwfgiJ2xboEmqVq6h9oEsA6oTlu3MDXQIAAOeEM1QAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYCk00AUAwSgkblugS6hlwwJdgFfLd+cGuoQzSk9IDnQJ5zV/779gP16ACwGfe4AnzlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgCUCFQAAAABYIlABAAAAgKXQQBcAIPByXIsCXUKtcRW1D3QJACykJyT7tb/lu3P92l8w8/e+A+CJM1QAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYCk00AUAQG0Kidvm1/5yXH7tLugNCBkW6BJQRy3fnevX/vz9WRDM6trnFFDbOEMFAAAAAJZ8ClRt2rSRw+Go9MjMzKyy/fz58yu1jYiI8GhjjNHDDz+s+Ph4NWjQQGlpadq2zfN/jQ4cOKCRI0fK6XQqOjpat99+uw4fPuzjpgIAAACAf/kUqNavX689e/a4Hzk5OZKkYcO8fwXE6XR6LFNQUOAx/6mnntLzzz+vl19+WWvXrlWjRo2Unp6uY8eOuduMHDlSeXl5ysnJ0bvvvquPP/5YEyZM8KV0AAAAAPA7n66hiomJ8Xg9Y8YMJSUlqV+/fl6XcTgciouLq3KeMUbPPfecHnroIQ0ePFiS9Oqrr6p58+ZasmSJRowYoS1btmjZsmVav369Lr/8cknSCy+8oOuvv16zZs1SQkKCL5sAAAAAAH5jfQ1VWVmZFixYoHHjxsnhcHhtd/jwYbVu3VqJiYkaPHiw8vLy3PN27NihoqIipaWluadFRUUpJSVFa9askSStWbNG0dHR7jAlSWlpaQoJCdHatWu9rvf48eMqLS31eAAAAACAP1kHqiVLlqi4uFhjx4712qZDhw6aN2+e3nnnHS1YsEAul0u9e/fW999/L0kqKiqSJDVv3txjuebNm7vnFRUVKTY21mN+aGiomjRp4m5TlaysLEVFRbkfiYmJNpsJAAAAAF5ZB6q5c+dq4MCBZ/zKXWpqqkaPHq3k5GT169dPixcvVkxMjObMmWO72mqbMmWKSkpK3I/vvvuuxtcJAAAAoG6x+h2qgoICrVixQosXL/Zpufr166tbt27Kz8+XJPe1VXv37lV8fLy73d69e5WcnOxus2/fPo9+Tp48qQMHDni9NkuSwsPDFR4e7lN9AAAAAOALqzNU2dnZio2N1aBBg3xarry8XJs2bXKHp7Zt2youLk4rV650tyktLdXatWuVmpoq6eezXMXFxdqwYYO7zapVq+RyuZSSkmJTPgAAAAD4hc9nqFwul7KzszVmzBiFhnouPnr0aLVo0UJZWVmSpOnTp6tXr15q166diouLNXPmTBUUFGj8+PGSfr4D4H333afHH39c7du3V9u2bTV16lQlJCRoyJAhkqROnTrpuuuuU0ZGhl5++WWdOHFCEydO1IgRI7jDHwAAAICA8jlQrVixQoWFhRo3blyleYWFhQoJ+eWk18GDB5WRkaGioiI1btxYPXr00OrVq9W5c2d3mwceeEBHjhzRhAkTVFxcrD59+mjZsmUePwD82muvaeLEibrmmmsUEhKioUOH6vnnn/e1dAAAAADwK4cxxgS6iNpQWlqqqKgolZSUyOl0BrocADgvDQjx/kPuwWD57txAl4DzREjctkCXACCA/JkNrO/yBwAAAAB1HYEKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAEoEKAAAAACwRqAAAAADAks8/7AsAqLtyXIsCXQIAAEGFM1QAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWCFQAAAAAYIlABQAAAACWQgNdQG0xxkiSSktLA1wJAAAAgEA6lQlOZYRzUWcC1aFDhyRJiYmJAa4EAAAAQDA4dOiQoqKizqkPh/FHLDsPuFwu7d69W5GRkXI4HIEup84qLS1VYmKivvvuOzmdzkCXU6cxFsGF8QgejEXwYCyCC+MRPBiLc2eM0aFDh5SQkKCQkHO7CqrOnKEKCQlRy5YtA10G/pfT6eQDIEgwFsGF8QgejEXwYCyCC+MRPBiLc3OuZ6ZO4aYUAAAAAGCJQAUAAAAAlghUqFXh4eGaNm2awsPDA11KncdYBBfGI3gwFsGDsQgujEfwYCyCS525KQUAAAAA+BtnqAAAAADAEoEKAAAAACwRqAAAAADAEoEKAAAAACwRqODVjBkz5HA4dN9997mn/eUvf1H//v3ldDrlcDhUXFxcabkDBw5o5MiRcjqdio6O1u23367Dhw97tPnqq6/Ut29fRUREKDExUU899VSlfhYtWqSOHTsqIiJCXbp00Xvvvecx3xijhx9+WPHx8WrQoIHS0tK0bds2v2x7MLIdjzZt2sjhcHg8ZsyY4dGG8fDN6WNx4MAB3X333erQoYMaNGigVq1a6Z577lFJSYnHcoWFhRo0aJAaNmyo2NhY/dd//ZdOnjzp0eajjz5S9+7dFR4ernbt2mn+/PmV1j979my1adNGERERSklJ0bp16zzmHzt2TJmZmWratKkuuugiDR06VHv37vXrPggmtuNx+vvC4XBo4cKFHm0YD99U9Tl1xx13KCkpSQ0aNFBMTIwGDx6sb775xmM53hv+ZzsWvC9qRlXjcYoxRgMHDpTD4dCSJUs85vHeOE8YoArr1q0zbdq0MV27djX33nuve/qzzz5rsrKyTFZWlpFkDh48WGnZ6667zlx22WXm3//+t/nkk09Mu3btzC233OKeX1JSYpo3b25GjhxpNm/ebP72t7+ZBg0amDlz5rjbfPbZZ6ZevXrmqaeeMl9//bV56KGHTP369c2mTZvcbWbMmGGioqLMkiVLzJdffml+/etfm7Zt25qffvqpRvZJIJ3LeLRu3dpMnz7d7Nmzx/04fPiwez7j4ZuqxmLTpk3mN7/5jVm6dKnJz883K1euNO3btzdDhw51L3fy5Elz6aWXmrS0NLNx40bz3nvvmWbNmpkpU6a423z77bemYcOGZvLkyebrr782L7zwgqlXr55ZtmyZu83ChQtNWFiYmTdvnsnLyzMZGRkmOjra7N27193mzjvvNImJiWblypXm888/N7169TK9e/eu+Z0TALbjYYwxkkx2drbHe6Pi8cp4+Mbb59ScOXPMv/71L7Njxw6zYcMGc8MNN5jExERz8uRJYwzvjZpgOxbG8L6oCd7G45RnnnnGDBw40Egyb7/9tns6743zB4EKlRw6dMi0b9/e5OTkmH79+lX55v/www+r/Af8119/bSSZ9evXu6e9//77xuFwmF27dhljjHnxxRdN48aNzfHjx91tHnzwQdOhQwf36+HDh5tBgwZ59J2SkmLuuOMOY4wxLpfLxMXFmZkzZ7rnFxcXm/DwcPO3v/3NetuD0bmMhzE/B6pnn33Wa/+MR/VVZyxOefPNN01YWJg5ceKEMcaY9957z4SEhJiioiJ3m5deesk4nU73vn/ggQfMr371K49+br75ZpOenu5+3bNnT5OZmel+XV5ebhISEkxWVpYx5uf9Xr9+fbNo0SJ3my1bthhJZs2aNfYbH4TOZTyMMZX+8XI6xqP6fBmLL7/80kgy+fn5xhjeG/52LmNhDO8LfzvbeGzcuNG0aNHC7Nmzp9K+571x/uArf6gkMzNTgwYNUlpams/LrlmzRtHR0br88svd09LS0hQSEqK1a9e621x55ZUKCwtzt0lPT9fWrVt18OBBd5vT15+enq41a9ZIknbs2KGioiKPNlFRUUpJSXG3uVCcy3icMmPGDDVt2lTdunXTzJkzPb4uwHhUny9jUVJSIqfTqdDQUEk/78MuXbqoefPm7jbp6ekqLS1VXl6eu82Z9nNZWZk2bNjg0SYkJERpaWnuNhs2bNCJEyc82nTs2FGtWrW6oMZCOrfxqNhHs2bN1LNnT82bN0+mwk8zMh7VV92xOHLkiLKzs9W2bVslJiZK4r3hb+cyFhX74H3hH2caj6NHj+rWW2/V7NmzFRcXV2k+743zR+jZm6AuWbhwob744gutX7/eavmioiLFxsZ6TAsNDVWTJk1UVFTkbtO2bVuPNqc+LIqKitS4cWMVFRV5fICcalOxj4rLVdXmQnCu4yFJ99xzj7p3764mTZpo9erVmjJlivbs2aNnnnlGEuNRXb6Mxf79+/XYY49pwoQJ7mne9uGpeWdqU1paqp9++kkHDx5UeXl5lW1OXQdRVFSksLAwRUdHV2pzoYyFdO7jIUnTp0/X1VdfrYYNG+qDDz7Q7373Ox0+fFj33HOPJMajuqozFi+++KIeeOABHTlyRB06dFBOTo77P3F4b/jPuY6FxPvCn842HpMmTVLv3r01ePDgKufz3jh/EKjg9t133+nee+9VTk6OIiIiAl1Oneev8Zg8ebL7edeuXRUWFqY77rhDWVlZCg8P90epFzxfxqK0tFSDBg1S586d9cgjj9ROgXWMv8Zj6tSp7ufdunXTkSNHNHPmTPc/HHF21R2LkSNHasCAAdqzZ49mzZql4cOH67PPPuNvjR/5ayx4X/jH2cZj6dKlWrVqlTZu3BiA6uBvfOUPbhs2bNC+ffvUvXt3hYaGKjQ0VP/617/0/PPPKzQ0VOXl5WftIy4uTvv27fOYdvLkSR04cMB9OjsuLq7SnWNOvT5bm4rzKy5XVZvznT/GoyopKSk6efKkdu7cKYnxqI7qjsWhQ4d03XXXKTIyUm+//bbq16/v7uNc9rPT6VSDBg3UrFkz1atX76xjUVZWVumOjxfKWEj+GY+qpKSk6Pvvv9fx48clMR7VUd2xiIqKUvv27XXllVfq73//u7755hu9/fbbknhv+Is/xqIqvC/snG08cnJytH37dkVHR7vnS9LQoUPVv39/Sbw3zicEKrhdc8012rRpk3Jzc92Pyy+/XCNHjlRubq7q1at31j5SU1NVXFysDRs2uKetWrVKLpdLKSkp7jYff/yxTpw44W6Tk5OjDh06qHHjxu42K1eu9Og7JydHqampkqS2bdsqLi7Oo01paanWrl3rbnO+88d4VCU3N1chISHur2YyHmdXnbEoLS3Vtddeq7CwMC1durTS/0impqZq06ZNHv/hkJOTI6fTqc6dO7vbnGk/h4WFqUePHh5tXC6XVq5c6W7To0cP1a9f36PN1q1bVVhYeEGMheSf8ahKbm6uGjdu7D5zy3icnc3nlPn5hljuf6Dz3vAPf4xFVXhf2DnbePzxj3/UV1995TFfkp599lllZ2dL4r1xXgnkHTEQ/E6/I82ePXvMxo0bzSuvvGIkmY8//ths3LjR/Pjjj+421113nenWrZtZu3at+fTTT0379u09bpteXFxsmjdvbkaNGmU2b95sFi5caBo2bFjpNt2hoaFm1qxZZsuWLWbatGlV3qY7OjravPPOO+arr74ygwcPviBv012Rr+OxevVq8+yzz5rc3Fyzfft2s2DBAhMTE2NGjx7t7oPxsFNxLEpKSkxKSorp0qWLyc/P97jd8Om3hr722mtNbm6uWbZsmYmJiany9rf/9V//ZbZs2WJmz55d5e1vw8PDzfz5883XX39tJkyYYKKjoz3uAnXnnXeaVq1amVWrVpnPP//cpKammtTU1NrZMQHi63gsXbrUvPLKK2bTpk1m27Zt5sUXXzQNGzY0Dz/8sLtPxsNOxbHYvn27eeKJJ8znn39uCgoKzGeffWZuuOEG06RJE/ctm3lv1Bxfx4L3Rc06210X5eW26bw3gh+BCmd0+pt/2rRpRlKlR3Z2trvNjz/+aG655RZz0UUXGafTaW677TZz6NAhj36//PJL06dPHxMeHm5atGhhZsyYUWndb775prnkkktMWFiY+dWvfmX++c9/esx3uVxm6tSppnnz5iY8PNxcc801ZuvWrX7d/mDj63hs2LDBpKSkmKioKBMREWE6depknnjiCXPs2DGPfhkP31Uci1O3ra/qsWPHDvcyO3fuNAMHDjQNGjQwzZo1M7///e89buN9qq/k5GQTFhZmLr74Yo/31ikvvPCCadWqlQkLCzM9e/Y0//73vz3m//TTT+Z3v/udady4sWnYsKG58cYbzZ49e/y9C4KKr+Px/vvvm+TkZHPRRReZRo0amcsuu8y8/PLLpry83KNfxsN3Fcdi165dZuDAgSY2NtbUr1/ftGzZ0tx6663mm2++8ViG90bN8HUseF/ULF8DlTG8N84XDmMq3AsTAAAAAFBtXEMFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgiUAFAAAAAJYIVAAAAABgKTTQBdSmY8eOqaysLNBlAAAAAAiwsLAwRUREnHM/dSZQHTt2TFENGqtMxwJdCgAAAIAAi4uL044dO845VNWZQFVWVqYyHVMfXa9Q1Zccv3zb0RHiUIUXXqZXeO5luiMkxEv7075Z6fCyfIV1e1uH13492nhZl9c+q7Fe+bYvjEcbL/V4eV69ZX95aqqx7dVq421dkoy3feqtjhAv0z3ae6mj4oortgmpuD1Vt/Hap7/ah3iZ7m3/VOS1/blMr8a+PW2e3+rw0r/XZWugHn+18bqs/NTG19oqtTNVtzuHfeHRp7zw2qepsk111uVrnw5f1ytv/VS9lQ4f1+vweO6ltjOs2/Ojouq+PP/EeFt31ct6ax+i6tRQoX01pnv06a1NNZ57fsz72I+8tXF5WZe3ZX9pL0n1vK6jYr8V2nvsi6rX7dmnlzbeplfos+I21PNY1y/P61XYFs/pXralGvV4rMtbDRX7qVCD53a5qpzubf9479/zPVfP23Z6qbWel+PXoyYvx1fF6Z5tfqnH47jxqLPC8wpHv2ebitPP/tyzfYiXNpWnlx5yqXWPnSorKyNQ+SpU9RXqOC1QeQkX3qZXKxB5W/b0eSFelj+nQOX1L9PZ66vOeoMiUPnW/rwKVN7+oXQeBir/BSdv06uxb0+bVxN1XLCBqjptVI02vtZQafkaDlRetueCDVTVml71er2HoHMNVL4FpHMKVNVpX4uBynso8n+gqk57qbqByts/qms2UHkNM9UITt6n+z9Q1fPo55eDLqTCAVhxuuf+qTi96vaVA1XFdt7Cmapu41FrddqcPVDVq4FA5dm+6n1UvUDl/1tIcFMKAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAAS6GBLqC2ndQJyUgVs6TDOCq08Da9wnMv0x0mpMrpMqfn1grzXBWWd3hZ3uHlecU87NFGVU/32mc11uttuql6uvFo46UeL8+rt2zFEiruz6rbm2rsH8/hq9jo9CGvRh0hXqZ7PYwq1FFxxR7DXXF7qm7jtU9/tfd2iHs95qrT/lymV2PfnjbPb3V46d/rsjVQj7/aeF1Wfmrja22V2pmq253DvvDoU1547dNU2aY66/K1T4ev65W3fqreSoeP63V4PPdS2xnW7flRUXVfnn9ivK276mW9tTequgaXl/Yh1Zgeomq0qcZzz495H/uRtzauKqc75G3Zin88pXpe11Gx3wrtPfZF1ev27NNLG2/TK/RZcRvqeazrl+f1KmyL53Qv21KNejzW5a2Giv1UqMFzu1xVTve2f7z37/meq+dtO73UWs/L8etRk5fjq+J0zza/1ONx3HjUWeF5haPfs03F6Wd/7tleXtpUrq30kOdxfy7qTKAKCwtTXFycPi167+cJFY/D8oCUBAAAACBA4uLiFBYWds79OIwxXv9z7kJz7NgxlZWVBboMnKa0tFSJiYn67rvv5HQ6A10O4IHjE8GKYxPBimMTwer0YzMsLEwRERHn3G+dOUMlSREREX7ZaagZTqeTD14ELY5PBCuOTQQrjk0EK38fm9yUAgAAAAAsEagAAAAAwBKBCgEXHh6uadOmKTw8PNClAJVwfCJYcWwiWHFsIljV1LFZp25KAQAAAAD+xBkqAAAAALBEoAIAAAAASwQqAAAAALBEoAIAAAAASwQqAAAAALBEoEKtmD17ttq0aaOIiAilpKRo3bp11Vpu4cKFcjgcGjJkSM0WiDrLl2Nz/vz5cjgcHo+IiIharBZ1ja+fncXFxcrMzFR8fLzCw8N1ySWX6L333qulalGX+HJs9u/fv9Jnp8Ph0KBBg2qxYtQVvn5uPvfcc+rQoYMaNGigxMRETZo0SceOHfNpnQQq1Lg33nhDkydP1rRp0/TFF1/osssuU3p6uvbt23fG5Xbu3Kn7779fffv2raVKUdfYHJtOp1N79uxxPwoKCmqxYtQlvh6fZWVlGjBggHbu3Km///3v2rp1q1555RW1aNGilivHhc7XY3Px4sUen5ubN29WvXr1NGzYsFquHBc6X4/N119/XX/4wx80bdo0bdmyRXPnztUbb7yh//t//69vKzZADevZs6fJzMx0vy4vLzcJCQkmKyvL6zInT540vXv3Nv/93/9txowZYwYPHlwLlaKu8fXYzM7ONlFRUbVUHeo6X4/Pl156yVx88cWmrKystkpEHWXzd72iZ5991kRGRprDhw/XVImoo3w9NjMzM83VV1/tMW3y5Mnmiiuu8Gm9nKFCjSorK9OGDRuUlpbmnhYSEqK0tDStWbPG63LTp09XbGysbr/99tooE3WQ7bF5+PBhtW7dWomJiRo8eLDy8vJqo1zUMTbH59KlS5WamqrMzEw1b95cl156qZ544gmVl5fXVtmoA2w/OyuaO3euRowYoUaNGtVUmaiDbI7N3r17a8OGDe6vBX777bd67733dP311/u07lD7soGz279/v8rLy9W8eXOP6c2bN9c333xT5TKffvqp5s6dq9zc3FqoEHWVzbHZoUMHzZs3T127dlVJSYlmzZql3r17Ky8vTy1btqyNslFH2Byf3377rVatWqWRI0fqvffeU35+vn73u9/pxIkTmjZtWm2UjTrA5tisaN26ddq8ebPmzp1bUyWijrI5Nm+99Vbt379fffr0kTFGJ0+e1J133unzV/44Q4WgcujQIY0aNUqvvPKKmjVrFuhyAA+pqakaPXq0kpOT1a9fPy1evFgxMTGaM2dOoEsD5HK5FBsbq7/85S/q0aOHbr75Zv3xj3/Uyy+/HOjSALe5c+eqS5cu6tmzZ6BLAfTRRx/piSee0IsvvqgvvvhCixcv1j//+U899thjPvXDGSrUqGbNmqlevXrau3evx/S9e/cqLi6uUvvt27dr586duuGGG9zTXC6XJCk0NFRbt25VUlJSzRaNOsHXY7Mq9evXV7du3ZSfn18TJaIOszk+4+PjVb9+fdWrV889rVOnTioqKlJZWZnCwsJqtGbUDefy2XnkyBEtXLhQ06dPr8kSUUfZHJtTp07VqFGjNH78eElSly5ddOTIEU2YMEF//OMfFRJSvXNPnKFCjQoLC1OPHj20cuVK9zSXy6WVK1cqNTW1UvuOHTtq06ZNys3NdT9+/etf66qrrlJubq4SExNrs3xcwHw9NqtSXl6uTZs2KT4+vqbKRB1lc3xeccUVys/Pd/8nlCT95z//UXx8PGEKfnMun52LFi3S8ePH9dvf/ramy0QdZHNsHj16tFJoOvWfUsaY6q/c17tnAL5auHChCQ8PN/Pnzzdff/21mTBhgomOjjZFRUXGGGNGjRpl/vCHP3hdnrv8oab4emw++uijZvny5Wb79u1mw4YNZsSIESYiIsLk5eUFahNwAfP1+CwsLDSRkZFm4sSJZuvWrebdd981sbGx5vHHHw/UJuACZft3vU+fPubmm2+u7XJRh/h6bE6bNs1ERkaav/3tb+bbb781H3zwgUlKSjLDhw/3ab185Q817uabb9YPP/yghx9+WEVFRUpOTtayZcvcFw0WFhZW+5Qq4E++HpsHDx5URkaGioqK1LhxY/Xo0UOrV69W586dA7UJuID5enwmJiZq+fLlmjRpkrp27aoWLVro3nvv1YMPPhioTcAFyubv+tatW/Xpp5/qgw8+CETJqCN8PTYfeughORwOPfTQQ9q1a5diYmJ0ww036E9/+pNP63UY48v5LAAAAADAKZwWAAAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABLBCoAAAAAsESgAgAAAABL/x9ga44uakFdwQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -558,7 +714,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -567,13 +723,13 @@ "" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 45e705f4ac4882d21458a380633225b70f98b1ab Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Wed, 13 Sep 2023 15:31:56 +0300 Subject: [PATCH 15/31] Updates to wofe: Try to fix generalized weights, custom resolution input (WIP), fix discrepancies in B=0 handling (WIP) --- eis_toolkit/prediction/wofe_new.py | 65 +++++++++- notebooks/wofe_new.ipynb | 196 ++++++++++++++--------------- 2 files changed, 160 insertions(+), 101 deletions(-) diff --git a/eis_toolkit/prediction/wofe_new.py b/eis_toolkit/prediction/wofe_new.py index 1e4967b3..6fb5001c 100644 --- a/eis_toolkit/prediction/wofe_new.py +++ b/eis_toolkit/prediction/wofe_new.py @@ -52,6 +52,9 @@ def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray, lapl p_A = (A + SMOOTH_CONSTANT) / (A + B + 2 * SMOOTH_CONSTANT) p_C = (C + SMOOTH_CONSTANT) / (C + D + 2 * SMOOTH_CONSTANT) + if A == 0: + return A, B, C, D, 0, 0, 0, 0, 0, 0, 0 + # Calculate metrics w_plus = np.log(p_A / p_C) if p_A != 0 and p_C != 0 else 0 w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0 @@ -60,9 +63,10 @@ def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray, lapl # Calculate signifigance metrics s_w_plus = np.sqrt((1 / A if A != 0 else 0) + (1 / C if C != 0 else 0)) s_w_minus = np.sqrt((1 / B if B != 0 else 0) + (1 / D if D != 0 else 0)) - s_contrast = np.sqrt(s_w_plus**2 + s_w_minus**2) + # s_w_plus = np.sqrt((1 / A) + (1 / C if C != 0 else 0)) + # s_w_minus = np.sqrt((1 / B) + (1 / D if D != 0 else 0)) - # Calculate studentized contrast + s_contrast = np.sqrt(s_w_plus**2 + s_w_minus**2) studentized_contrast = contrast / s_contrast return A, B, C, D, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast, studentized_contrast @@ -98,6 +102,53 @@ def reclassify_by_studentized_contrast(df: pd.DataFrame, studentized_contrast_th raise ValueError("Reclassification failed: 'Favorable' class (Class 2) doesn't exist.") +def reclassify_by_studentized_contrast3(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: + """Create generalized classes based on the studentized contrast threhsold value.""" + index = df.idxmax()["Contrast"] + + if df.loc[index, "Studentized contrast"] < studentized_contrast_threshold: + raise Exception("Failed") + + df["Generalized class"] = 1 + for i in range(0, index + 1): + df.loc[i, "Generalized class"] = 2 + + # df["Generalized class"] = np.where(df["Studentized contrast"] >= studentized_contrast_threshold, 2, 1) + + # # Check if both classes are present + # unique_classes = df["Generalized class"].unique() + # if 1 not in unique_classes: + # raise ValueError("Reclassification failed: 'Unfavorable' class (Class 1) doesn't exist.") + # elif 2 not in unique_classes: + # raise ValueError("Reclassification failed: 'Favorable' class (Class 2) doesn't exist.") + + +def reclassify_by_studentized_contrast2(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: + """Create generalized classes based on the studentized contrast threshold value.""" + + # Sort the DataFrame based on the 'Contrast' value + df.sort_values(by="Contrast", ascending=False, inplace=True) + + # Initialize a flag to check if we have reached the highest contrast class that meets the threshold + highest_contrast_reached = False + + for idx, row in df.iterrows(): + if row["Studentized contrast"] >= studentized_contrast_threshold and not highest_contrast_reached: + df.at[idx, "Generalized class"] = 2 + highest_contrast_reached = True + elif highest_contrast_reached: + df.at[idx, "Generalized class"] = 2 + else: + df.at[idx, "Generalized class"] = 1 + + # Check if both classes are present + unique_classes = df["Generalized class"].unique() + if 1 not in unique_classes: + raise ValueError("Reclassification failed: 'Unfavorable' class (Class 1) doesn't exist.") + elif 2 not in unique_classes: + raise ValueError("Reclassification failed: 'Favorable' class (Class 2) doesn't exist.") + + def calculate_generalized_weights(weights_df: pd.DataFrame) -> None: """ Calculate generalized weights. @@ -167,6 +218,7 @@ def generate_rasters_from_metrics( def weights_of_evidence( evidential_raster: rasterio.io.DatasetReader, deposits: gpd.GeoDataFrame, + resolution: Optional[float] = None, weights_type: Literal["unique", "ascending", "descending"] = "unique", studentized_contrast_threshold: Number = 2, laplace_smoothing: bool = False, @@ -178,6 +230,8 @@ def weights_of_evidence( Args: evidential_raster: The evidential raster. deposits: Vector data representing the mineral deposits or occurences point data. + resolution: The resolution i.e. cell size of the output raster. + Optional parameter, if not given, resolution of evidential raster is used. weights_type: Accepted values are 'unique' for unique weights, 'ascending' for cumulative ascending weights, 'descending' for cumulative descending weights. Defaults to 'unique'. studentized_contrast_threshold: Studentized contrast threshold value used to reclassify all classes. @@ -209,6 +263,11 @@ def weights_of_evidence( geodataframe=deposits, default_value=1.0, base_raster_profile=raster_meta, fill_value=0.0 ) + # Resample + if resolution is not None: + # TODO + pass + # Mask NaN out of the array nodata_mask = np.isnan(evidence_array) masked_evidence_array = evidence_array[~nodata_mask] @@ -249,7 +308,7 @@ def weights_of_evidence( # 4. If we use cumulative weights type, reclassify and calculate generalized weights if weights_type != "unique": - reclassify_by_studentized_contrast(weights_df, studentized_contrast_threshold) + reclassify_by_studentized_contrast3(weights_df, studentized_contrast_threshold) # calculate_generalized_weights(weights_df) calculate_generalized_weights_alternative(weights_df, masked_deposit_array) diff --git a/notebooks/wofe_new.ipynb b/notebooks/wofe_new.ipynb index fe270a80..e71026b3 100644 --- a/notebooks/wofe_new.ipynb +++ b/notebooks/wofe_new.ipynb @@ -28,9 +28,9 @@ "with rasterio.open(\"../tests/data/local/Int_wofe_ev_nan.tif\") as test_ev:\n", " # with rasterio.open(\"../tests/data/local/wofe_dep_new.tif\") as test_dep:\n", " gdf = gpd.read_file(\"../tests/data/local/Dep1s.shp\")\n", - " test_wgt_un_, test_gen_un_, test_rst_meta = weights_of_evidence(test_ev, gdf, 'unique')\n", - " test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_of_evidence(test_ev, gdf, 'ascending', 1)\n", - " test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_of_evidence(test_ev, gdf, 'descending', 1)" + " test_wgt_un_, test_gen_un_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='unique')\n", + " test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='ascending', studentized_contrast_threshold=1)\n", + " test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='descending', studentized_contrast_threshold=1)" ] }, { @@ -91,12 +91,12 @@ " 11\n", " 0\n", " 0.000\n", - " 0.302\n", - " 0.014\n", - " 0.253\n", - " -0.014\n", - " 0.393\n", - " -0.037\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", " \n", " \n", " 2\n", @@ -130,12 +130,12 @@ " 1\n", " 0\n", " 0.000\n", - " 1.000\n", - " 0.001\n", - " 0.253\n", - " -0.001\n", - " 1.031\n", - " -0.001\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", " \n", " \n", " 5\n", @@ -143,12 +143,12 @@ " 43\n", " 0\n", " 0.000\n", - " 0.152\n", - " 0.058\n", - " 0.253\n", - " -0.058\n", - " 0.295\n", - " -0.196\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", " \n", " \n", " 6\n", @@ -169,12 +169,12 @@ " 10\n", " 0\n", " 0.000\n", - " 0.316\n", - " 0.013\n", - " 0.253\n", - " -0.013\n", - " 0.405\n", - " -0.033\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", " \n", " \n", "\n", @@ -183,23 +183,23 @@ "text/plain": [ " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", "0 1.0 275 9 0.481 0.339 -0.399 0.381 0.880 \n", - "1 2.0 11 0 0.000 0.302 0.014 0.253 -0.014 \n", + "1 2.0 11 0 0.000 0.000 0.000 0.000 0.000 \n", "2 3.0 396 5 -0.492 0.450 0.341 0.306 -0.833 \n", "3 5.0 43 1 0.130 1.012 -0.008 0.261 0.138 \n", - "4 6.0 1 0 0.000 1.000 0.001 0.253 -0.001 \n", - "5 8.0 43 0 0.000 0.152 0.058 0.253 -0.058 \n", + "4 6.0 1 0 0.000 0.000 0.000 0.000 0.000 \n", + "5 8.0 43 0 0.000 0.000 0.000 0.000 0.000 \n", "6 10.0 2 1 3.867 1.414 -0.063 0.261 3.931 \n", - "7 13.0 10 0 0.000 0.316 0.013 0.253 -0.013 \n", + "7 13.0 10 0 0.000 0.000 0.000 0.000 0.000 \n", "\n", " S_Contrast Studentized contrast \n", "0 0.510 1.728 \n", - "1 0.393 -0.037 \n", + "1 0.000 0.000 \n", "2 0.544 -1.531 \n", "3 1.045 0.132 \n", - "4 1.031 -0.001 \n", - "5 0.295 -0.196 \n", + "4 0.000 0.000 \n", + "5 0.000 0.000 \n", "6 1.438 2.733 \n", - "7 0.405 -0.033 " + "7 0.000 0.000 " ] }, "execution_count": 3, @@ -267,8 +267,8 @@ " 0.510\n", " 1.728\n", " 2\n", - " 0.4605\n", - " 0.2396\n", + " 0.481\n", + " 0.3389\n", " \n", " \n", " 1\n", @@ -282,9 +282,9 @@ " 0.818\n", " 0.510\n", " 1.605\n", - " 2\n", - " 0.4605\n", - " 0.2396\n", + " 1\n", + " 0.030\n", + " 0.1011\n", " \n", " \n", " 2\n", @@ -299,8 +299,8 @@ " 0.764\n", " 0.021\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " 0.030\n", + " 0.1011\n", " \n", " \n", " 3\n", @@ -315,8 +315,8 @@ " 1.042\n", " 0.144\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " 0.030\n", + " 0.1011\n", " \n", " \n", " 4\n", @@ -331,8 +331,8 @@ " 1.042\n", " 0.125\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " 0.030\n", + " 0.1011\n", " \n", " \n", " 5\n", @@ -347,8 +347,8 @@ " 1.077\n", " -1.411\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " 0.030\n", + " 0.1011\n", " \n", " \n", " 6\n", @@ -363,8 +363,8 @@ " 0.405\n", " 0.033\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " 0.030\n", + " 0.1011\n", " \n", " \n", " 7\n", @@ -379,8 +379,8 @@ " 0.253\n", " 0.000\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " 0.030\n", + " 0.1011\n", " \n", " \n", "\n", @@ -398,24 +398,24 @@ "7 13.0 781 16 0.000 0.253 0.000 0.000 0.000 \n", "\n", " S_Contrast Studentized contrast Generalized class Generalized WPlus \\\n", - "0 0.510 1.728 2 0.4605 \n", - "1 0.510 1.605 2 0.4605 \n", - "2 0.764 0.021 1 -0.0028 \n", - "3 1.042 0.144 1 -0.0028 \n", - "4 1.042 0.125 1 -0.0028 \n", - "5 1.077 -1.411 1 -0.0028 \n", - "6 0.405 0.033 1 -0.0028 \n", - "7 0.253 0.000 1 -0.0028 \n", + "0 0.510 1.728 2 0.481 \n", + "1 0.510 1.605 1 0.030 \n", + "2 0.764 0.021 1 0.030 \n", + "3 1.042 0.144 1 0.030 \n", + "4 1.042 0.125 1 0.030 \n", + "5 1.077 -1.411 1 0.030 \n", + "6 0.405 0.033 1 0.030 \n", + "7 0.253 0.000 1 0.030 \n", "\n", " Generalized S_WPlus \n", - "0 0.2396 \n", - "1 0.2396 \n", - "2 0.1059 \n", - "3 0.1059 \n", - "4 0.1059 \n", - "5 0.1059 \n", - "6 0.1059 \n", - "7 0.1059 " + "0 0.3389 \n", + "1 0.1011 \n", + "2 0.1011 \n", + "3 0.1011 \n", + "4 0.1011 \n", + "5 0.1011 \n", + "6 0.1011 \n", + "7 0.1011 " ] }, "execution_count": 4, @@ -476,15 +476,15 @@ " 10\n", " 0\n", " 0.000\n", - " 0.316\n", - " 0.013\n", - " 0.253\n", - " -0.013\n", - " 0.405\n", - " -0.033\n", - " 1\n", - " -0.1911\n", - " 0.1730\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 0.000\n", + " 2\n", + " 0.8228\n", + " 1.0235\n", " \n", " \n", " 1\n", @@ -499,8 +499,8 @@ " 1.077\n", " 1.411\n", " 2\n", - " 1.4694\n", - " 1.0445\n", + " 0.8228\n", + " 1.0235\n", " \n", " \n", " 2\n", @@ -515,7 +515,7 @@ " 1.042\n", " -0.125\n", " 1\n", - " -0.1911\n", + " -0.1860\n", " 0.1730\n", " \n", " \n", @@ -531,7 +531,7 @@ " 1.042\n", " -0.144\n", " 1\n", - " -0.1911\n", + " -0.1860\n", " 0.1730\n", " \n", " \n", @@ -547,7 +547,7 @@ " 0.764\n", " -0.021\n", " 1\n", - " -0.1911\n", + " -0.1860\n", " 0.1730\n", " \n", " \n", @@ -563,7 +563,7 @@ " 0.510\n", " -1.605\n", " 1\n", - " -0.1911\n", + " -0.1860\n", " 0.1730\n", " \n", " \n", @@ -579,7 +579,7 @@ " 0.510\n", " -1.728\n", " 1\n", - " -0.1911\n", + " -0.1860\n", " 0.1730\n", " \n", " \n", @@ -595,7 +595,7 @@ " 0.253\n", " 0.000\n", " 1\n", - " -0.1911\n", + " -0.1860\n", " 0.1730\n", " \n", " \n", @@ -604,7 +604,7 @@ ], "text/plain": [ " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", - "0 13.0 10 0 0.000 0.316 0.013 0.253 -0.013 \n", + "0 13.0 10 0 0.000 0.000 0.000 0.000 0.000 \n", "1 10.0 12 1 1.469 1.044 -0.050 0.261 1.519 \n", "2 8.0 55 1 -0.122 1.009 0.009 0.261 -0.130 \n", "3 6.0 56 1 -0.140 1.009 0.010 0.261 -0.150 \n", @@ -614,18 +614,18 @@ "7 1.0 781 16 0.000 0.253 0.000 0.000 0.000 \n", "\n", " S_Contrast Studentized contrast Generalized class Generalized WPlus \\\n", - "0 0.405 -0.033 1 -0.1911 \n", - "1 1.077 1.411 2 1.4694 \n", - "2 1.042 -0.125 1 -0.1911 \n", - "3 1.042 -0.144 1 -0.1911 \n", - "4 0.764 -0.021 1 -0.1911 \n", - "5 0.510 -1.605 1 -0.1911 \n", - "6 0.510 -1.728 1 -0.1911 \n", - "7 0.253 0.000 1 -0.1911 \n", + "0 0.000 0.000 2 0.8228 \n", + "1 1.077 1.411 2 0.8228 \n", + "2 1.042 -0.125 1 -0.1860 \n", + "3 1.042 -0.144 1 -0.1860 \n", + "4 0.764 -0.021 1 -0.1860 \n", + "5 0.510 -1.605 1 -0.1860 \n", + "6 0.510 -1.728 1 -0.1860 \n", + "7 0.253 0.000 1 -0.1860 \n", "\n", " Generalized S_WPlus \n", - "0 0.1730 \n", - "1 1.0445 \n", + "0 1.0235 \n", + "1 1.0235 \n", "2 0.1730 \n", "3 0.1730 \n", "4 0.1730 \n", @@ -695,7 +695,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAAK7CAYAAADBfQ+iAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABRAElEQVR4nO3df5hWdZ0//tc9DAyIzAAKDOAIBIS6qSBeIuSvEkPjU1imaa6gJJahltbm+l0NtTZIKf3kmrmu4pa5lhuS65YGqNsPSM1EEZUVE1BhUBMYAeXHzPn+4cfbuZ15w9zDwIzM43Fd93Xd9znv8z6vc97nvocn5z7nzmVZlgUAAAANlLR2AQAAAG2VwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEQJt05ZVXRi6XK5g2cODAOPvss3drHbfffnvkcrlYvnz5bl3v+5199tkxcODAZi+79957t2xBAO2EwATwAfLiiy/GBRdcEB/+8Idjr732ir322isOOuigmDp1ajz11FOtXR4fcJs2bYorr7wyHn744dYuBaDNKG3tAgBomvvuuy8+//nPR2lpaZx55plx6KGHRklJSTz33HMxe/bsuOmmm+LFF1+MAQMGtHapu8zSpUujpKR9/l/fLbfcEnV1dbt0HZs2bYqrrroqIiKOO+64XbougA8KgQngA+CFF16I008/PQYMGBDz58+Pvn37Fsz/3ve+Fz/60Y/adJjYuHFjdO3adaf6KCsra6FqPng6duzY2iUAtEtt9y8rAHnXXHNNbNy4MWbNmtUgLEVElJaWxkUXXRRVVVUF05977rn43Oc+Fz179ozOnTvH4YcfHvfee29Bm3ev0fnjH/8Yl1xySfTq1Su6du0an/nMZ+K1115rsK7f/OY3cfTRR0fXrl2jW7duMX78+FiyZElBm3evmXnhhRfik5/8ZHTr1i3OPPPMiIj4/e9/H6eeemrsv//+UVZWFlVVVXHxxRfHW2+9tcP98P5rmHK5XPJR/5qjpuyHiIglS5bExz/+8ejSpUvst99+8Z3vfKdJZ3XuvffeyOVyBV+L/OUvfxm5XC4++9nPFrQ98MAD4/Of/3zBtDvuuCNGjhwZXbp0iZ49e8bpp58eL730UkGbxq5h+tvf/hZnnXVWlJeXR/fu3WPSpEnx5JNPRi6Xi9tvv71Bna+88kqcfPLJsffee0evXr3iG9/4RtTW1kZExPLly6NXr14REXHVVVfl9+OVV14ZERHV1dVxzjnnxH777RdlZWXRt2/fmDBhQqtf2wWwqznDBPABcN9998WQIUNi1KhRTV5myZIl8dGPfjT69+8f//iP/xhdu3aNX/ziF3HyySfHL3/5y/jMZz5T0P7CCy+MHj16xLRp02L58uVx/fXXxwUXXBA///nP821++tOfxqRJk2LcuHHxve99LzZt2hQ33XRTHHXUUfHEE08U/IN+27ZtMW7cuDjqqKNi5syZsddee0VExN133x2bNm2K888/P/bZZ5949NFH44YbboiXX3457r777qL2y09/+tMG0y6//PJ49dVX8zc5aOp+qK6ujo997GOxbdu2fLt//dd/jS5duuywjqOOOipyuVz87ne/i0MOOSQi3gmGJSUl8Yc//CHf7rXXXovnnnsuLrjggvy0f/7nf44rrrgiTjvttDj33HPjtddeixtuuCGOOeaYeOKJJ6J79+6NrrOuri4+9alPxaOPPhrnn39+HHDAAfGrX/0qJk2a1Gj72traGDduXIwaNSpmzpwZ8+bNi+9///sxePDgOP/886NXr15x0003xfnnnx+f+cxn8kHv3e055ZRTYsmSJXHhhRfGwIED49VXX425c+fGypUrm30zCoAPhAyANm39+vVZRGQnn3xyg3lr167NXnvttfxj06ZN+XnHH398dvDBB2dvv/12flpdXV02ZsyYbOjQoflps2bNyiIiGzt2bFZXV5effvHFF2cdOnTI1q1bl2VZlr355ptZ9+7dsylTphTUUF1dnVVUVBRMnzRpUhYR2T/+4z82qLl+je+aPn16lsvlshUrVuSnTZs2LXv/n6kBAwZkkyZNarD8u6655posIrKf/OQnRe+Hr33ta1lEZI888kh+2quvvppVVFRkEZG9+OKLyfVmWZb93d/9XXbaaaflXx922GHZqaeemkVE9uyzz2ZZlmWzZ8/OIiJ78sknsyzLsuXLl2cdOnTI/vmf/7mgr8WLF2elpaUF0ydNmpQNGDAg//qXv/xlFhHZ9ddfn59WW1ubffzjH88iIps1a1bBshGRXX311QXrGTFiRDZy5Mj869deey2LiGzatGkF7dauXZtFRHbttddudx8A7Il8JQ+gjaupqYmIaPS20Mcdd1z06tUr/7jxxhsjIuKNN96IBx98ME477bR488034/XXX4/XX389/va3v8W4cePi+eefj1deeaWgr/POO6/gNt5HH3101NbWxooVKyIiYu7cubFu3bo444wz8v29/vrr0aFDhxg1alQ89NBDDeo7//zzG0yrf8Zm48aN8frrr8eYMWMiy7J44oknmrGH3vHQQw/FZZddFhdeeGGcddZZRe+HX//613HkkUfGEUccke+zV69e+a8S7sjRRx8dv//97yMi4s0334wnn3wyzjvvvNh3333z03//+99H9+7d4yMf+UhERMyePTvq6uritNNOK9inlZWVMXTo0Eb36bvuv//+6NixY0yZMiU/raSkJKZOnZpc5stf/nKDmv/617/ucNu6dOkSnTp1iocffjjWrl27w/YAe5J2GZh+97vfxac+9ano169f5HK5mDNnTtF9ZFkWM2fOjA9/+MNRVlYW/fv3j3/+539u+WKBdq9bt24REbFhw4YG826++eaYO3du3HHHHQXTly1bFlmWxRVXXFEQqHr16hXTpk2LiIhXX321YJn999+/4HWPHj0iIvL/QH7++ecjIuLjH/94gz5/+9vfNuivtLQ09ttvvwY1r1y5Ms4+++zo2bNn/lqaY489NiIi1q9f37Sd8j4vv/xyfP7zn4+PfvSj8YMf/KBZ+2HFihUxdOjQBn0PGzasSTUcffTRsXr16li2bFksWLAgcrlcjB49uiBI/f73v4+PfvSj+ZtzPP/885FlWQwdOrRBfc8++2yDfVrfihUrom/fvvmvOr5ryJAhjbbv3Llz/hqld/Xo0aNJAaisrCy+973vxW9+85vo06dPHHPMMXHNNddEdXX1DpcF+KBrl9cwbdy4MQ499NCYPHlyg4txm+qrX/1q/Pa3v42ZM2fGwQcfHG+88Ua88cYbLVwpQERFRUX07ds3nn766Qbz3r2m6f0X3r97o4JvfOMbMW7cuEb7ff8/rDt06NBouyzLCvr86U9/GpWVlQ3alZYW/kkpKytrcNe+2traOOGEE+KNN96ISy+9NA444IDo2rVrvPLKK3H22Wc367bZW7Zsic997nNRVlYWv/jFLwrqaM5+aK6jjjoqIt75T7m//vWvcdhhh0XXrl3j6KOPjh/+8IexYcOGeOKJJwr+c62uri5yuVz85je/aXT/t+SPzabGt6m+9rWvxac+9amYM2dOPPDAA3HFFVfE9OnT48EHH4wRI0a0UJUAbU+7DEwnnXRSnHTSScn5mzdvjn/6p3+K//iP/4h169bFRz7ykfje976X/02KZ599Nm666aZ4+umn8//zOGjQoN1ROtBOjR8/Pv7t3/4tHn300YKvjKV86EMfioh3bkU9duzYFqlh8ODBERHRu3fvZve5ePHi+N///d/493//95g4cWJ++ty5c5td10UXXRSLFi2K3/3ud9GnT5+CecXshwEDBuTPotW3dOnSJtWx//77x/777x+///3v469//WscffTRERFxzDHHxCWXXBJ333131NbWxjHHHJNfZvDgwZFlWQwaNCg+/OEPN2k99et96KGHYtOmTQVnmZYtW1ZUP/XV/0pmYwYPHhxf//rX4+tf/3o8//zzMXz48Pj+97/f4AwnwJ6kXX4lb0cuuOCCWLhwYdx1113x1FNPxamnnhonnnhi/g/pf/3Xf8WHPvShuO+++2LQoEExcODAOPfcc51hAnaZb37zm7HXXnvF5MmTY82aNQ3mv3sW6F29e/eO4447Lm6++eZYvXp1g/aN3S58R8aNGxfl5eXx3e9+N7Zu3dqsPt89y1G/3izL4v/+3/9bdD0REbNmzYqbb745brzxxkaDZDH74ZOf/GT86U9/ikcffbRg/s9+9rMm13P00UfHgw8+GI8++mg+MA0fPjy6desWM2bMiC5dusTIkSPz7T/72c9Ghw4d4qqrrmowhlmWxd/+9rfkusaNGxdbt26NW265JT+trq4ufx1bc7wbvNatW1cwfdOmTfH2228XTBs8eHB069YtNm/e3Oz1AXwQtMszTNuzcuXKmDVrVqxcuTL69esXEe98leP++++PWbNmxXe/+93461//GitWrIi77747fvKTn0RtbW1cfPHF8bnPfS4efPDBVt4CYE80dOjQuPPOO+OMM86IYcOGxZlnnhmHHnpoZFkWL774Ytx5551RUlJScM3QjTfeGEcddVQcfPDBMWXKlPjQhz4Ua9asiYULF8bLL78cTz75ZFE1lJeXx0033RRnnXVWHHbYYXH66adHr169YuXKlfHf//3f8dGPfjT+5V/+Zbt9HHDAATF48OD4xje+Ea+88kqUl5fHL3/5y2bdSOD111+Pr3zlK3HQQQdFWVlZg7Mcn/nMZ6Jr165N3g/f/OY346c//WmceOKJ8dWvfjV/W/EBAwYU/L7S9hx99NHxs5/9LHK5XP4reh06dIgxY8bEAw88EMcdd1x06tQp337w4MHxne98Jy677LJYvnx5nHzyydGtW7d48cUX45577onzzjsvvvGNbzS6rpNPPjmOOOKI+PrXvx7Lli2LAw44IO699978f97t6GxRY7p06RIHHXRQ/PznP48Pf/jD0bNnz/jIRz4S27Zti+OPPz5OO+20OOigg6K0tDTuueeeWLNmTZx++ulFrwfgA6VV7s3XhkREds899+Rf33fffVlEZF27di14lJaW5m8XO2XKlCwisqVLl+aXe/zxx7OIyJ577rndvQlAO7Js2bLs/PPPz4YMGZJ17tw569KlS3bAAQdkX/7yl7NFixY1aP/CCy9kEydOzCorK7OOHTtm/fv3z/7P//k/2X/+53/m27x7W/HHHnusYNmHHnooi4jsoYceajB93LhxWUVFRda5c+ds8ODB2dlnn539+c9/zreZNGlS1rVr10a34ZlnnsnGjh2b7b333tm+++6bTZkyJXvyyScb3Ap7R7cVf/HFF7OISD7q3wa8Kfshy7Lsqaeeyo499tisc+fOWf/+/bNvf/vb2a233tqk24pnWZYtWbIki4jswAMPLJj+ne98J4uI7Iorrmh0uV/+8pfZUUcdlf+bc8ABB2RTp04t+Dvz/tuKZ9k7twH/whe+kHXr1i2rqKjIzj777OyPf/xjFhHZXXfdVbBsY+PR2D5esGBBNnLkyKxTp075W4y//vrr2dSpU7MDDjgg69q1a1ZRUZGNGjUq+8UvfrHDfQLwQZfLsvd9B6CdyeVycc8998TJJ58cERE///nP48wzz4wlS5Y0uEB27733jsrKypg2bVqDr6S89dZbsddee8Vvf/vbOOGEE3bnJgBA3pw5c+Izn/lM/OEPf4iPfvSjrV0OwAeer+S9z4gRI6K2tjZeffXV/PfP3++jH/1obNu2LV544YX8RdD/+7//GxHvXIQLALvDW2+9VfC7VrW1tXHDDTdEeXl5HHbYYa1YGcCeo10Gpg0bNhTcRejFF1+MRYsWRc+ePePDH/5wnHnmmTFx4sT4/ve/HyNGjIjXXnst5s+fH4ccckiMHz8+xo4dG4cddlhMnjw5rr/++qirq4upU6fGCSecUPRdjgCguS688MJ46623YvTo0bF58+aYPXt2LFiwIL773e8WBCkAmq9dfiXv4Ycfjo997GMNpk+aNCluv/322Lp1a3znO9+Jn/zkJ/HKK6/EvvvuG0ceeWRcddVVcfDBB0dExKpVq+LCCy+M3/72t9G1a9c46aST4vvf/3707Nlzd28OAO3UnXfeGd///vdj2bJl8fbbb8eQIUPi/PPPjwsuuKC1SwPYY7TLwAQAANAUfocJAAAgQWACAABIaDc3fairq4tVq1ZFt27dmvVjfgAAwJ4hy7J48803o1+/flFSsv1zSO0mMK1atSqqqqpauwwAAKCNeOmll2K//fbbbpt2E5i6desWEe/slPLy8lauBgAAaC01NTVRVVWVzwjb024C07tfwysvLxeYAACAJl2q46YPAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAklLZ2AbznhJJTW7sE/p8HVi1q7RK2a1y/4a1dwnbNrbu7tUsAAGgRzjABAAAkFBWYBg4cGLlcrsFj6tSpjba//fbbG7Tt3Llzfv7WrVvj0ksvjYMPPji6du0a/fr1i4kTJ8aqVat2uN4ZM2Y0Y3MBAACarqiv5D322GNRW1ubf/3000/HCSecEKeemv4qWXl5eSxdujT/OpfL5Z9v2rQp/vKXv8QVV1wRhx56aKxduza++tWvxqc//en485//XNDP1VdfHVOmTMm/7tatWzGlAwAAFK2owNSrV6+C1zNmzIjBgwfHsccem1wml8tFZWVlo/MqKipi7ty5BdP+5V/+JY444ohYuXJl7L///vnp3bp1S/YDAACwKzT7GqYtW7bEHXfcEZMnTy44a/R+GzZsiAEDBkRVVVVMmDAhlixZst1+169fH7lcLrp3714wfcaMGbHPPvvEiBEj4tprr41t27Ztt5/NmzdHTU1NwQMAAKAYzb5L3pw5c2LdunVx9tlnJ9sMGzYsbrvttjjkkENi/fr1MXPmzBgzZkwsWbIk9ttvvwbt33777bj00kvjjDPOiPLy8vz0iy66KA477LDo2bNnLFiwIC677LJYvXp1/OAHP0iue/r06XHVVVc1d/MAAAAil2VZ1pwFx40bF506dYr/+q//avIyW7dujQMPPDDOOOOM+Pa3v91g3imnnBIvv/xyPPzwwwWB6f1uu+22+NKXvhQbNmyIsrKyRtts3rw5Nm/enH9dU1MTVVVVsX79+u323ZrcVrztcFvxneO24gBAW1ZTUxMVFRVNygbNOsO0YsWKmDdvXsyePbuo5Tp27BgjRoyIZcuWFUzfunVrnHbaabFixYp48MEHd1j0qFGjYtu2bbF8+fIYNmxYo23KysqSYQoAAKApmnUN06xZs6J3794xfvz4oparra2NxYsXR9++ffPT3g1Lzz//fMybNy/22WefHfazaNGiKCkpid69exddOwAAQFMVfYaprq4uZs2aFZMmTYrS0sLFJ06cGP3794/p06dHxDu3Aj/yyCNjyJAhsW7durj22mtjxYoVce6550bEO2Hpc5/7XPzlL3+J++67L2pra6O6ujoiInr27BmdOnWKhQsXxiOPPBIf+9jHolu3brFw4cK4+OKL4+///u+jR48eO7v9AAAASUUHpnnz5sXKlStj8uTJDeatXLkySkreO2m1du3amDJlSlRXV0ePHj1i5MiRsWDBgjjooIMiIuKVV16Je++9NyIihg8fXtDXQw89FMcdd1yUlZXFXXfdFVdeeWVs3rw5Bg0aFBdffHFccsklxZYOAABQlGbf9OGDppgLu1qLmz60HW76sHPc9AEAaMuKyQbN/h0mAACAPZ3ABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAk+B2mNqSuemiL9teWf6unrf/OUXvTlo8V9mx+swuA1uB3mAAAAFqAwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJOSyLMtau4jdoaamJioqKmL9+vVRXl7e2uU06oSSU1u7hA+sB1Ytau0SqGdcv+GtXQK0OXPr7m7tEgD4f4rJBs4wAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAEBCLsuyrLWL2B1qamqioqIi1q9fH+Xl5a1dTqPqqoe2dgnQ5ozrN7y1SwCaYW7d3a1dAkBSMdnAGSYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIKG0tQvgPeP6DW/R/h5YtahF+4PW0NaP45Z+38Ke4oSSU1u7hN1qbt3drV0CsIs4wwQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACaWtXQDAB9kDqxa1aH/j+g1v0f6A3eOEklNbu4TdZm7d3a1dAuxWzjABAAAkFBWYBg4cGLlcrsFj6tSpjba//fbbG7Tt3Llzfv7WrVvj0ksvjYMPPji6du0a/fr1i4kTJ8aqVasK+nnjjTfizDPPjPLy8ujevXt88YtfjA0bNjRjcwEAAJquqK/kPfbYY1FbW5t//fTTT8cJJ5wQp56aPg1dXl4eS5cuzb/O5XL555s2bYq//OUvccUVV8Shhx4aa9euja9+9avx6U9/Ov785z/n25155pmxevXqmDt3bmzdujXOOeecOO+88+LOO+8spnwAAICiFBWYevXqVfB6xowZMXjw4Dj22GOTy+RyuaisrGx0XkVFRcydO7dg2r/8y7/EEUccEStXroz9998/nn322bj//vvjsccei8MPPzwiIm644Yb45Cc/GTNnzox+/foVswkAAABN1uxrmLZs2RJ33HFHTJ48ueCs0ftt2LAhBgwYEFVVVTFhwoRYsmTJdvtdv3595HK56N69e0RELFy4MLp3754PSxERY8eOjZKSknjkkUeS/WzevDlqamoKHgAAAMVodmCaM2dOrFu3Ls4+++xkm2HDhsVtt90Wv/rVr+KOO+6Iurq6GDNmTLz88suNtn/77bfj0ksvjTPOOCPKy8sjIqK6ujp69+5d0K60tDR69uwZ1dXVyXVPnz49Kioq8o+qqqriNxIAAGjXmh2Ybr311jjppJO2+5W40aNHx8SJE2P48OFx7LHHxuzZs6NXr15x8803N2i7devWOO200yLLsrjpppuaW1beZZddFuvXr88/XnrppZ3uEwAAaF+a9TtMK1asiHnz5sXs2bOLWq5jx44xYsSIWLZsWcH0d8PSihUr4sEHH8yfXYqIqKysjFdffbWg/bZt2+KNN95IXhsVEVFWVhZlZWVF1QcAAFBfs84wzZo1K3r37h3jx48varna2tpYvHhx9O3bNz/t3bD0/PPPx7x582KfffYpWGb06NGxbt26ePzxx/PTHnzwwairq4tRo0Y1p3wAAIAmKfoMU11dXcyaNSsmTZoUpaWFi0+cODH69+8f06dPj4iIq6++Oo488sgYMmRIrFu3Lq699tpYsWJFnHvuuRHxTlj63Oc+F3/5y1/ivvvui9ra2vx1ST179oxOnTrFgQceGCeeeGJMmTIlfvzjH8fWrVvjggsuiNNPP90d8gAAgF2q6MA0b968WLlyZUyePLnBvJUrV0ZJyXsnrdauXRtTpkyJ6urq6NGjR4wcOTIWLFgQBx10UEREvPLKK3HvvfdGRMTw4cML+nrooYfiuOOOi4iIn/3sZ3HBBRfE8ccfHyUlJXHKKafED3/4w2JLBwAAKEouy7KstYvYHWpqaqKioiLWr19fcI1UW3JCSfoHgJvjgVWLWrQ/YNcb1294a5cAsF1z6+5u7RJgpxWTDZp9lzwAAIA9ncAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACT4HaY2pK56aIv215K/5+I3nWgtLf27RO3tWPa7TgBti9+xahv8DhMAAEALEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgITS1i6A94zrN7y1S9htWnpbH1i1qEX7a+va+rHS3sYDAJrqhJJTW7uE3WZu3d2tXUKLcIYJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABJyWZZlrV3E7lBTUxMVFRWxfv36KC8vb+1yGlVXPbRF+xvXb3iL9teSHli1qEX7a+ltbev1tSctPRbsHMcyAK1lbt3dLdZXMdnAGSYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASCht7QLYdR5Ytai1S0ga1294a5fwgdbSY9vS49GWjz0AgGI4wwQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACaWtXQDvGddveIv298CqRS3aX3tiLHZOS+6/9rbvAIC2xRkmAACAhKIC08CBAyOXyzV4TJ06tdH2t99+e4O2nTt3Lmgze/bs+MQnPhH77LNP5HK5WLRoUYN+jjvuuAb9fPnLXy6mdAAAgKIV9ZW8xx57LGpra/Ovn3766TjhhBPi1FNPTS5TXl4eS5cuzb/O5XIF8zdu3BhHHXVUnHbaaTFlypRkP1OmTImrr746/3qvvfYqpnQAAICiFRWYevXqVfB6xowZMXjw4Dj22GOTy+RyuaisrEzOP+ussyIiYvny5dtd91577bXdfgAAAFpas69h2rJlS9xxxx0xefLkBmeN6tuwYUMMGDAgqqqqYsKECbFkyZJmre9nP/tZ7LvvvvGRj3wkLrvssti0adN222/evDlqamoKHgAAAMVo9l3y5syZE+vWrYuzzz472WbYsGFx2223xSGHHBLr16+PmTNnxpgxY2LJkiWx3377NXldX/jCF2LAgAHRr1+/eOqpp+LSSy+NpUuXxuzZs5PLTJ8+Pa666qpiNgkAAKBAswPTrbfeGieddFL069cv2Wb06NExevTo/OsxY8bEgQceGDfffHN8+9vfbvK6zjvvvPzzgw8+OPr27RvHH398vPDCCzF48OBGl7nsssvikksuyb+uqamJqqqqJq8TAACgWYFpxYoVMW/evO2e4WlMx44dY8SIEbFs2bLmrDZv1KhRERGxbNmyZGAqKyuLsrKynVoPAADQvjXrGqZZs2ZF7969Y/z48UUtV1tbG4sXL46+ffs2Z7V57956fGf7AQAA2J6izzDV1dXFrFmzYtKkSVFaWrj4xIkTo3///jF9+vSIiLj66qvjyCOPjCFDhsS6devi2muvjRUrVsS5556bX+aNN96IlStXxqpVqyIi8rcgr6ysjMrKynjhhRfizjvvjE9+8pOxzz77xFNPPRUXX3xxHHPMMXHIIYc0e8MBAAB2pOjANG/evFi5cmVMnjy5wbyVK1dGScl7J63Wrl0bU6ZMierq6ujRo0eMHDkyFixYEAcddFC+zb333hvnnHNO/vXpp58eERHTpk2LK6+8Mjp16hTz5s2L66+/PjZu3BhVVVVxyimnxOWXX15s6QAAAEXJZVmWtXYRu0NNTU1UVFTE+vXro7y8vLXLadQJJekfAG6OB1YtatH+WtK4fsNbu4Tdqi2PRUTbHo+2vu/am7Z8rACwZ5tbd3eL9VVMNmj27zABAADs6QQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACCh6B+uZddpy78347dXdo79x56iLX9ORbTse62lt9XnAMAHkzNMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJBQ2toF8J5x/Ya3dgnsIg+sWtTaJWxXSx97Lbm9bbk22p62fOwB8MHkDBMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkFDa2gXQPj2walFrl7Bbjes3vLVL2K62PB5tuTb2bC197LX1z4G2rq1/Fhhf2HM5wwQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACaWtXQDveWDVotYuYbcZ1294i/bXnvZdRNvf3pYc37a+rcDu0dJ/NwCayhkmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgobe0CeM+4fsNbtL8HVi1qsb7acm0fBO1te9uylj6WW5pjZee05Pi29bFo6fra+nuD5nOswM5xhgkAACChqMA0cODAyOVyDR5Tp05ttP3tt9/eoG3nzp0L2syePTs+8YlPxD777BO5XC4WLVrUoJ+33347pk6dGvvss0/svffeccopp8SaNWuKKR0AAKBoRQWmxx57LFavXp1/zJ07NyIiTj311OQy5eXlBcusWLGiYP7GjRvjqKOOiu9973vJPi6++OL4r//6r7j77rvjf/7nf2LVqlXx2c9+tpjSAQAAilbUNUy9evUqeD1jxowYPHhwHHvsscllcrlcVFZWJuefddZZERGxfPnyRuevX78+br311rjzzjvj4x//eEREzJo1Kw488MD405/+FEceeWQxmwAAANBkzb6GacuWLXHHHXfE5MmTI5fLJdtt2LAhBgwYEFVVVTFhwoRYsmRJUet5/PHHY+vWrTF27Nj8tAMOOCD233//WLhwYXK5zZs3R01NTcEDAACgGM0OTHPmzIl169bF2WefnWwzbNiwuO222+JXv/pV3HHHHVFXVxdjxoyJl19+ucnrqa6ujk6dOkX37t0Lpvfp0yeqq6uTy02fPj0qKiryj6qqqiavEwAAIGInAtOtt94aJ510UvTr1y/ZZvTo0TFx4sQYPnx4HHvssTF79uzo1atX3Hzzzc1dbZNddtllsX79+vzjpZde2uXrBAAA9izN+h2mFStWxLx582L27NlFLdexY8cYMWJELFu2rMnLVFZWxpYtW2LdunUFZ5nWrFmz3WujysrKoqysrKj6AAAA6mvWGaZZs2ZF7969Y/z48UUtV1tbG4sXL46+ffs2eZmRI0dGx44dY/78+flpS5cujZUrV8bo0aOLWj8AAEAxij7DVFdXF7NmzYpJkyZFaWnh4hMnToz+/fvH9OnTIyLi6quvjiOPPDKGDBkS69ati2uvvTZWrFgR5557bn6ZN954I1auXBmrVq2KiHfCUMQ7Z5YqKyujoqIivvjFL8Yll1wSPXv2jPLy8rjwwgtj9OjR7pAHAADsUkUHpnnz5sXKlStj8uTJDeatXLkySkreO2m1du3amDJlSlRXV0ePHj1i5MiRsWDBgjjooIPybe69994455xz8q9PP/30iIiYNm1aXHnllRERcd1110VJSUmccsopsXnz5hg3blz86Ec/KrZ0AACAohQdmD7xiU9ElmWNznv44YcLXl933XVx3XXXbbe/s88+e7t32ouI6Ny5c9x4441x4403FlMqAADATmn2XfIAAAD2dAITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJBQ9O8wses8sGpRi/Y3rt/wFu0PWoPjeM/Wlse3LdcW0fbro+1wrMDOcYYJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABJKW7sA3jOu3/AW7e+BVYtatL/2xFjsnJbc3pYei7auvW0vtJaW/lz23oU9lzNMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJBQ2toF8J4HVi1q0f7G9RveYn21dG1tXXvb3pbWksceQETb/1xuy/X5TIad4wwTAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACSUtnYB7DoPrFrU2iWwi4zrN7y1S4A9Xnv7DG3rnystXV97Gt+W3ta2fqxAS3OGCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASSlu7AGgPxvUb3tolAOxWD6xa1NolsIu09Nj6G0lbV9QZpoEDB0Yul2vwmDp1aqPtb7/99gZtO3fuXNAmy7L41re+FX379o0uXbrE2LFj4/nnn9/hemfMmFHkpgIAABSnqDNMjz32WNTW1uZfP/3003HCCSfEqaeemlymvLw8li5dmn+dy+UK5l9zzTXxwx/+MP793/89Bg0aFFdccUWMGzcunnnmmYJwdfXVV8eUKVPyr7t161ZM6QAAAEUrKjD16tWr4PWMGTNi8ODBceyxxyaXyeVyUVlZ2ei8LMvi+uuvj8svvzwmTJgQERE/+clPok+fPjFnzpw4/fTT8227deuW7AcAAGBXaPZNH7Zs2RJ33HFHTJ48ucFZo/o2bNgQAwYMiKqqqpgwYUIsWbIkP+/FF1+M6urqGDt2bH5aRUVFjBo1KhYuXFjQz4wZM2KfffaJESNGxLXXXhvbtm3bbn2bN2+OmpqaggcAAEAxmn3Thzlz5sS6devi7LPPTrYZNmxY3HbbbXHIIYfE+vXrY+bMmTFmzJhYsmRJ7LffflFdXR0REX369ClYrk+fPvl5EREXXXRRHHbYYdGzZ89YsGBBXHbZZbF69er4wQ9+kFz39OnT46qrrmru5gEAADQ/MN16661x0kknRb9+/ZJtRo8eHaNHj86/HjNmTBx44IFx8803x7e//e0mr+uSSy7JPz/kkEOiU6dO8aUvfSmmT58eZWVljS5z2WWXFSxXU1MTVVVVTV4nAABAs76St2LFipg3b16ce+65RS3XsWPHGDFiRCxbtiwiIn9N0po1awrarVmzZrvXK40aNSq2bdsWy5cvT7YpKyuL8vLyggcAAEAxmhWYZs2aFb17947x48cXtVxtbW0sXrw4+vbtGxERgwYNisrKypg/f36+TU1NTTzyyCMFZ6beb9GiRVFSUhK9e/duTvkAAABNUvRX8urq6mLWrFkxadKkKC0tXHzixInRv3//mD59ekS8cyvwI488MoYMGRLr1q2La6+9NlasWJE/M5XL5eJrX/tafOc734mhQ4fmbyver1+/OPnkkyMiYuHChfHII4/Exz72sejWrVssXLgwLr744vj7v//76NGjx05uPgAAQFrRgWnevHmxcuXKmDx5coN5K1eujJKS905arV27NqZMmRLV1dXRo0ePGDlyZCxYsCAOOuigfJtvfvObsXHjxjjvvPNi3bp1cdRRR8X999+f/w2msrKyuOuuu+LKK6+MzZs3x6BBg+Liiy8uuD4JAABgV8hlWZa1dhG7Q01NTVRUVMT69evb7PVMddVDW7sEdpFx/Ya3dglAkR5Ytai1S9itWvpzqr3tP5rP30iaam7d3S3WVzHZoNm/wwQAALCnE5gAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIKG0tQvgPSWVz7d2CUl+VHfntPUfcPSjgewp2vp7rS2z7wAa5wwTAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJBQ2toF8MFQUvl8a5ewW9VVD23tEqBdeGDVotYuAQC2yxkmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgobe0CoC0qqXy+tUvYzU5t7QKSHli1qLVL2K5x/Ya3dgkfaC29/9r68QJ7Ap97tDfOMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAQmlrFwC0vrl1d7d2CbtNXfXQ1i4BaIZx/Ya3aH8PrFrUov21ZS2976C9cYYJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABJKW7sAgN2ppPL5Fu1vbl2LdtfmnVByamuXQDv1wKpFLdpfS38WtGXt7XMKWpozTAAAAAlFBaaBAwdGLpdr8Jg6dWqj7W+//fYGbTt37lzQJsuy+Na3vhV9+/aNLl26xNixY+P55wv/1+eNN96IM888M8rLy6N79+7xxS9+MTZs2FDkpgIAABSnqMD02GOPxerVq/OPuXPnRkTEqaemv6JRXl5esMyKFSsK5l9zzTXxwx/+MH784x/HI488El27do1x48bF22+/nW9z5plnxpIlS2Lu3Llx3333xe9+97s477zziikdAACgaEVdw9SrV6+C1zNmzIjBgwfHsccem1wml8tFZWVlo/OyLIvrr78+Lr/88pgwYUJERPzkJz+JPn36xJw5c+L000+PZ599Nu6///547LHH4vDDD4+IiBtuuCE++clPxsyZM6Nfv37FbAIAAECTNfsapi1btsQdd9wRkydPjlwul2y3YcOGGDBgQFRVVcWECRNiyZIl+XkvvvhiVFdXx9ixY/PTKioqYtSoUbFw4cKIiFi4cGF07949H5YiIsaOHRslJSXxyCOPJNe7efPmqKmpKXgAAAAUo9mBac6cObFu3bo4++yzk22GDRsWt912W/zqV7+KO+64I+rq6mLMmDHx8ssvR0REdXV1RET06dOnYLk+ffrk51VXV0fv3r0L5peWlkbPnj3zbRozffr0qKioyD+qqqqas5kAAEA71uzAdOutt8ZJJ5203a/EjR49OiZOnBjDhw+PY489NmbPnh29evWKm2++ubmrbbLLLrss1q9fn3+89NJLu3ydAADAnqVZv8O0YsWKmDdvXsyePbuo5Tp27BgjRoyIZcuWRUTkr21as2ZN9O3bN99uzZo1MXz48HybV199taCfbdu2xRtvvJG8NioioqysLMrKyoqqDwAAoL5mnWGaNWtW9O7dO8aPH1/UcrW1tbF48eJ8OBo0aFBUVlbG/Pnz821qamrikUceidGjR0fEO2ep1q1bF48//ni+zYMPPhh1dXUxatSo5pQPAADQJEWfYaqrq4tZs2bFpEmTorS0cPGJEydG//79Y/r06RERcfXVV8eRRx4ZQ4YMiXXr1sW1114bK1asiHPPPTci3rmD3te+9rX4zne+E0OHDo1BgwbFFVdcEf369YuTTz45IiIOPPDAOPHEE2PKlCnx4x//OLZu3RoXXHBBnH766e6QBwAA7FJFB6Z58+bFypUrY/LkyQ3mrVy5MkpK3jtptXbt2pgyZUpUV1dHjx49YuTIkbFgwYI46KCD8m2++c1vxsaNG+O8886LdevWxVFHHRX3339/wQ/c/uxnP4sLLrggjj/++CgpKYlTTjklfvjDHxZbOgAAQFFyWZZlrV3E7lBTUxMVFRWxfv36KC8vb+1yAD6QTihJ/1B5W/DAqkWtXQIfECWVz7d2CUArKiYbNPsueQAAAHs6gQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASCj6h2sBaL/m1t3d2iUAwG7lDBMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkFDa2gXsLlmWRURETU1NK1cCAAC0pnczwbsZYXvaTWB68803IyKiqqqqlSsBAADagjfffDMqKiq22yaXNSVW7QHq6upi1apV0a1bt8jlcq1dTrtVU1MTVVVV8dJLL0V5eXlrl9OuGYu2xXi0Hcai7TAWbYvxaDuMxc7LsizefPPN6NevX5SUbP8qpXZzhqmkpCT222+/1i6D/6e8vNwbvI0wFm2L8Wg7jEXbYSzaFuPRdhiLnbOjM0vvctMHAACABIEJAAAgQWBityorK4tp06ZFWVlZa5fS7hmLtsV4tB3Gou0wFm2L8Wg7jMXu1W5u+gAAAFAsZ5gAAAASBCYAAIAEgQkAACBBYAIAAEgQmEiaMWNG5HK5+NrXvpaf9q//+q9x3HHHRXl5eeRyuVi3bl2D5d54440488wzo7y8PLp37x5f/OIXY8OGDQVtnnrqqTj66KOjc+fOUVVVFddcc02Dfu6+++444IADonPnznHwwQfHr3/964L5WZbFt771rejbt2906dIlxo4dG88//3yLbHtb1NzxGDhwYORyuYLHjBkzCtoYj+K8fyzeeOONuPDCC2PYsGHRpUuX2H///eOiiy6K9evXFyy3cuXKGD9+fOy1117Ru3fv+Id/+IfYtm1bQZuHH344DjvssCgrK4shQ4bE7bff3mD9N954YwwcODA6d+4co0aNikcffbRg/ttvvx1Tp06NffbZJ/bee+845ZRTYs2aNS26D9qS5o7H+98XuVwu7rrrroI2xqM4jX1OfelLX4rBgwdHly5dolevXjFhwoR47rnnCpbz3mh5zR0L74tdo7HxeFeWZXHSSSdFLpeLOXPmFMzz3mgjMmjEo48+mg0cODA75JBDsq9+9av56dddd102ffr0bPr06VlEZGvXrm2w7Iknnpgdeuih2Z/+9Kfs97//fTZkyJDsjDPOyM9fv3591qdPn+zMM8/Mnn766ew//uM/si5dumQ333xzvs0f//jHrEOHDtk111yTPfPMM9nll1+edezYMVu8eHG+zYwZM7KKiopszpw52ZNPPpl9+tOfzgYNGpS99dZbu2SftKadGY8BAwZkV199dbZ69er8Y8OGDfn5xqM4jY3F4sWLs89+9rPZvffemy1btiybP39+NnTo0OyUU07JL7dt27bsIx/5SDZ27NjsiSeeyH79619n++67b3bZZZfl2/z1r3/N9tprr+ySSy7JnnnmmeyGG27IOnTokN1///35NnfddVfWqVOn7LbbbsuWLFmSTZkyJevevXu2Zs2afJsvf/nLWVVVVTZ//vzsz3/+c3bkkUdmY8aM2fU7pxU0dzyyLMsiIps1a1bBe6P+8Wo8ipP6nLr55puz//mf/8lefPHF7PHHH88+9alPZVVVVdm2bduyLPPe2BWaOxZZ5n2xK6TG410/+MEPspNOOimLiOyee+7JT/feaDsEJhp48803s6FDh2Zz587Njj322Ebf3A899FCj/0B/5plnsojIHnvssfy03/zmN1kul8teeeWVLMuy7Ec/+lHWo0ePbPPmzfk2l156aTZs2LD869NOOy0bP358Qd+jRo3KvvSlL2VZlmV1dXVZZWVldu211+bnr1u3LisrK8v+4z/+o9nb3hbtzHhk2TuB6brrrkv2bzyarilj8a5f/OIXWadOnbKtW7dmWZZlv/71r7OSkpKsuro63+amm27KysvL8/v+m9/8ZvZ3f/d3Bf18/vOfz8aNG5d/fcQRR2RTp07Nv66trc369euXTZ8+Pcuyd/Z7x44ds7vvvjvf5tlnn80iIlu4cGHzN74N2pnxyLKswT9O3s94NF0xY/Hkk09mEZEtW7YsyzLvjZa2M2ORZd4XLW1H4/HEE09k/fv3z1avXt1g33tvtB2+kkcDU6dOjfHjx8fYsWOLXnbhwoXRvXv3OPzww/PTxo4dGyUlJfHII4/k2xxzzDHRqVOnfJtx48bF0qVLY+3atfk271//uHHjYuHChRER8eKLL0Z1dXVBm4qKihg1alS+zZ5iZ8bjXTNmzIh99tknRowYEddee23B6Xzj0XTFjMX69eujvLw8SktLI+KdfXjwwQdHnz598m3GjRsXNTU1sWTJknyb7e3nLVu2xOOPP17QpqSkJMaOHZtv8/jjj8fWrVsL2hxwwAGx//7771FjEbFz41G/j3333TeOOOKIuO222yKr99OExqPpmjoWGzdujFmzZsWgQYOiqqoqIrw3WtrOjEX9PrwvWsb2xmPTpk3xhS98IW688caorKxsMN97o+0o3XET2pO77ror/vKXv8Rjjz3WrOWrq6ujd+/eBdNKS0ujZ8+eUV1dnW8zaNCggjbvfhhUV1dHjx49orq6uuAD4t029fuov1xjbfYEOzseEREXXXRRHHbYYdGzZ89YsGBBXHbZZbF69er4wQ9+EBHGo6mKGYvXX389vv3tb8d5552Xn5bah+/O216bmpqaeOutt2Lt2rVRW1vbaJt3r0Oorq6OTp06Rffu3Ru02VPGImLnxyMi4uqrr46Pf/zjsddee8Vvf/vb+MpXvhIbNmyIiy66KCKMR1M1ZSx+9KMfxTe/+c3YuHFjDBs2LObOnZv/TxrvjZazs2MR4X3RknY0HhdffHGMGTMmJkyY0Oh87422Q2Ai76WXXoqvfvWrMXfu3OjcuXNrl9PutdR4XHLJJfnnhxxySHTq1Cm+9KUvxfTp06OsrKwlSt3jFTMWNTU1MX78+DjooIPiyiuv3D0FtjMtNR5XXHFF/vmIESNi48aNce211+b/YciONXUszjzzzDjhhBNi9erVMXPmzDjttNPij3/8o781LailxsL7omXsaDzuvffeePDBB+OJJ55oheoolq/kkff444/Hq6++GocddliUlpZGaWlp/M///E/88Ic/jNLS0qitrd1hH5WVlfHqq68WTNu2bVu88cYb+dPNlZWVDe688u7rHbWpP7/+co21+aBrifFozKhRo2Lbtm2xfPnyiDAeTdHUsXjzzTfjxBNPjG7dusU999wTHTt2zPexM/u5vLw8unTpEvvuu2906NBhh2OxZcuWBndM3FPGIqJlxqMxo0aNipdffjk2b94cEcajKZo6FhUVFTF06NA45phj4j//8z/jueeei3vuuScivDdaSkuMRWO8L5pnR+Mxd+7ceOGFF6J79+75+RERp5xyShx33HER4b3RlghM5B1//PGxePHiWLRoUf5x+OGHx5lnnhmLFi2KDh067LCP0aNHx7p16+Lxxx/PT3vwwQejrq4uRo0alW/zu9/9LrZu3ZpvM3fu3Bg2bFj06NEj32b+/PkFfc+dOzdGjx4dERGDBg2KysrKgjY1NTXxyCOP5Nt80LXEeDRm0aJFUVJSkv/qpPHYsaaMRU1NTXziE5+ITp06xb333tvgfxRHjx4dixcvLvgPhblz50Z5eXkcdNBB+Tbb28+dOnWKkSNHFrSpq6uL+fPn59uMHDkyOnbsWNBm6dKlsXLlyj1iLCJaZjwas2jRoujRo0f+zKvx2LHmfE5l79xwKv8PcO+NltESY9EY74vm2dF4/NM//VM89dRTBfMjIq677rqYNWtWRHhvtCmteccJ2r7339Fl9erV2RNPPJHdcsstWURkv/vd77Innngi+9vf/pZvc+KJJ2YjRozIHnnkkewPf/hDNnTo0ILbiq9bty7r06dPdtZZZ2VPP/10dtddd2V77bVXg9tYl5aWZjNnzsyeffbZbNq0aY3exrp79+7Zr371q+ypp57KJkyYsEfexrq+YsdjwYIF2XXXXZctWrQoe+GFF7I77rgj69WrVzZx4sR8H8ajeeqPxfr167NRo0ZlBx98cLZs2bKC2/G+/9bJn/jEJ7JFixZl999/f9arV69Gbw/7D//wD9mzzz6b3XjjjY3eHrasrCy7/fbbs2eeeSY777zzsu7duxfcRenLX/5ytv/++2cPPvhg9uc//zkbPXp0Nnr06N2zY1pJseNx7733Zrfccku2ePHi7Pnnn89+9KMfZXvttVf2rW99K9+n8Wie+mPxwgsvZN/97nezP//5z9mKFSuyP/7xj9mnPvWprGfPnvlbGntv7DrFjoX3xa61o7sWRuK24t4brU9gYrve/+aeNm1aFhENHrNmzcq3+dvf/padccYZ2d57752Vl5dn55xzTvbmm28W9Pvkk09mRx11VFZWVpb1798/mzFjRoN1/+IXv8g+/OEPZ506dcr+7u/+Lvvv//7vgvl1dXXZFVdckfXp0ycrKyvLjj/++Gzp0qUtuv1tTbHj8fjjj2ejRo3KKioqss6dO2cHHnhg9t3vfjd7++23C/o1HsWrPxbv3ta9sceLL76YX2b58uXZSSedlHXp0iXbd999s69//esFt7l+t6/hw4dnnTp1yj70oQ8VvLfedcMNN2T7779/1qlTp+yII47I/vSnPxXMf+utt7KvfOUrWY8ePbK99tor+8xnPpOtXr26pXdBm1LsePzmN7/Jhg8fnu29995Z165ds0MPPTT78Y9/nNXW1hb0azyKV38sXnnlleykk07KevfunXXs2DHbb7/9si984QvZc889V7CM98auUexYeF/sWsUGpizz3mgrcllW716RAAAA5LmGCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACAhNLWLmB3evvtt2PLli2tXQYAANDKOnXqFJ07d95hu3YTmN5+++2o6NIjtsTbrV0KAADQyiorK+PFF1/cYWhqN4Fpy5YtsSXejqPik1EaHSNy730bMVeSi3ovEtPrPU9Mz5WUJNq/75uPucTy9dadWkey34I2iXUl+2zCeqO4fZEVtEnUk3jetGXfe5o1Ydub1Ca1rojIUvs0VUdJYnpB+0Qd9Vdcv01J/e1pvE2yz5ZqX5KYnto/9SXb78z0Juzb981rsToS/SeX3QX1tFSb5LLRQm2Kra1Bu6zxdjuxLwr6jIRkn1mjbZqyrmL7zBW73kj10/hW5opcb67geaK27ay78KOi8b4K/8Sk1t34sqn2JdGUGuq1b8L0gj5TbZrwvPBjvsh+ItWmLrGu1LLvtY+I6JBcR/1+67Uv2BeNr7uwz0Sb1PR6fdbfhg4F63rveYd621I4PbEtTainYF2pGur3U6+Gwu2qa3R6av+k+y98z3VIbWei1g6J47egpsTxVX96YZv36ik4bgrqrPe83tFf2Kb+9B0/L2xfkmjTcHrNm3UxYOTy2LJli8D0fqXRMUpz7wtMifCQmt6kwJNa9v3zShLL71RgSv7l2XF9TVlvmwhMxbX/QAWm1D+EPoCBqeWCUWp6E/bt++btijr22MDUlDbRhDbF1tBg+V0cmBLbs8cGpiZNb3y96ZCzs4GpuAC0U4GpKe13Y2BKh56WD0xNaR/R1MCU+kfzrg1MybDShGCUnt7ygalDQT/vHXQl9Q7A+tML90/96Y23bxiY6rdLha9ovE1BrU1ps+PA1GEXBKbC9o3vo6YFpuJv4eCmDwAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAEBCaWsXsLtti60RWUT9rJjLcvVapKbXe56YnstKGp0e2ftzab15dfWWzyWWzyWe18+7BW2i8enJPpuw3tT0rPHpWUGbRD2J501btn4J9fdn4+2zJuyfwuGr3+j9Q96EOkoS05OHUb066q+4YLjrb0/jbZJ9tlT71CGePOaa0n5npjdh375vXovVkeg/uewuqKel2iSXjRZqU2xtDdpljbfbiX1R0GckJPvMGm3TlHUV22eu2PVGqp/GtzJX5HpzBc8TtW1n3YUfFY33VfgnJrXuxpdNtc+i8RrqEu1LmjC9JJrQpgnPCz/mi+wnUm3qGp2ei9Sy9f94RnRIrqN+v/XaF+yLxtdd2GeiTWp6vT7rb0OHgnW997xDvW0pnJ7YlibUU7CuVA31+6lXQ+F21TU6PbV/0v0Xvuc6pLYzUWuHxPFbUFPi+Ko/vbDNe/UUHDcFddZ7Xu/oL2xTf/qOnxe2j0SbhrXVvFl43G9PuwlMnTp1isrKyvhD9a/fmVD/OKttlZIAAIBWUllZGZ06ddphu1yWZcn/XNvTvP3227Fly5b865qamqiqqoqXXnopysvLW7EyKOTYpK1ybNKWOT5pqxybbVOnTp2ic+fOO2zXbs4wRUR07ty50Z1SXl7u4KVNcmzSVjk2acscn7RVjs0PJjd9AAAASBCYAAAAEtp1YCorK4tp06ZFWVlZa5cCBRybtFWOTdoyxydtlWPzg61d3fQBAACgGO36DBMAAMD2CEwAAAAJAhMAAECCwAQAAJAgMAEAACTs8YHpxhtvjIEDB0bnzp1j1KhR8eijj263/d133x0HHHBAdO7cOQ4++OD49a9/vZsqpb0p5thcsmRJnHLKKTFw4MDI5XJx/fXX775CaXeKOTZvueWWOProo6NHjx7Ro0ePGDt27A4/Z2FnFHN8zp49Ow4//PDo3r17dO3aNYYPHx4//elPd2O1tCfF/pvzXXfddVfkcrk4+eSTd22BNNseHZh+/vOfxyWXXBLTpk2Lv/zlL3HooYfGuHHj4tVXX220/YIFC+KMM86IL37xi/HEE0/EySefHCeffHI8/fTTu7ly9nTFHpubNm2KD33oQzFjxoyorKzczdXSnhR7bD788MNxxhlnxEMPPRQLFy6Mqqqq+MQnPhGvvPLKbq6c9qDY47Nnz57xT//0T7Fw4cJ46qmn4pxzzolzzjknHnjggd1cOXu6Yo/Ndy1fvjy+8Y1vxNFHH72bKqVZsj3YEUcckU2dOjX/ura2NuvXr182ffr0Rtufdtpp2fjx4wumjRo1KvvSl760S+uk/Sn22KxvwIAB2XXXXbcLq6M925ljM8uybNu2bVm3bt2yf//3f99VJdKO7ezxmWVZNmLEiOzyyy/fFeXRjjXn2Ny2bVs2ZsyY7N/+7d+ySZMmZRMmTNgNldIce+wZpi1btsTjjz8eY8eOzU8rKSmJsWPHxsKFCxtdZuHChQXtIyLGjRuXbA/N0ZxjE3aHljg2N23aFFu3bo2ePXvuqjJpp3b2+MyyLObPnx9Lly6NY445ZleWSjvT3GPz6quvjt69e8cXv/jF3VEmO6G0tQvYVV5//fWora2NPn36FEzv06dPPPfcc40uU11d3Wj76urqXVYn7U9zjk3YHVri2Lz00kujX79+Df7zCXZWc4/P9evXR//+/WPz5s3RoUOH+NGPfhQnnHDCri6XdqQ5x+Yf/vCHuPXWW2PRokW7oUJ21h4bmADYvWbMmBF33XVXPPzww9G5c+fWLgciIqJbt26xaNGi2LBhQ8yfPz8uueSS+NCHPhTHHXdca5dGO/Xmm2/GWWedFbfcckvsu+++rV0OTbDHBqZ99903OnToEGvWrCmYvmbNmuRF85WVlUW1h+ZozrEJu8POHJszZ86MGTNmxLx58+KQQw7ZlWXSTjX3+CwpKYkhQ4ZERMTw4cPj2WefjenTpwtMtJhij80XXnghli9fHp/61Kfy0+rq6iIiorS0NJYuXRqDBw/etUVTlD32GqZOnTrFyJEjY/78+flpdXV1MX/+/Bg9enSjy4wePbqgfUTE3Llzk+2hOZpzbMLu0Nxj85prrolvf/vbcf/998fhhx++O0qlHWqpz866urrYvHnzriiRdqrYY/OAAw6IxYsXx6JFi/KPT3/60/Gxj30sFi1aFFVVVbuzfJqite86sSvdddddWVlZWXb77bdnzzzzTHbeeedl3bt3z6qrq7Msy7Kzzjor+8d//Md8+z/+8Y9ZaWlpNnPmzOzZZ5/Npk2blnXs2DFbvHhxa20Ce6hij83NmzdnTzzxRPbEE09kffv2zb7xjW9kTzzxRPb888+31iawhyr22JwxY0bWqVOn7D//8z+z1atX5x9vvvlma20Ce7Bij8/vfve72W9/+9vshRdeyJ555pls5syZWWlpaXbLLbe01iawhyr22Hw/d8lr2/bYr+RFRHz+85+P1157Lb71rW9FdXV1DB8+PO6///78RXkrV66MkpL3TrKNGTMm7rzzzrj88svj//v//r8YOnRozJkzJz7ykY+01iawhyr22Fy1alWMGDEi/3rmzJkxc+bMOPbYY+Phhx/e3eWzByv22Lzppptiy5Yt8bnPfa6gn2nTpsWVV165O0unHSj2+Ny4cWN85StfiZdffjm6dOkSBxxwQNxxxx3x+c9/vrU2gT1UsccmHyy5LMuy1i4CAACgLRJ1AQAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIOH/B4RlRO1Kf7aEAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -729,7 +729,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 42bf9c18a3c0ae6663a81b93b03e78276cf6243d Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Fri, 15 Sep 2023 10:45:36 +0300 Subject: [PATCH 16/31] Cases where B=0 and D=0 now handled similarly as in Arcs version --- eis_toolkit/prediction/wofe_new.py | 49 ++- notebooks/wofe_new.ipynb | 518 ++++++++++++++--------------- 2 files changed, 282 insertions(+), 285 deletions(-) diff --git a/eis_toolkit/prediction/wofe_new.py b/eis_toolkit/prediction/wofe_new.py index 6fb5001c..5476b0cf 100644 --- a/eis_toolkit/prediction/wofe_new.py +++ b/eis_toolkit/prediction/wofe_new.py @@ -10,16 +10,6 @@ # from beartype import beartype -# REPLACE signifies if we use replacement of 0 and 1 with the values below -# If REPLACE is False but laplace_smoothing is set to True, we use the SMOOTH_CONSTANT to compute p_A and p_C -REPLACE = False -SMALL_NUMBER = 0.0001 -LARGE_NUMBER = 1.0001 - -SMOOTH_CONSTANT = 1.0 - -# NODATA_THRESHOLD = 0.0000001 - def read_and_preprocess_evidence(raster: rasterio.io.DatasetReader, nodata: Optional[Number] = None) -> np.ndarray: """Read raster data and handle NoData values.""" @@ -45,26 +35,33 @@ def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray, lapl if C + D == 0: raise Exception("All included cells have deposits") - if not laplace_smoothing: - p_A = A / (A + B) # probability of presence of evidence given the presence of mineral deposit - p_C = C / (C + D) # probability of presence of evidence given the absence of mineral deposit - else: - p_A = (A + SMOOTH_CONSTANT) / (A + B + 2 * SMOOTH_CONSTANT) - p_C = (C + SMOOTH_CONSTANT) / (C + D + 2 * SMOOTH_CONSTANT) - if A == 0: return A, B, C, D, 0, 0, 0, 0, 0, 0, 0 + p_A_nominator = A + p_C_nominator = C + B_adjusted = B + D_adjusted = D + + if B == 0: + p_A_nominator -= 0.99 + B_adjusted = 0.99 + + if D == 0: + p_C_nominator -= 0.99 + D_adjusted = 0.99 + + p_A = p_A_nominator / (A + B) # probability of presence of evidence given the presence of mineral deposit + p_C = p_C_nominator / (C + D) # probability of presence of evidence given the absence of mineral deposit + # Calculate metrics - w_plus = np.log(p_A / p_C) if p_A != 0 and p_C != 0 else 0 - w_minus = np.log((1 - p_A) / (1 - p_C)) if (1 - p_A) != 0 and (1 - p_C) != 0 else 0 + w_plus = np.log(p_A / p_C) if p_C != 0 else 0 # Check + w_minus = np.log((1 - p_A) / (1 - p_C)) contrast = w_plus - w_minus # Calculate signifigance metrics - s_w_plus = np.sqrt((1 / A if A != 0 else 0) + (1 / C if C != 0 else 0)) - s_w_minus = np.sqrt((1 / B if B != 0 else 0) + (1 / D if D != 0 else 0)) - # s_w_plus = np.sqrt((1 / A) + (1 / C if C != 0 else 0)) - # s_w_minus = np.sqrt((1 / B) + (1 / D if D != 0 else 0)) + s_w_plus = np.sqrt((1 / p_A_nominator) + (1 / p_C_nominator)) + s_w_minus = np.sqrt((1 / B_adjusted) + (1 / D_adjusted)) s_contrast = np.sqrt(s_w_plus**2 + s_w_minus**2) studentized_contrast = contrast / s_contrast @@ -107,7 +104,7 @@ def reclassify_by_studentized_contrast3(df: pd.DataFrame, studentized_contrast_t index = df.idxmax()["Contrast"] if df.loc[index, "Studentized contrast"] < studentized_contrast_threshold: - raise Exception("Failed") + raise Exception("Failed, studentized contrast is {}".format(df.loc[index, "Studentized contrast"])) df["Generalized class"] = 1 for i in range(0, index + 1): @@ -288,7 +285,7 @@ def weights_of_evidence( # 3. Create dataframe based on calculated metrics df_entries = [] for cls, metrics in wofe_weights.items(): - metrics = [round(metric, 3) if isinstance(metric, np.floating) else metric for metric in metrics] + metrics = [round(metric, 4) if isinstance(metric, np.floating) else metric for metric in metrics] A, _, C, _, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast, studentized_contrast = metrics df_entries.append( { @@ -308,7 +305,7 @@ def weights_of_evidence( # 4. If we use cumulative weights type, reclassify and calculate generalized weights if weights_type != "unique": - reclassify_by_studentized_contrast3(weights_df, studentized_contrast_threshold) + reclassify_by_studentized_contrast(weights_df, studentized_contrast_threshold) # calculate_generalized_weights(weights_df) calculate_generalized_weights_alternative(weights_df, masked_deposit_array) diff --git a/notebooks/wofe_new.ipynb b/notebooks/wofe_new.ipynb index e71026b3..8d420d9d 100644 --- a/notebooks/wofe_new.ipynb +++ b/notebooks/wofe_new.ipynb @@ -77,129 +77,129 @@ " 1.0\n", " 275\n", " 9\n", - " 0.481\n", - " 0.339\n", - " -0.399\n", - " 0.381\n", - " 0.880\n", - " 0.510\n", - " 1.728\n", + " 0.4810\n", + " 0.3389\n", + " -0.3994\n", + " 0.3806\n", + " 0.8804\n", + " 0.5096\n", + " 1.7275\n", " \n", " \n", " 1\n", " 2.0\n", " 11\n", " 0\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", " \n", " \n", " 2\n", " 3.0\n", " 396\n", " 5\n", - " -0.492\n", - " 0.450\n", - " 0.341\n", - " 0.306\n", - " -0.833\n", - " 0.544\n", - " -1.531\n", + " -0.4920\n", + " 0.4501\n", + " 0.3409\n", + " 0.3059\n", + " -0.8329\n", + " 0.5442\n", + " -1.5306\n", " \n", " \n", " 3\n", " 5.0\n", " 43\n", " 1\n", - " 0.130\n", - " 1.012\n", - " -0.008\n", - " 0.261\n", - " 0.138\n", - " 1.045\n", - " 0.132\n", + " 0.1296\n", + " 1.0118\n", + " -0.0081\n", + " 0.2609\n", + " 0.1377\n", + " 1.0449\n", + " 0.1318\n", " \n", " \n", " 4\n", " 6.0\n", " 1\n", " 0\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", " \n", " \n", " 5\n", " 8.0\n", " 43\n", " 0\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", " \n", " \n", " 6\n", " 10.0\n", " 2\n", " 1\n", - " 3.867\n", - " 1.414\n", - " -0.063\n", - " 0.261\n", - " 3.931\n", - " 1.438\n", - " 2.733\n", + " 3.8673\n", + " 1.4142\n", + " -0.0632\n", + " 0.2607\n", + " 3.9305\n", + " 1.4380\n", + " 2.7332\n", " \n", " \n", " 7\n", " 13.0\n", " 10\n", " 0\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", - "0 1.0 275 9 0.481 0.339 -0.399 0.381 0.880 \n", - "1 2.0 11 0 0.000 0.000 0.000 0.000 0.000 \n", - "2 3.0 396 5 -0.492 0.450 0.341 0.306 -0.833 \n", - "3 5.0 43 1 0.130 1.012 -0.008 0.261 0.138 \n", - "4 6.0 1 0 0.000 0.000 0.000 0.000 0.000 \n", - "5 8.0 43 0 0.000 0.000 0.000 0.000 0.000 \n", - "6 10.0 2 1 3.867 1.414 -0.063 0.261 3.931 \n", - "7 13.0 10 0 0.000 0.000 0.000 0.000 0.000 \n", + " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", + "0 1.0 275 9 0.4810 0.3389 -0.3994 0.3806 0.8804 \n", + "1 2.0 11 0 0.0000 0.0000 0.0000 0.0000 0.0000 \n", + "2 3.0 396 5 -0.4920 0.4501 0.3409 0.3059 -0.8329 \n", + "3 5.0 43 1 0.1296 1.0118 -0.0081 0.2609 0.1377 \n", + "4 6.0 1 0 0.0000 0.0000 0.0000 0.0000 0.0000 \n", + "5 8.0 43 0 0.0000 0.0000 0.0000 0.0000 0.0000 \n", + "6 10.0 2 1 3.8673 1.4142 -0.0632 0.2607 3.9305 \n", + "7 13.0 10 0 0.0000 0.0000 0.0000 0.0000 0.0000 \n", "\n", " S_Contrast Studentized contrast \n", - "0 0.510 1.728 \n", - "1 0.000 0.000 \n", - "2 0.544 -1.531 \n", - "3 1.045 0.132 \n", - "4 0.000 0.000 \n", - "5 0.000 0.000 \n", - "6 1.438 2.733 \n", - "7 0.000 0.000 " + "0 0.5096 1.7275 \n", + "1 0.0000 0.0000 \n", + "2 0.5442 -1.5306 \n", + "3 1.0449 0.1318 \n", + "4 0.0000 0.0000 \n", + "5 0.0000 0.0000 \n", + "6 1.4380 2.7332 \n", + "7 0.0000 0.0000 " ] }, "execution_count": 3, @@ -259,163 +259,163 @@ " 1.0\n", " 275\n", " 9\n", - " 0.481\n", - " 0.339\n", - " -0.399\n", - " 0.381\n", - " 0.880\n", - " 0.510\n", - " 1.728\n", - " 2\n", - " 0.481\n", + " 0.4810\n", " 0.3389\n", + " -0.3994\n", + " 0.3806\n", + " 0.8804\n", + " 0.5096\n", + " 1.7275\n", + " 2\n", + " 0.4605\n", + " 0.2396\n", " \n", " \n", " 1\n", " 2.0\n", " 286\n", " 9\n", - " 0.440\n", - " 0.339\n", - " -0.377\n", - " 0.381\n", - " 0.818\n", - " 0.510\n", - " 1.605\n", - " 1\n", - " 0.030\n", - " 0.1011\n", + " 0.4405\n", + " 0.3387\n", + " -0.3771\n", + " 0.3807\n", + " 0.8176\n", + " 0.5095\n", + " 1.6046\n", + " 2\n", + " 0.4605\n", + " 0.2396\n", " \n", " \n", " 2\n", " 3.0\n", " 682\n", " 14\n", - " 0.002\n", - " 0.270\n", - " -0.014\n", - " 0.714\n", - " 0.016\n", - " 0.764\n", - " 0.021\n", + " 0.0021\n", + " 0.2700\n", + " -0.0143\n", + " 0.7144\n", + " 0.0163\n", + " 0.7637\n", + " 0.0214\n", " 1\n", - " 0.030\n", - " 0.1011\n", + " -0.0028\n", + " 0.1059\n", " \n", " \n", " 3\n", " 5.0\n", " 725\n", " 15\n", - " 0.010\n", - " 0.261\n", - " -0.140\n", - " 1.009\n", - " 0.150\n", - " 1.042\n", - " 0.144\n", + " 0.0101\n", + " 0.2609\n", + " -0.1400\n", + " 1.0090\n", + " 0.1501\n", + " 1.0422\n", + " 0.1440\n", " 1\n", - " 0.030\n", - " 0.1011\n", + " -0.0028\n", + " 0.1059\n", " \n", " \n", " 4\n", " 6.0\n", " 726\n", " 15\n", - " 0.009\n", - " 0.261\n", - " -0.122\n", - " 1.009\n", - " 0.130\n", - " 1.042\n", - " 0.125\n", + " 0.0087\n", + " 0.2609\n", + " -0.1217\n", + " 1.0092\n", + " 0.1304\n", + " 1.0424\n", + " 0.1251\n", " 1\n", - " 0.030\n", - " 0.1011\n", + " -0.0028\n", + " 0.1059\n", " \n", " \n", " 5\n", " 8.0\n", " 769\n", " 15\n", - " -0.050\n", - " 0.261\n", - " 1.469\n", - " 1.044\n", - " -1.519\n", - " 1.077\n", - " -1.411\n", + " -0.0501\n", + " 0.2608\n", + " 1.4694\n", + " 1.0445\n", + " -1.5194\n", + " 1.0765\n", + " -1.4114\n", " 1\n", - " 0.030\n", - " 0.1011\n", + " -0.0028\n", + " 0.1059\n", " \n", " \n", " 6\n", " 10.0\n", " 771\n", " 16\n", - " 0.013\n", - " 0.253\n", - " 0.000\n", - " 0.316\n", - " 0.013\n", - " 0.405\n", - " 0.033\n", + " -0.0507\n", + " 0.2607\n", + " 1.5547\n", + " 1.0536\n", + " -1.6054\n", + " 1.0854\n", + " -1.4791\n", " 1\n", - " 0.030\n", - " 0.1011\n", + " -0.0028\n", + " 0.1059\n", " \n", " \n", " 7\n", " 13.0\n", " 781\n", " 16\n", - " 0.000\n", - " 0.253\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.253\n", - " 0.000\n", + " -0.0626\n", + " 0.2606\n", + " 3.8673\n", + " 1.4213\n", + " -3.9299\n", + " 1.4450\n", + " -2.7196\n", " 1\n", - " 0.030\n", - " 0.1011\n", + " -0.0028\n", + " 0.1059\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", - "0 1.0 275 9 0.481 0.339 -0.399 0.381 0.880 \n", - "1 2.0 286 9 0.440 0.339 -0.377 0.381 0.818 \n", - "2 3.0 682 14 0.002 0.270 -0.014 0.714 0.016 \n", - "3 5.0 725 15 0.010 0.261 -0.140 1.009 0.150 \n", - "4 6.0 726 15 0.009 0.261 -0.122 1.009 0.130 \n", - "5 8.0 769 15 -0.050 0.261 1.469 1.044 -1.519 \n", - "6 10.0 771 16 0.013 0.253 0.000 0.316 0.013 \n", - "7 13.0 781 16 0.000 0.253 0.000 0.000 0.000 \n", + " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", + "0 1.0 275 9 0.4810 0.3389 -0.3994 0.3806 0.8804 \n", + "1 2.0 286 9 0.4405 0.3387 -0.3771 0.3807 0.8176 \n", + "2 3.0 682 14 0.0021 0.2700 -0.0143 0.7144 0.0163 \n", + "3 5.0 725 15 0.0101 0.2609 -0.1400 1.0090 0.1501 \n", + "4 6.0 726 15 0.0087 0.2609 -0.1217 1.0092 0.1304 \n", + "5 8.0 769 15 -0.0501 0.2608 1.4694 1.0445 -1.5194 \n", + "6 10.0 771 16 -0.0507 0.2607 1.5547 1.0536 -1.6054 \n", + "7 13.0 781 16 -0.0626 0.2606 3.8673 1.4213 -3.9299 \n", "\n", " S_Contrast Studentized contrast Generalized class Generalized WPlus \\\n", - "0 0.510 1.728 2 0.481 \n", - "1 0.510 1.605 1 0.030 \n", - "2 0.764 0.021 1 0.030 \n", - "3 1.042 0.144 1 0.030 \n", - "4 1.042 0.125 1 0.030 \n", - "5 1.077 -1.411 1 0.030 \n", - "6 0.405 0.033 1 0.030 \n", - "7 0.253 0.000 1 0.030 \n", + "0 0.5096 1.7275 2 0.4605 \n", + "1 0.5095 1.6046 2 0.4605 \n", + "2 0.7637 0.0214 1 -0.0028 \n", + "3 1.0422 0.1440 1 -0.0028 \n", + "4 1.0424 0.1251 1 -0.0028 \n", + "5 1.0765 -1.4114 1 -0.0028 \n", + "6 1.0854 -1.4791 1 -0.0028 \n", + "7 1.4450 -2.7196 1 -0.0028 \n", "\n", " Generalized S_WPlus \n", - "0 0.3389 \n", - "1 0.1011 \n", - "2 0.1011 \n", - "3 0.1011 \n", - "4 0.1011 \n", - "5 0.1011 \n", - "6 0.1011 \n", - "7 0.1011 " + "0 0.2396 \n", + "1 0.2396 \n", + "2 0.1059 \n", + "3 0.1059 \n", + "4 0.1059 \n", + "5 0.1059 \n", + "6 0.1059 \n", + "7 0.1059 " ] }, "execution_count": 4, @@ -475,47 +475,47 @@ " 13.0\n", " 10\n", " 0\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 2\n", - " 0.8228\n", - " 1.0235\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 0.0000\n", + " 1\n", + " -0.1911\n", + " 0.1730\n", " \n", " \n", " 1\n", " 10.0\n", " 12\n", " 1\n", - " 1.469\n", - " 1.044\n", - " -0.050\n", - " 0.261\n", - " 1.519\n", - " 1.077\n", - " 1.411\n", + " 1.4694\n", + " 1.0445\n", + " -0.0501\n", + " 0.2608\n", + " 1.5194\n", + " 1.0765\n", + " 1.4114\n", " 2\n", - " 0.8228\n", - " 1.0235\n", + " 1.4694\n", + " 1.0445\n", " \n", " \n", " 2\n", " 8.0\n", " 55\n", " 1\n", - " -0.122\n", - " 1.009\n", - " 0.009\n", - " 0.261\n", - " -0.130\n", - " 1.042\n", - " -0.125\n", + " -0.1217\n", + " 1.0092\n", + " 0.0087\n", + " 0.2609\n", + " -0.1304\n", + " 1.0424\n", + " -0.1251\n", " 1\n", - " -0.1860\n", + " -0.1911\n", " 0.1730\n", " \n", " \n", @@ -523,15 +523,15 @@ " 6.0\n", " 56\n", " 1\n", - " -0.140\n", - " 1.009\n", - " 0.010\n", - " 0.261\n", - " -0.150\n", - " 1.042\n", - " -0.144\n", + " -0.1400\n", + " 1.0090\n", + " 0.0101\n", + " 0.2609\n", + " -0.1501\n", + " 1.0422\n", + " -0.1440\n", " 1\n", - " -0.1860\n", + " -0.1911\n", " 0.1730\n", " \n", " \n", @@ -539,15 +539,15 @@ " 5.0\n", " 99\n", " 2\n", - " -0.014\n", - " 0.714\n", - " 0.002\n", - " 0.270\n", - " -0.016\n", - " 0.764\n", - " -0.021\n", + " -0.0143\n", + " 0.7144\n", + " 0.0021\n", + " 0.2700\n", + " -0.0163\n", + " 0.7637\n", + " -0.0214\n", " 1\n", - " -0.1860\n", + " -0.1911\n", " 0.1730\n", " \n", " \n", @@ -555,15 +555,15 @@ " 3.0\n", " 495\n", " 7\n", - " -0.377\n", - " 0.381\n", - " 0.440\n", - " 0.339\n", - " -0.818\n", - " 0.510\n", - " -1.605\n", + " -0.3771\n", + " 0.3807\n", + " 0.4405\n", + " 0.3387\n", + " -0.8176\n", + " 0.5095\n", + " -1.6046\n", " 1\n", - " -0.1860\n", + " -0.1911\n", " 0.1730\n", " \n", " \n", @@ -571,15 +571,15 @@ " 2.0\n", " 506\n", " 7\n", - " -0.399\n", - " 0.381\n", - " 0.481\n", - " 0.339\n", - " -0.880\n", - " 0.510\n", - " -1.728\n", + " -0.3994\n", + " 0.3806\n", + " 0.4810\n", + " 0.3389\n", + " -0.8804\n", + " 0.5096\n", + " -1.7275\n", " 1\n", - " -0.1860\n", + " -0.1911\n", " 0.1730\n", " \n", " \n", @@ -587,15 +587,15 @@ " 1.0\n", " 781\n", " 16\n", - " 0.000\n", - " 0.253\n", - " 0.000\n", - " 0.000\n", - " 0.000\n", - " 0.253\n", - " 0.000\n", + " -0.0626\n", + " 0.2606\n", + " 3.8673\n", + " 1.4213\n", + " -3.9299\n", + " 1.4450\n", + " -2.7196\n", " 1\n", - " -0.1860\n", + " -0.1911\n", " 0.1730\n", " \n", " \n", @@ -603,29 +603,29 @@ "" ], "text/plain": [ - " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", - "0 13.0 10 0 0.000 0.000 0.000 0.000 0.000 \n", - "1 10.0 12 1 1.469 1.044 -0.050 0.261 1.519 \n", - "2 8.0 55 1 -0.122 1.009 0.009 0.261 -0.130 \n", - "3 6.0 56 1 -0.140 1.009 0.010 0.261 -0.150 \n", - "4 5.0 99 2 -0.014 0.714 0.002 0.270 -0.016 \n", - "5 3.0 495 7 -0.377 0.381 0.440 0.339 -0.818 \n", - "6 2.0 506 7 -0.399 0.381 0.481 0.339 -0.880 \n", - "7 1.0 781 16 0.000 0.253 0.000 0.000 0.000 \n", + " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", + "0 13.0 10 0 0.0000 0.0000 0.0000 0.0000 0.0000 \n", + "1 10.0 12 1 1.4694 1.0445 -0.0501 0.2608 1.5194 \n", + "2 8.0 55 1 -0.1217 1.0092 0.0087 0.2609 -0.1304 \n", + "3 6.0 56 1 -0.1400 1.0090 0.0101 0.2609 -0.1501 \n", + "4 5.0 99 2 -0.0143 0.7144 0.0021 0.2700 -0.0163 \n", + "5 3.0 495 7 -0.3771 0.3807 0.4405 0.3387 -0.8176 \n", + "6 2.0 506 7 -0.3994 0.3806 0.4810 0.3389 -0.8804 \n", + "7 1.0 781 16 -0.0626 0.2606 3.8673 1.4213 -3.9299 \n", "\n", " S_Contrast Studentized contrast Generalized class Generalized WPlus \\\n", - "0 0.000 0.000 2 0.8228 \n", - "1 1.077 1.411 2 0.8228 \n", - "2 1.042 -0.125 1 -0.1860 \n", - "3 1.042 -0.144 1 -0.1860 \n", - "4 0.764 -0.021 1 -0.1860 \n", - "5 0.510 -1.605 1 -0.1860 \n", - "6 0.510 -1.728 1 -0.1860 \n", - "7 0.253 0.000 1 -0.1860 \n", + "0 0.0000 0.0000 1 -0.1911 \n", + "1 1.0765 1.4114 2 1.4694 \n", + "2 1.0424 -0.1251 1 -0.1911 \n", + "3 1.0422 -0.1440 1 -0.1911 \n", + "4 0.7637 -0.0214 1 -0.1911 \n", + "5 0.5095 -1.6046 1 -0.1911 \n", + "6 0.5096 -1.7275 1 -0.1911 \n", + "7 1.4450 -2.7196 1 -0.1911 \n", "\n", " Generalized S_WPlus \n", - "0 1.0235 \n", - "1 1.0235 \n", + "0 0.1730 \n", + "1 1.0445 \n", "2 0.1730 \n", "3 0.1730 \n", "4 0.1730 \n", @@ -695,7 +695,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAAK7CAYAAADBfQ+iAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABQOUlEQVR4nO3dfZhVZb038N8eBgZEZgAFBnAEAvPlpIL4iJCKJYbGU1qmaR4BSSxDTa2Tx+tkvlWQUvpkZp4exVPmsTwheTylAerJgtTMUUTliAmoOL4kwwgoLzPr+cPH7Wxnbpg9DMwAn8917evae6173eu31r32Hr6svdbOZVmWBQAAAE2UtHcBAAAAHZXABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwARAh3T55ZdHLpcrmDZ48OCYPHnydq3j1ltvjVwuF8uWLduu6/2gyZMnx+DBg1u97O677962BQHsIgQmgB3ICy+8EOeee258+MMfjt122y122223OOCAA2LatGnx5JNPtnd57ODWrVsXl19+eTz44IPtXQpAh1Ha3gUA0DL33HNPfP7zn4/S0tI4/fTT4+CDD46SkpJ49tlnY/bs2XHjjTfGCy+8EIMGDWrvUreZJUuWREnJrvl/fT/96U+joaFhm65j3bp1ccUVV0RExNFHH71N1wWwoxCYAHYAzz//fJx66qkxaNCgmD9/fvTv379g/ve+97348Y9/3KHDxNq1a6N79+5b1UdZWVkbVbPj6dy5c3uXALBL6rh/WQHIu/rqq2Pt2rUxa9asJmEpIqK0tDTOP//8qKqqKpj+7LPPxuc+97no3bt3dO3aNQ499NC4++67C9q8d43On/70p7jooouiT58+0b179/jMZz4Tr7/+epN1/e53v4sjjzwyunfvHj169IgJEybE4sWLC9q8d83M888/H5/85CejR48ecfrpp0dExEMPPRQnn3xy7L333lFWVhZVVVVx4YUXxttvv73F/fDBa5hyuVzy0fiao5bsh4iIxYsXx8c//vHo1q1b7LXXXvHtb3+7RWd17r777sjlcgVfi/z1r38duVwuPvvZzxa03X///ePzn/98wbTbbrstRo4cGd26dYvevXvHqaeeGi+++GJBm+auYfr73/8eZ5xxRpSXl0fPnj1j0qRJ8cQTT0Qul4tbb721SZ0vv/xynHjiibH77rtHnz594utf/3rU19dHRMSyZcuiT58+ERFxxRVX5Pfj5ZdfHhERNTU1ceaZZ8Zee+0VZWVl0b9//zjhhBPa/dougG3NGSaAHcA999wTw4YNi1GjRrV4mcWLF8dHP/rRGDhwYPzzP/9zdO/ePX71q1/FiSeeGL/+9a/jM5/5TEH78847L3r16hWXXXZZLFu2LK677ro499xz45e//GW+zc9//vOYNGlSjB8/Pr73ve/FunXr4sYbb4wjjjgiHn/88YJ/0G/atCnGjx8fRxxxRMycOTN22223iIi48847Y926dXHOOefEHnvsEY888khcf/318dJLL8Wdd95Z1H75+c9/3mTaN7/5zXjttdfyNzlo6X6oqamJj33sY7Fp06Z8u3/913+Nbt26bbGOI444InK5XPzhD3+Igw46KCLeDYYlJSXxxz/+Md/u9ddfj2effTbOPffc/LTvfOc7cemll8Ypp5wSZ511Vrz++utx/fXXx1FHHRWPP/549OzZs9l1NjQ0xKc+9al45JFH4pxzzon99tsvfvOb38SkSZOabV9fXx/jx4+PUaNGxcyZM2PevHnx/e9/P4YOHRrnnHNO9OnTJ2688cY455xz4jOf+Uw+6L23PSeddFIsXrw4zjvvvBg8eHC89tprMXfu3FixYkWrb0YBsEPIAOjQVq9enUVEduKJJzaZt2rVquz111/PP9atW5efd8wxx2QHHnhg9s477+SnNTQ0ZGPGjMn22Wef/LRZs2ZlEZGNGzcua2hoyE+/8MILs06dOmW1tbVZlmXZW2+9lfXs2TObOnVqQQ01NTVZRUVFwfRJkyZlEZH98z//c5OaG9f4nunTp2e5XC5bvnx5ftpll12WffDP1KBBg7JJkyY1Wf49V199dRYR2c9+9rOi98MFF1yQRUT28MMP56e99tprWUVFRRYR2QsvvJBcb5Zl2T/8wz9kp5xySv71IYcckp188slZRGTPPPNMlmVZNnv27CwisieeeCLLsixbtmxZ1qlTp+w73/lOQV+LFi3KSktLC6ZPmjQpGzRoUP71r3/96ywisuuuuy4/rb6+Pvv4xz+eRUQ2a9asgmUjIrvyyisL1jNixIhs5MiR+devv/56FhHZZZddVtBu1apVWURk11xzzWb3AcDOyFfyADq4urq6iIhmbwt99NFHR58+ffKPG264ISIi3nzzzbj//vvjlFNOibfeeiveeOONeOONN+Lvf/97jB8/Pp577rl4+eWXC/o6++yzC27jfeSRR0Z9fX0sX748IiLmzp0btbW1cdppp+X7e+ONN6JTp04xatSoeOCBB5rUd8455zSZ1viMzdq1a+ONN96IMWPGRJZl8fjjj7diD73rgQceiEsuuSTOO++8OOOMM4reD7/97W/j8MMPj8MOOyzfZ58+ffJfJdySI488Mh566KGIiHjrrbfiiSeeiLPPPjv23HPP/PSHHnooevbsGR/5yEciImL27NnR0NAQp5xySsE+raysjH322afZffqee++9Nzp37hxTp07NTyspKYlp06Yll/nyl7/cpOa//e1vW9y2bt26RZcuXeLBBx+MVatWbbE9wM5klwxMf/jDH+JTn/pUDBgwIHK5XMyZM6foPrIsi5kzZ8aHP/zhKCsri4EDB8Z3vvOdti8W2OX16NEjIiLWrFnTZN5NN90Uc+fOjdtuu61g+tKlSyPLsrj00ksLAlWfPn3isssui4iI1157rWCZvffeu+B1r169IiLy/0B+7rnnIiLi4x//eJM+f//73zfpr7S0NPbaa68mNa9YsSImT54cvXv3zl9LM3bs2IiIWL16dct2yge89NJL8fnPfz4++tGPxg9+8INW7Yfly5fHPvvs06Tvfffdt0U1HHnkkfHKK6/E0qVLY8GCBZHL5WL06NEFQeqhhx6Kj370o/mbczz33HORZVnss88+Tep75plnmuzTxpYvXx79+/fPf9XxPcOGDWu2fdeuXfPXKL2nV69eLQpAZWVl8b3vfS9+97vfRb9+/eKoo46Kq6++Ompqara4LMCObpe8hmnt2rVx8MEHx5QpU5pcjNtSX/3qV+P3v/99zJw5Mw488MB48803480332zjSgEiKioqon///vHUU081mffeNU0fvPD+vRsVfP3rX4/x48c32+8H/2HdqVOnZttlWVbQ589//vOorKxs0q60tPBPSllZWZO79tXX18exxx4bb775Zlx88cWx3377Rffu3ePll1+OyZMnt+q22Rs2bIjPfe5zUVZWFr/61a8K6mjNfmitI444IiLe/U+5v/3tb3HIIYdE9+7d48gjj4wf/vCHsWbNmnj88ccL/nOtoaEhcrlc/O53v2t2/7flj82mxrelLrjggvjUpz4Vc+bMifvuuy8uvfTSmD59etx///0xYsSINqoSoOPZJQPT8ccfH8cff3xy/vr16+Nf/uVf4t///d+jtrY2PvKRj8T3vve9/G9SPPPMM3HjjTfGU089lf+fxyFDhmyP0oFd1IQJE+L//t//G4888kjBV8ZSPvShD0XEu7eiHjduXJvUMHTo0IiI6Nu3b6v7XLRoUfzP//xP/Nu//VtMnDgxP33u3Lmtruv888+P6urq+MMf/hD9+vUrmFfMfhg0aFD+LFpjS5YsaVEde++9d+y9997x0EMPxd/+9rc48sgjIyLiqKOOiosuuijuvPPOqK+vj6OOOiq/zNChQyPLshgyZEh8+MMfbtF6Gtf7wAMPxLp16wrOMi1durSofhpr/JXM5gwdOjS+9rWvxde+9rV47rnnYvjw4fH973+/yRlOgJ3JLvmVvC0599xzY+HChXHHHXfEk08+GSeffHIcd9xx+T+k//mf/xkf+tCH4p577okhQ4bE4MGD46yzznKGCdhmvvGNb8Ruu+0WU6ZMiVdffbXJ/PfOAr2nb9++cfTRR8dNN90Ur7zySpP2zd0ufEvGjx8f5eXl8d3vfjc2btzYqj7fO8vRuN4sy+L//J//U3Q9ERGzZs2Km266KW644YZmg2Qx++GTn/xk/PnPf45HHnmkYP4vfvGLFtdz5JFHxv333x+PPPJIPjANHz48evToETNmzIhu3brFyJEj8+0/+9nPRqdOneKKK65oMoZZlsXf//735LrGjx8fGzdujJ/+9Kf5aQ0NDfnr2FrjveBVW1tbMH3dunXxzjvvFEwbOnRo9OjRI9avX9/q9QHsCHbJM0ybs2LFipg1a1asWLEiBgwYEBHvfpXj3nvvjVmzZsV3v/vd+Nvf/hbLly+PO++8M372s59FfX19XHjhhfG5z30u7r///nbeAmBntM8++8Ttt98ep512Wuy7775x+umnx8EHHxxZlsULL7wQt99+e5SUlBRcM3TDDTfEEUccEQceeGBMnTo1PvShD8Wrr74aCxcujJdeeimeeOKJomooLy+PG2+8Mc4444w45JBD4tRTT40+ffrEihUr4r/+67/iox/9aPzoRz/abB/77bdfDB06NL7+9a/Hyy+/HOXl5fHrX/+6VTcSeOONN+IrX/lKHHDAAVFWVtbkLMdnPvOZ6N69e4v3wze+8Y34+c9/Hscdd1x89atfzd9WfNCgQQW/r7Q5Rx55ZPziF7+IXC6X/4pep06dYsyYMXHffffF0UcfHV26dMm3Hzp0aHz729+OSy65JJYtWxYnnnhi9OjRI1544YW466674uyzz46vf/3rza7rxBNPjMMOOyy+9rWvxdKlS2O//faLu+++O/+fd1s6W9Scbt26xQEHHBC//OUv48Mf/nD07t07PvKRj8SmTZvimGOOiVNOOSUOOOCAKC0tjbvuuiteffXVOPXUU4teD8AOpV3uzdeBRER211135V/fc889WURk3bt3L3iUlpbmbxc7derULCKyJUuW5Jd77LHHsojInn322e29CcAuZOnSpdk555yTDRs2LOvatWvWrVu3bL/99su+/OUvZ9XV1U3aP//889nEiROzysrKrHPnztnAgQOz//2//3f2H//xH/k2791W/NFHHy1Y9oEHHsgiInvggQeaTB8/fnxWUVGRde3aNRs6dGg2efLk7C9/+Uu+zaRJk7Lu3bs3uw1PP/10Nm7cuGz33XfP9txzz2zq1KnZE0880eRW2Fu6rfgLL7yQRUTy0fg24C3ZD1mWZU8++WQ2duzYrGvXrtnAgQOzq666Krv55ptbdFvxLMuyxYsXZxGR7b///gXTv/3tb2cRkV166aXNLvfrX/86O+KII/J/c/bbb79s2rRpBX9nPnhb8Sx79zbgX/jCF7IePXpkFRUV2eTJk7M//elPWURkd9xxR8GyzY1Hc/t4wYIF2ciRI7MuXbrkbzH+xhtvZNOmTcv222+/rHv37llFRUU2atSo7Fe/+tUW9wnAji6XZR/4DsAuJpfLxV133RUnnnhiRET88pe/jNNPPz0WL17c5ALZ3XffPSorK+Oyyy5r8pWUt99+O3bbbbf4/e9/H8cee+z23AQAyJszZ0585jOfiT/+8Y/x0Y9+tL3LAdjh+UreB4wYMSLq6+vjtddey3///IM++tGPxqZNm+L555/PXwT9P//zPxHx7kW4ALA9vP322wW/a1VfXx/XX399lJeXxyGHHNKOlQHsPHbJwLRmzZqCuwi98MILUV1dHb17944Pf/jDcfrpp8fEiRPj+9//fowYMSJef/31mD9/fhx00EExYcKEGDduXBxyyCExZcqUuO6666KhoSGmTZsWxx57bNF3OQKA1jrvvPPi7bffjtGjR8f69etj9uzZsWDBgvjud79bEKQAaL1d8it5Dz74YHzsYx9rMn3SpElx6623xsaNG+Pb3/52/OxnP4uXX3459txzzzj88MPjiiuuiAMPPDAiIlauXBnnnXde/P73v4/u3bvH8ccfH9///vejd+/e23tzANhF3X777fH9738/li5dGu+8804MGzYszjnnnDj33HPbuzSAncYuGZgAAABawu8wAQAAJAhMAAAACbvMTR8aGhpi5cqV0aNHj1b9mB8AALBzyLIs3nrrrRgwYECUlGz+HNIuE5hWrlwZVVVV7V0GAADQQbz44oux1157bbbNLhOYevToERHv7pTy8vJ2rgYAAGgvdXV1UVVVlc8Im7PLBKb3voZXXl4uMAEAAC26VMdNHwAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASCht7wJ437ElJ7d3Cfx/962sbu8SNmv8gOHtXcJmzW24s71LAABoE84wAQAAJBQVmAYPHhy5XK7JY9q0ac22v/XWW5u07dq1a37+xo0b4+KLL44DDzwwunfvHgMGDIiJEyfGypUrt7jeGTNmtGJzAQAAWq6or+Q9+uijUV9fn3/91FNPxbHHHhsnn5z+Kll5eXksWbIk/zqXy+Wfr1u3Lv7617/GpZdeGgcffHCsWrUqvvrVr8anP/3p+Mtf/lLQz5VXXhlTp07Nv+7Ro0cxpQMAABStqMDUp0+fgtczZsyIoUOHxtixY5PL5HK5qKysbHZeRUVFzJ07t2Daj370ozjssMNixYoVsffee+en9+jRI9kPAADAttDqa5g2bNgQt912W0yZMqXgrNEHrVmzJgYNGhRVVVVxwgknxOLFizfb7+rVqyOXy0XPnj0Lps+YMSP22GOPGDFiRFxzzTWxadOmzfazfv36qKurK3gAAAAUo9V3yZszZ07U1tbG5MmTk2323XffuOWWW+Kggw6K1atXx8yZM2PMmDGxePHi2GuvvZq0f+edd+Liiy+O0047LcrLy/PTzz///DjkkEOid+/esWDBgrjkkkvilVdeiR/84AfJdU+fPj2uuOKK1m4eAABA5LIsy1qz4Pjx46NLly7xn//5ny1eZuPGjbH//vvHaaedFldddVWTeSeddFK89NJL8eCDDxYEpg+65ZZb4ktf+lKsWbMmysrKmm2zfv36WL9+ff51XV1dVFVVxerVqzfbd3tyW/GOw23Ft47bigMAHVldXV1UVFS0KBu06gzT8uXLY968eTF79uyiluvcuXOMGDEili5dWjB948aNccopp8Ty5cvj/vvv32LRo0aNik2bNsWyZcti3333bbZNWVlZMkwBAAC0RKuuYZo1a1b07ds3JkyYUNRy9fX1sWjRoujfv39+2nth6bnnnot58+bFHnvsscV+qquro6SkJPr27Vt07QAAAC1V9BmmhoaGmDVrVkyaNClKSwsXnzhxYgwcODCmT58eEe/eCvzwww+PYcOGRW1tbVxzzTWxfPnyOOussyLi3bD0uc99Lv7617/GPffcE/X19VFTUxMREb17944uXbrEwoUL4+GHH46Pfexj0aNHj1i4cGFceOGF8Y//+I/Rq1evrd1+AACApKID07x582LFihUxZcqUJvNWrFgRJSXvn7RatWpVTJ06NWpqaqJXr14xcuTIWLBgQRxwwAEREfHyyy/H3XffHRERw4cPL+jrgQceiKOPPjrKysrijjvuiMsvvzzWr18fQ4YMiQsvvDAuuuiiYksHAAAoSqtv+rCjKebCrvbipg8dh5s+bB03fQAAOrJiskGrf4cJAABgZycwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJfoepA2mo2adN++vIv9XT0X/naFfTkY8Vdm5+swuA9uB3mAAAANqAwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJOSyLMvau4jtoa6uLioqKmL16tVRXl7e3uU069iSk9u7hB3WfSur27sEGhk/YHh7lwAdztyGO9u7BAD+v2KygTNMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJCQy7Isa+8itoe6urqoqKiI1atXR3l5eXuX06yGmn3auwTocMYPGN7eJQCtMLfhzvYuASCpmGzgDBMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkFDa3gXwvvEDhrdpf/etrG7T/qA9dPTjuK3ft7CzOLbk5PYuYbua23Bne5cAbCPOMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAQml7FwCwI7tvZXWb9jd+wPA27Q/YPo4tObm9S9hu5jbc2d4lwHblDBMAAEBCUYFp8ODBkcvlmjymTZvWbPtbb721SduuXbvm52/cuDEuvvjiOPDAA6N79+4xYMCAmDhxYqxcubKgnzfffDNOP/30KC8vj549e8YXv/jFWLNmTSs2FwAAoOWK+kreo48+GvX19fnXTz31VBx77LFx8snp09Dl5eWxZMmS/OtcLpd/vm7duvjrX/8al156aRx88MGxatWq+OpXvxqf/vSn4y9/+Uu+3emnnx6vvPJKzJ07NzZu3BhnnnlmnH322XH77bcXUz4AAEBRigpMffr0KXg9Y8aMGDp0aIwdOza5TC6Xi8rKymbnVVRUxNy5cwum/ehHP4rDDjssVqxYEXvvvXc888wzce+998ajjz4ahx56aEREXH/99fHJT34yZs6cGQMGDChmEwAAAFqs1dcwbdiwIW677baYMmVKwVmjD1qzZk0MGjQoqqqq4oQTTojFixdvtt/Vq1dHLpeLnj17RkTEwoULo2fPnvmwFBExbty4KCkpiYcffjjZz/r166Ourq7gAQAAUIxWB6Y5c+ZEbW1tTJ48Odlm3333jVtuuSV+85vfxG233RYNDQ0xZsyYeOmll5pt/84778TFF18cp512WpSXl0dERE1NTfTt27egXWlpafTu3TtqamqS654+fXpUVFTkH1VVVcVvJAAAsEtrdWC6+eab4/jjj9/sV+JGjx4dEydOjOHDh8fYsWNj9uzZ0adPn7jpppuatN24cWOccsopkWVZ3Hjjja0tK++SSy6J1atX5x8vvvjiVvcJAADsWlr1O0zLly+PefPmxezZs4tarnPnzjFixIhYunRpwfT3wtLy5cvj/vvvz59dioiorKyM1157raD9pk2b4s0330xeGxURUVZWFmVlZUXVBwAA0FirzjDNmjUr+vbtGxMmTChqufr6+li0aFH0798/P+29sPTcc8/FvHnzYo899ihYZvTo0VFbWxuPPfZYftr9998fDQ0NMWrUqNaUDwAA0CJFn2FqaGiIWbNmxaRJk6K0tHDxiRMnxsCBA2P69OkREXHllVfG4YcfHsOGDYva2tq45pprYvny5XHWWWdFxLth6XOf+1z89a9/jXvuuSfq6+vz1yX17t07unTpEvvvv38cd9xxMXXq1PjJT34SGzdujHPPPTdOPfVUd8gDAAC2qaID07x582LFihUxZcqUJvNWrFgRJSXvn7RatWpVTJ06NWpqaqJXr14xcuTIWLBgQRxwwAEREfHyyy/H3XffHRERw4cPL+jrgQceiKOPPjoiIn7xi1/EueeeG8ccc0yUlJTESSedFD/84Q+LLR0AAKAouSzLsvYuYnuoq6uLioqKWL16dcE1Uh3JsSXpHwBujftWVrdpf8C2N37A8PYuAWCz5jbc2d4lwFYrJhu0+i55AAAAOzuBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABI8DtMHUhDzT5t2l9b/p6L33SivbT17xLtasey33UC6Fj8jlXH4HeYAAAA2oDABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAklLZ3Abxv/IDh7V3CdtPW23rfyuo27a+j6+jHyq42HgDQUseWnNzeJWw3cxvubO8S2oQzTAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQkMuyLGvvIraHurq6qKioiNWrV0d5eXl7l9Oshpp92rS/8QOGt2l/bem+ldVt2l9bb2tHr29X0tZjwdZxLAPQXuY23NlmfRWTDZxhAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAICE0vYugG3nvpXV7V1C0vgBw9u7hB1aW49tW49HRz72AACK4QwTAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACSUtncBvG/8gOFt2t99K6vbtL9dibHYOm25/3a1fQcAdCzOMAEAACQUFZgGDx4cuVyuyWPatGnNtr/11lubtO3atWtBm9mzZ8cnPvGJ2GOPPSKXy0V1dXWTfo4++ugm/Xz5y18upnQAAICiFfWVvEcffTTq6+vzr5966qk49thj4+STT04uU15eHkuWLMm/zuVyBfPXrl0bRxxxRJxyyikxderUZD9Tp06NK6+8Mv96t912K6Z0AACAohUVmPr06VPwesaMGTF06NAYO3ZscplcLheVlZXJ+WeccUZERCxbtmyz695tt9022w8AAEBba/U1TBs2bIjbbrstpkyZ0uSsUWNr1qyJQYMGRVVVVZxwwgmxePHiVq3vF7/4Rey5557xkY98JC655JJYt27dZtuvX78+6urqCh4AAADFaPVd8ubMmRO1tbUxefLkZJt99903brnlljjooINi9erVMXPmzBgzZkwsXrw49tprrxav6wtf+EIMGjQoBgwYEE8++WRcfPHFsWTJkpg9e3ZymenTp8cVV1xRzCYBAAAUaHVguvnmm+P444+PAQMGJNuMHj06Ro8enX89ZsyY2H///eOmm26Kq666qsXrOvvss/PPDzzwwOjfv38cc8wx8fzzz8fQoUObXeaSSy6Jiy66KP+6rq4uqqqqWrxOAACAVgWm5cuXx7x58zZ7hqc5nTt3jhEjRsTSpUtbs9q8UaNGRUTE0qVLk4GprKwsysrKtmo9AADArq1V1zDNmjUr+vbtGxMmTChqufr6+li0aFH079+/NavNe+/W41vbDwAAwOYUfYapoaEhZs2aFZMmTYrS0sLFJ06cGAMHDozp06dHRMSVV14Zhx9+eAwbNixqa2vjmmuuieXLl8dZZ52VX+bNN9+MFStWxMqVKyMi8rcgr6ysjMrKynj++efj9ttvj09+8pOxxx57xJNPPhkXXnhhHHXUUXHQQQe1esMBAAC2pOjANG/evFixYkVMmTKlybwVK1ZEScn7J61WrVoVU6dOjZqamujVq1eMHDkyFixYEAcccEC+zd133x1nnnlm/vWpp54aERGXXXZZXH755dGlS5eYN29eXHfddbF27dqoqqqKk046Kb75zW8WWzoAAEBRclmWZe1dxPZQV1cXFRUVsXr16igvL2/vcpp1bEn6B4Bb476V1W3aX1saP2B4e5ewXXXksYjo2OPR0ffdrqYjHysA7NzmNtzZZn0Vkw1a/TtMAAAAOzuBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIKPqHa9l2OvLvzfjtla1j/7Gz6MifUxFt+15r6231OQCwY3KGCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASStu7AN43fsDw9i6BbeS+ldXtXcJmtfWx15bb25Fro+PpyMceADsmZ5gAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgITS9i6AXdN9K6vbu4TtavyA4e1dwmZ15PHoyLWxc2vrY6+jfw50dB39s8D4ws7LGSYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASCht7wJ4330rq9u7hO1m/IDhbdrfrrTvIjr+9rbl+Hb0bQW2j7b+uwHQUs4wAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAEBCaXsXwPvGDxjepv3dt7K6zfrqyLXtCHa17e3I2vpYbmuOla3TluPb0ceirevr6O8NWs+xAlvHGSYAAICEogLT4MGDI5fLNXlMmzat2fa33nprk7Zdu3YtaDN79uz4xCc+EXvssUfkcrmorq5u0s8777wT06ZNiz322CN23333OOmkk+LVV18tpnQAAICiFRWYHn300XjllVfyj7lz50ZExMknn5xcpry8vGCZ5cuXF8xfu3ZtHHHEEfG9730v2ceFF14Y//mf/xl33nln/Pd//3esXLkyPvvZzxZTOgAAQNGKuoapT58+Ba9nzJgRQ4cOjbFjxyaXyeVyUVlZmZx/xhlnRETEsmXLmp2/evXquPnmm+P222+Pj3/84xERMWvWrNh///3jz3/+cxx++OHFbAIAAECLtfoapg0bNsRtt90WU6ZMiVwul2y3Zs2aGDRoUFRVVcUJJ5wQixcvLmo9jz32WGzcuDHGjRuXn7bffvvF3nvvHQsXLkwut379+qirqyt4AAAAFKPVgWnOnDlRW1sbkydPTrbZd99945Zbbonf/OY3cdttt0VDQ0OMGTMmXnrppRavp6amJrp06RI9e/YsmN6vX7+oqalJLjd9+vSoqKjIP6qqqlq8TgAAgIitCEw333xzHH/88TFgwIBkm9GjR8fEiRNj+PDhMXbs2Jg9e3b06dMnbrrpptautsUuueSSWL16df7x4osvbvN1AgAAO5dW/Q7T8uXLY968eTF79uyiluvcuXOMGDEili5d2uJlKisrY8OGDVFbW1twlunVV1/d7LVRZWVlUVZWVlR9AAAAjbXqDNOsWbOib9++MWHChKKWq6+vj0WLFkX//v1bvMzIkSOjc+fOMX/+/Py0JUuWxIoVK2L06NFFrR8AAKAYRZ9hamhoiFmzZsWkSZOitLRw8YkTJ8bAgQNj+vTpERFx5ZVXxuGHHx7Dhg2L2trauOaaa2L58uVx1lln5Zd58803Y8WKFbFy5cqIeDcMRbx7ZqmysjIqKirii1/8Ylx00UXRu3fvKC8vj/POOy9Gjx7tDnkAAMA2VXRgmjdvXqxYsSKmTJnSZN6KFSuipOT9k1arVq2KqVOnRk1NTfTq1StGjhwZCxYsiAMOOCDf5u67744zzzwz//rUU0+NiIjLLrssLr/88oiIuPbaa6OkpCROOumkWL9+fYwfPz5+/OMfF1s6AABAUYoOTJ/4xCciy7Jm5z344IMFr6+99tq49tprN9vf5MmTN3unvYiIrl27xg033BA33HBDMaUCAABslVbfJQ8AAGBnJzABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAlF/w4T2859K6vbtL/xA4a3aX/QHhzHO7eOPL4dubaIjl8fHYdjBbaOM0wAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkFDa3gXwvvEDhrdpf/etrG7T/nYlxmLrtOX2tvVYdHS72vZCe2nrz2XvXdh5OcMEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAml7V0A77tvZXWb9jd+wPA266uta+vodrXtbWtteewBRHT8z+WOXJ/PZNg6zjABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQEJpexfA+8YPGN7eJSS1dW33raxu0/52NR35WIGdxa72OdXRP1f8HWq9tt7Wjn6sQFtzhgkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEkrbuwB2TeMHDG/T/u5bWd2m/bW1tt5egI6uo38u03ptPbb+RtLRFXWGafDgwZHL5Zo8pk2b1mz7W2+9tUnbrl27FrTJsiy+9a1vRf/+/aNbt24xbty4eO6557a43hkzZhS5qQAAAMUp6gzTo48+GvX19fnXTz31VBx77LFx8sknJ5cpLy+PJUuW5F/ncrmC+VdffXX88Ic/jH/7t3+LIUOGxKWXXhrjx4+Pp59+uiBcXXnllTF16tT86x49ehRTOgAAQNGKCkx9+vQpeD1jxowYOnRojB07NrlMLpeLysrKZudlWRbXXXddfPOb34wTTjghIiJ+9rOfRb9+/WLOnDlx6qmn5tv26NEj2Q8AAMC20OqbPmzYsCFuu+22mDJlSpOzRo2tWbMmBg0aFFVVVXHCCSfE4sWL8/NeeOGFqKmpiXHjxuWnVVRUxKhRo2LhwoUF/cyYMSP22GOPGDFiRFxzzTWxadOmzda3fv36qKurK3gAAAAUo9U3fZgzZ07U1tbG5MmTk2323XffuOWWW+Kggw6K1atXx8yZM2PMmDGxePHi2GuvvaKmpiYiIvr161ewXL9+/fLzIiLOP//8OOSQQ6J3796xYMGCuOSSS+KVV16JH/zgB8l1T58+Pa644orWbh4AAEDrA9PNN98cxx9/fAwYMCDZZvTo0TF69Oj86zFjxsT+++8fN910U1x11VUtXtdFF12Uf37QQQdFly5d4ktf+lJMnz49ysrKml3mkksuKViurq4uqqqqWrxOAACAVn0lb/ny5TFv3rw466yzilquc+fOMWLEiFi6dGlERP6apFdffbWg3auvvrrZ65VGjRoVmzZtimXLliXblJWVRXl5ecEDAACgGK0KTLNmzYq+ffvGhAkTilquvr4+Fi1aFP3794+IiCFDhkRlZWXMnz8/36auri4efvjhgjNTH1RdXR0lJSXRt2/f1pQPAADQIkV/Ja+hoSFmzZoVkyZNitLSwsUnTpwYAwcOjOnTp0fEu7cCP/zww2PYsGFRW1sb11xzTSxfvjx/ZiqXy8UFF1wQ3/72t2OfffbJ31Z8wIABceKJJ0ZExMKFC+Phhx+Oj33sY9GjR49YuHBhXHjhhfGP//iP0atXr63cfAAAgLSiA9O8efNixYoVMWXKlCbzVqxYESUl75+0WrVqVUydOjVqamqiV69eMXLkyFiwYEEccMAB+Tbf+MY3Yu3atXH22WdHbW1tHHHEEXHvvffmf4OprKws7rjjjrj88stj/fr1MWTIkLjwwgsLrk8CAADYFnJZlmXtXcT2UFdXFxUVFbF69eoOez3TsSXpHwBm8+5bWd3eJWzW+AHD27sEoEgd/XOlrbX159Sutv9oPX8jaam5DXe2WV/FZINW/w4TAADAzk5gAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAICE0vYugPe15Y9xtbWO/qO6Hf0HFzv6Dzj60UB2Fh39vdaR2XcAzXOGCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIKG3vAtgxzG24s71L2K6OLTm5Tfu7b2V1m/YHOwvvDQA6OmeYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACChtL0LgI5obsOd7V3CdnZyexeQdN/K6vYuYbPGDxje3iXs0Np6/3X04wV2Bj732NU4wwQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACaXtXQDQ/uY23NneJWw3DTX7tHcJQCuMHzC8Tfu7b2V1m/bXkbX1voNdjTNMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJBQ2t4FAGxPJZXPtWl/cxvatLsO79iSk9u7BHZR962sbtP+2vqzoCPb1T6noK05wwQAAJBQVGAaPHhw5HK5Jo9p06Y12/7WW29t0rZr164FbbIsi29961vRv3//6NatW4wbNy6ee67wf33efPPNOP3006O8vDx69uwZX/ziF2PNmjVFbioAAEBxigpMjz76aLzyyiv5x9y5cyMi4uST01/RKC8vL1hm+fLlBfOvvvrq+OEPfxg/+clP4uGHH47u3bvH+PHj45133sm3Of3002Px4sUxd+7cuOeee+IPf/hDnH322cWUDgAAULSirmHq06dPwesZM2bE0KFDY+zYscllcrlcVFZWNjsvy7K47rrr4pvf/GaccMIJERHxs5/9LPr16xdz5syJU089NZ555pm4995749FHH41DDz00IiKuv/76+OQnPxkzZ86MAQMGFLMJAAAALdbqa5g2bNgQt912W0yZMiVyuVyy3Zo1a2LQoEFRVVUVJ5xwQixevDg/74UXXoiampoYN25cflpFRUWMGjUqFi5cGBERCxcujJ49e+bDUkTEuHHjoqSkJB5++OHketevXx91dXUFDwAAgGK0OjDNmTMnamtrY/Lkyck2++67b9xyyy3xm9/8Jm677bZoaGiIMWPGxEsvvRQRETU1NRER0a9fv4Ll+vXrl59XU1MTffv2LZhfWloavXv3zrdpzvTp06OioiL/qKqqas1mAgAAu7BWB6abb745jj/++M1+JW706NExceLEGD58eIwdOzZmz54dffr0iZtuuqm1q22xSy65JFavXp1/vPjii9t8nQAAwM6lVb/DtHz58pg3b17Mnj27qOU6d+4cI0aMiKVLl0ZE5K9tevXVV6N///75dq+++moMHz483+a1114r6GfTpk3x5ptvJq+NiogoKyuLsrKyouoDAABorFVnmGbNmhV9+/aNCRMmFLVcfX19LFq0KB+OhgwZEpWVlTF//vx8m7q6unj44Ydj9OjREfHuWara2tp47LHH8m3uv//+aGhoiFGjRrWmfAAAgBYp+gxTQ0NDzJo1KyZNmhSlpYWLT5w4MQYOHBjTp0+PiIgrr7wyDj/88Bg2bFjU1tbGNddcE8uXL4+zzjorIt69g94FF1wQ3/72t2OfffaJIUOGxKWXXhoDBgyIE088MSIi9t9//zjuuONi6tSp8ZOf/CQ2btwY5557bpx66qnukAcAAGxTRQemefPmxYoVK2LKlClN5q1YsSJKSt4/abVq1aqYOnVq1NTURK9evWLkyJGxYMGCOOCAA/JtvvGNb8TatWvj7LPPjtra2jjiiCPi3nvvLfiB21/84hdx7rnnxjHHHBMlJSVx0kknxQ9/+MNiSwcAAChKLsuyrL2L2B7q6uqioqIiVq9eHeXl5e1dDsAO6diS9A+VdwT3raxu7xLYQZRUPtfeJQDtqJhs0Oq75AEAAOzsBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIKHoH64FYNc1t+HO9i4BALYrZ5gAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgITS9i5ge8myLCIi6urq2rkSAACgPb2XCd7LCJuzywSmt956KyIiqqqq2rkSAACgI3jrrbeioqJis21yWUti1U6goaEhVq5cGT169IhcLtfe5eyy6urqoqqqKl588cUoLy9v73J2acaiYzEeHYex6DiMRcdiPDoOY7H1siyLt956KwYMGBAlJZu/SmmXOcNUUlISe+21V3uXwf9XXl7uDd5BGIuOxXh0HMai4zAWHYvx6DiMxdbZ0pml97jpAwAAQILABAAAkCAwsV2VlZXFZZddFmVlZe1dyi7PWHQsxqPjMBYdh7HoWIxHx2Estq9d5qYPAAAAxXKGCQAAIEFgAgAASBCYAAAAEgQmAACABIGJpBkzZkQul4sLLrggP+1f//Vf4+ijj47y8vLI5XJRW1vbZLk333wzTj/99CgvL4+ePXvGF7/4xVizZk1BmyeffDKOPPLI6Nq1a1RVVcXVV1/dpJ8777wz9ttvv+jatWsceOCB8dvf/rZgfpZl8a1vfSv69+8f3bp1i3HjxsVzzz3XJtveEbV2PAYPHhy5XK7gMWPGjII2xqM4HxyLN998M84777zYd999o1u3brH33nvH+eefH6tXry5YbsWKFTFhwoTYbbfdom/fvvFP//RPsWnTpoI2Dz74YBxyyCFRVlYWw4YNi1tvvbXJ+m+44YYYPHhwdO3aNUaNGhWPPPJIwfx33nknpk2bFnvssUfsvvvucdJJJ8Wrr77apvugI2nteHzwfZHL5eKOO+4oaGM8itPc59SXvvSlGDp0aHTr1i369OkTJ5xwQjz77LMFy3lvtL3WjoX3xbbR3Hi8J8uyOP744yOXy8WcOXMK5nlvdBAZNOORRx7JBg8enB100EHZV7/61fz0a6+9Nps+fXo2ffr0LCKyVatWNVn2uOOOyw4++ODsz3/+c/bQQw9lw4YNy0477bT8/NWrV2f9+vXLTj/99Oypp57K/v3f/z3r1q1bdtNNN+Xb/OlPf8o6deqUXX311dnTTz+dffOb38w6d+6cLVq0KN9mxowZWUVFRTZnzpzsiSeeyD796U9nQ4YMyd5+++1tsk/a09aMx6BBg7Irr7wye+WVV/KPNWvW5Ocbj+I0NxaLFi3KPvvZz2Z33313tnTp0mz+/PnZPvvsk5100kn55TZt2pR95CMfycaNG5c9/vjj2W9/+9tszz33zC655JJ8m7/97W/Zbrvtll100UXZ008/nV1//fVZp06dsnvvvTff5o477si6dOmS3XLLLdnixYuzqVOnZj179sxeffXVfJsvf/nLWVVVVTZ//vzsL3/5S3b44YdnY8aM2fY7px20djyyLMsiIps1a1bBe6Px8Wo8ipP6nLrpppuy//7v/85eeOGF7LHHHss+9alPZVVVVdmmTZuyLPPe2BZaOxZZ5n2xLaTG4z0/+MEPsuOPPz6LiOyuu+7KT/fe6DgEJpp46623sn322SebO3duNnbs2Gbf3A888ECz/0B/+umns4jIHn300fy03/3ud1kul8tefvnlLMuy7Mc//nHWq1evbP369fk2F198cbbvvvvmX59yyinZhAkTCvoeNWpU9qUvfSnLsixraGjIKisrs2uuuSY/v7a2NisrK8v+/d//vdXb3hFtzXhk2buB6dprr032bzxariVj8Z5f/epXWZcuXbKNGzdmWZZlv/3tb7OSkpKspqYm3+bGG2/MysvL8/v+G9/4RvYP//APBf18/vOfz8aPH59/fdhhh2XTpk3Lv66vr88GDBiQTZ8+Pcuyd/d7586dszvvvDPf5plnnskiIlu4cGHrN74D2prxyLKsyT9OPsh4tFwxY/HEE09kEZEtXbo0yzLvjba2NWORZd4XbW1L4/H4449nAwcOzF555ZUm+957o+PwlTyamDZtWkyYMCHGjRtX9LILFy6Mnj17xqGHHpqfNm7cuCgpKYmHH3443+aoo46KLl265NuMHz8+lixZEqtWrcq3+eD6x48fHwsXLoyIiBdeeCFqamoK2lRUVMSoUaPybXYWWzMe75kxY0bsscceMWLEiLjmmmsKTucbj5YrZixWr14d5eXlUVpaGhHv7sMDDzww+vXrl28zfvz4qKuri8WLF+fbbG4/b9iwIR577LGCNiUlJTFu3Lh8m8ceeyw2btxY0Ga//faLvffee6cai4itG4/Gfey5555x2GGHxS233BJZo58mNB4t19KxWLt2bcyaNSuGDBkSVVVVEeG90da2Ziwa9+F90TY2Nx7r1q2LL3zhC3HDDTdEZWVlk/neGx1H6ZabsCu544474q9//Ws8+uijrVq+pqYm+vbtWzCttLQ0evfuHTU1Nfk2Q4YMKWjz3odBTU1N9OrVK2pqago+IN5r07iPxss112ZnsLXjERFx/vnnxyGHHBK9e/eOBQsWxCWXXBKvvPJK/OAHP4gI49FSxYzFG2+8EVdddVWcffbZ+WmpffjevM21qauri7fffjtWrVoV9fX1zbZ57zqEmpqa6NKlS/Ts2bNJm51lLCK2fjwiIq688sr4+Mc/Hrvttlv8/ve/j6985SuxZs2aOP/88yPCeLRUS8bixz/+cXzjG9+ItWvXxr777htz587N/yeN90bb2dqxiPC+aEtbGo8LL7wwxowZEyeccEKz8703Og6BibwXX3wxvvrVr8bcuXOja9eu7V3OLq+txuOiiy7KPz/ooIOiS5cu8aUvfSmmT58eZWVlbVHqTq+Ysairq4sJEybEAQccEJdffvn2KXAX01bjcemll+afjxgxItauXRvXXHNN/h+GbFlLx+L000+PY489Nl555ZWYOXNmnHLKKfGnP/3J35o21FZj4X3RNrY0HnfffXfcf//98fjjj7dDdRTLV/LIe+yxx+K1116LQw45JEpLS6O0tDT++7//O374wx9GaWlp1NfXb7GPysrKeO211wqmbdq0Kd5888386ebKysomd1557/WW2jSe33i55trs6NpiPJozatSo2LRpUyxbtiwijEdLtHQs3nrrrTjuuOOiR48ecdddd0Xnzp3zfWzNfi4vL49u3brFnnvuGZ06ddriWGzYsKHJHRN3lrGIaJvxaM6oUaPipZdeivXr10eE8WiJlo5FRUVF7LPPPnHUUUfFf/zHf8Szzz4bd911V0R4b7SVthiL5nhftM6WxmPu3Lnx/PPPR8+ePfPzIyJOOumkOProoyPCe6MjEZjIO+aYY2LRokVRXV2dfxx66KFx+umnR3V1dXTq1GmLfYwePTpqa2vjsccey0+7//77o6GhIUaNGpVv84c//CE2btyYbzN37tzYd999o1evXvk28+fPL+h77ty5MXr06IiIGDJkSFRWVha0qauri4cffjjfZkfXFuPRnOrq6igpKcl/ddJ4bFlLxqKuri4+8YlPRJcuXeLuu+9u8j+Ko0ePjkWLFhX8h8LcuXOjvLw8DjjggHybze3nLl26xMiRIwvaNDQ0xPz58/NtRo4cGZ07dy5os2TJklixYsVOMRYRbTMezamuro5evXrlz7wajy1rzedU9u4Np/L/APfeaBttMRbN8b5onS2Nx7/8y7/Ek08+WTA/IuLaa6+NWbNmRYT3RofSnnecoOP74B1dXnnllezxxx/PfvrTn2YRkf3hD3/IHn/88ezvf/97vs1xxx2XjRgxInv44YezP/7xj9k+++xTcFvx2trarF+/ftkZZ5yRPfXUU9kdd9yR7bbbbk1uY11aWprNnDkze+aZZ7LLLrus2dtY9+zZM/vNb36TPfnkk9kJJ5ywU97GurFix2PBggXZtddem1VXV2fPP/98dtttt2V9+vTJJk6cmO/DeLRO47FYvXp1NmrUqOzAAw/Mli5dWnA73g/eOvkTn/hEVl1dnd17771Znz59mr097D/90z9lzzzzTHbDDTc0e3vYsrKy7NZbb82efvrp7Oyzz8569uxZcBelL3/5y9nee++d3X///dlf/vKXbPTo0dno0aO3z45pJ8WOx91335399Kc/zRYtWpQ999xz2Y9//ONst912y771rW/l+zQerdN4LJ5//vnsu9/9bvaXv/wlW758efanP/0p+9SnPpX17t07f0tj741tp9ix8L7YtrZ018JI3Fbce6P9CUxs1gff3JdddlkWEU0es2bNyrf5+9//np122mnZ7rvvnpWXl2dnnnlm9tZbbxX0+8QTT2RHHHFEVlZWlg0cODCbMWNGk3X/6le/yj784Q9nXbp0yf7hH/4h+6//+q+C+Q0NDdmll16a9evXLysrK8uOOeaYbMmSJW26/R1NsePx2GOPZaNGjcoqKiqyrl27Zvvvv3/23e9+N3vnnXcK+jUexWs8Fu/d1r25xwsvvJBfZtmyZdnxxx+fdevWLdtzzz2zr33tawW3uX6vr+HDh2ddunTJPvShDxW8t95z/fXXZ3vvvXfWpUuX7LDDDsv+/Oc/F8x/++23s6985StZr169st122y37zGc+k73yyittvQs6lGLH43e/+102fPjwbPfdd8+6d++eHXzwwdlPfvKTrL6+vqBf41G8xmPx8ssvZ8cff3zWt2/frHPnztlee+2VfeELX8ieffbZgmW8N7aNYsfC+2LbKjYwZZn3RkeRy7JG94oEAAAgzzVMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAklLZ3AdvTO++8Exs2bGjvMgAAgHbWpUuX6Nq16xbb7TKB6Z133omKbr1iQ7zT3qUAAADtrLKyMl544YUthqZdJjBt2LAhNsQ7cUR8Mkqjc0Tu/W8j5kpy0ehFYnqj54npuZKSRPsPfPMxl1i+0bpT60j2W9Amsa5kny1YbxS3L7KCNol6Es9btuz7T7MWbHuL2qTWFRFZap+m6ihJTC9on6ij8YobtylpvD3Nt0n22VbtSxLTU/unsWT7rZnegn37gXltVkei/+Sy26CetmqTXDbaqE2xtTVplzXfbiv2RUGfkZDsM2u2TUvWVWyfuWLXG6l+mt/KXJHrzRU8T9S2mXUXflQ031fhn5jUuptfNtW+JFpSQ6P2LZhe0GeqTQueF37MF9lPpNo0JNaVWvb99hERnZLraNxvo/YF+6L5dRf2mWiTmt6oz8bb0KlgXe8/79RoWwqnJ7alBfUUrCtVQ+N+GtVQuF0NzU5P7Z90/4XvuU6p7UzU2ilx/BbUlDi+Gk8vbPN+PQXHTUGdjZ43OvoL2zSevuXnhe1LEm2aTq97qyEGjVwWGzZsEJg+qDQ6R2nuA4EpER5S01sUeFLLfnBeSWL5rQpMyb88W66vJevtEIGpuPY7VGBK/UNoBwxMbReMUtNbsG8/MG9b1LHTBqaWtIkWtCm2hibLb+PAlNienTYwtWh68+tNh5ytDUzFBaCtCkwtab8dA1M69LR9YGpJ+4iWBqbUP5q3bWBKhpUWBKP09LYPTJ0K+nn/oCtpdAA2nl64fxpPb75908DUuF0qfEXzbQpqbUmbLQemTtsgMBW2b34ftSwwFX8LBzd9AAAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABJK27uA7W1TbIzIIhpnxVyWa9QiNb3R88T0XFbS7PTIPphLG81raLR8LrF8LvG8cd4taBPNT0/22YL1pqZnzU/PCtok6kk8b9myjUtovD+bb5+1YP8UDl/jRh8c8hbUUZKYnjyMGtXReMUFw914e5pvk+yzrdqnDvHkMdeS9lszvQX79gPz2qyORP/JZbdBPW3VJrlstFGbYmtr0i5rvt1W7IuCPiMh2WfWbJuWrKvYPnPFrjdS/TS/lbki15sreJ6obTPrLvyoaL6vwj8xqXU3v2yqfRbN19CQaF/Sgukl0YI2LXhe+DFfZD+RatPQ7PRcpJZt/MczolNyHY37bdS+YF80v+7CPhNtUtMb9dl4GzoVrOv9550abUvh9MS2tKCegnWlamjcT6MaCrerodnpqf2T7r/wPdcptZ2JWjsljt+CmhLHV+PphW3er6fguCmos9HzRkd/YZvG07f8vLB9JNo0ra3urcLjfnN2mcDUpUuXqKysjD/W/PbdCY2Ps/p2KQkAAGgnlZWV0aVLly22y2VZlvzPtZ3NO++8Exs2bGjvMthG6urqoqqqKl588cUoLy9v73IgybHKjsTxyo7E8UoxunTpEl27dt1iu13mDFNERNeuXVu0U9ixlZeX+5Bkh+BYZUfieGVH4nilLbnpAwAAQILABAAAkCAwsdMoKyuLyy67LMrKytq7FNgsxyo7EscrOxLHK9vCLnXTBwAAgGI4wwQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwscO44YYbYvDgwdG1a9cYNWpUPPLII8m2ixcvjpNOOikGDx4cuVwurrvuuu1XKERxx+tPf/rTOPLII6NXr17Rq1evGDdu3GbbQ1sr5nidPXt2HHroodGzZ8/o3r17DB8+PH7+859vx2rZ1RVzvDZ2xx13RC6XixNPPHHbFshOR2Bih/DLX/4yLrroorjsssvir3/9axx88MExfvz4eO2115ptv27duvjQhz4UM2bMiMrKyu1cLbu6Yo/XBx98ME477bR44IEHYuHChVFVVRWf+MQn4uWXX97OlbMrKvZ47d27d/zLv/xLLFy4MJ588sk488wz48wzz4z77rtvO1fOrqjY4/U9y5Yti69//etx5JFHbqdK2Zn4HSZ2CKNGjYr/9b/+V/zoRz+KiIiGhoaoqqqK8847L/75n/95s8sOHjw4Lrjggrjgggu2Q6WwdcdrRER9fX306tUrfvSjH8XEiRO3dbns4rb2eI2IOOSQQ2LChAlx1VVXbctSoVXHa319fRx11FExZcqUeOihh6K2tjbmzJmzHatmR+cMEx3ehg0b4rHHHotx48blp5WUlMS4ceNi4cKF7VgZNNUWx+u6deti48aN0bt3721VJkTE1h+vWZbF/PnzY8mSJXHUUUdty1Kh1cfrlVdeGX379o0vfvGL26NMdkKl7V0AbMkbb7wR9fX10a9fv4Lp/fr1i2effbadqoLmtcXxevHFF8eAAQMK/lEA20Jrj9fVq1fHwIEDY/369dGpU6f48Y9/HMcee+y2LpddXGuO1z/+8Y9x8803R3V19XaokJ2VwATQgcyYMSPuuOOOePDBB6Nr167tXQ40q0ePHlFdXR1r1qyJ+fPnx0UXXRQf+tCH4uijj27v0iDvrbfeijPOOCN++tOfxp577tne5bADE5jo8Pbcc8/o1KlTvPrqqwXTX331VTd0oMPZmuN15syZMWPGjJg3b14cdNBB27JMiIjWH68lJSUxbNiwiIgYPnx4PPPMMzF9+nSBiW2q2OP1+eefj2XLlsWnPvWp/LSGhoaIiCgtLY0lS5bE0KFDt23R7BRcw0SH16VLlxg5cmTMnz8/P62hoSHmz58fo0ePbsfKoKnWHq9XX311XHXVVXHvvffGoYceuj1KhTb7fG1oaIj169dvixIhr9jjdb/99otFixZFdXV1/vHpT386Pvaxj0V1dXVUVVVtz/LZgTnDxA7hoosuikmTJsWhhx4ahx12WFx33XWxdu3aOPPMMyMiYuLEiTFw4MCYPn16RLx7YejTTz+df/7yyy9HdXV17L777vn/FYVtpdjj9Xvf+15861vfittvvz0GDx4cNTU1ERGx++67x+67795u28Guodjjdfr06XHooYfG0KFDY/369fHb3/42fv7zn8eNN97YnpvBLqKY47Vr167xkY98pGD5nj17RkQ0mQ6bIzCxQ/j85z8fr7/+enzrW9+KmpqaGD58eNx77735Cz9XrFgRJSXvnzBduXJljBgxIv965syZMXPmzBg7dmw8+OCD27t8djHFHq833nhjbNiwIT73uc8V9HPZZZfF5Zdfvj1LZxdU7PG6du3a+MpXvhIvvfRSdOvWLfbbb7+47bbb4vOf/3x7bQK7kGKPV2gLfocJAAAgQQQHAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACAhP8Hp3jT1BKJ/AkAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -729,7 +729,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From bab009e8bff4a06612247ffcdd68eed21e8f120a Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Wed, 27 Sep 2023 12:52:14 +0300 Subject: [PATCH 17/31] Fixed generalized weights calculations --- eis_toolkit/prediction/wofe_new.py | 122 +++++++++------------------ notebooks/wofe_new.ipynb | 128 ++++++++++++++--------------- 2 files changed, 105 insertions(+), 145 deletions(-) diff --git a/eis_toolkit/prediction/wofe_new.py b/eis_toolkit/prediction/wofe_new.py index 5476b0cf..a0e75f71 100644 --- a/eis_toolkit/prediction/wofe_new.py +++ b/eis_toolkit/prediction/wofe_new.py @@ -23,7 +23,7 @@ def read_and_preprocess_evidence(raster: rasterio.io.DatasetReader, nodata: Opti return array -def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray, laplace_smoothing: bool): +def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray): """Calculate weights/metrics for given data.""" A = np.sum(np.logical_and(deposits == 1, evidence == 1)) B = np.sum(np.logical_and(deposits == 1, evidence == 0)) @@ -69,37 +69,23 @@ def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray, lapl return A, B, C, D, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast, studentized_contrast -def unique_weights(deposits: np.ndarray, evidence: np.ndarray, laplace_smoothing: bool) -> dict: +def unique_weights(deposits: np.ndarray, evidence: np.ndarray) -> dict: """Calculate unique weights for each class.""" classes = np.unique(evidence) - return {cls: calculate_metrics_for_class(deposits, evidence == cls, laplace_smoothing) for cls in classes} + return {cls: calculate_metrics_for_class(deposits, evidence == cls) for cls in classes} -def cumulative_weights( - deposits: np.ndarray, evidence: np.ndarray, laplace_smoothing: bool, ascending: bool = True -) -> dict: +def cumulative_weights(deposits: np.ndarray, evidence: np.ndarray, ascending: bool = True) -> dict: """Calculate cumulative weights (ascending or descending) for each class.""" classes = sorted(np.unique(evidence), reverse=not ascending) cumulative_classes = [classes[: i + 1] for i in range(len(classes))] return { - cls[i]: calculate_metrics_for_class(deposits, np.isin(evidence, cls), laplace_smoothing) + cls[i]: calculate_metrics_for_class(deposits, np.isin(evidence, cls)) for i, cls in enumerate(cumulative_classes) } def reclassify_by_studentized_contrast(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: - """Create generalized classes based on the studentized contrast threhsold value.""" - df["Generalized class"] = np.where(df["Studentized contrast"] >= studentized_contrast_threshold, 2, 1) - - # Check if both classes are present - unique_classes = df["Generalized class"].unique() - if 1 not in unique_classes: - raise ValueError("Reclassification failed: 'Unfavorable' class (Class 1) doesn't exist.") - elif 2 not in unique_classes: - raise ValueError("Reclassification failed: 'Favorable' class (Class 2) doesn't exist.") - - -def reclassify_by_studentized_contrast3(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: """Create generalized classes based on the studentized contrast threhsold value.""" index = df.idxmax()["Contrast"] @@ -110,33 +96,10 @@ def reclassify_by_studentized_contrast3(df: pd.DataFrame, studentized_contrast_t for i in range(0, index + 1): df.loc[i, "Generalized class"] = 2 - # df["Generalized class"] = np.where(df["Studentized contrast"] >= studentized_contrast_threshold, 2, 1) - # # Check if both classes are present - # unique_classes = df["Generalized class"].unique() - # if 1 not in unique_classes: - # raise ValueError("Reclassification failed: 'Unfavorable' class (Class 1) doesn't exist.") - # elif 2 not in unique_classes: - # raise ValueError("Reclassification failed: 'Favorable' class (Class 2) doesn't exist.") - - -def reclassify_by_studentized_contrast2(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: - """Create generalized classes based on the studentized contrast threshold value.""" - - # Sort the DataFrame based on the 'Contrast' value - df.sort_values(by="Contrast", ascending=False, inplace=True) - - # Initialize a flag to check if we have reached the highest contrast class that meets the threshold - highest_contrast_reached = False - - for idx, row in df.iterrows(): - if row["Studentized contrast"] >= studentized_contrast_threshold and not highest_contrast_reached: - df.at[idx, "Generalized class"] = 2 - highest_contrast_reached = True - elif highest_contrast_reached: - df.at[idx, "Generalized class"] = 2 - else: - df.at[idx, "Generalized class"] = 1 +def reclassify_by_studentized_contrast_alternative(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: + """Create generalized classes based on the studentized contrast threhsold value.""" + df["Generalized class"] = np.where(df["Studentized contrast"] >= studentized_contrast_threshold, 2, 1) # Check if both classes are present unique_classes = df["Generalized class"].unique() @@ -146,52 +109,56 @@ def reclassify_by_studentized_contrast2(df: pd.DataFrame, studentized_contrast_t raise ValueError("Reclassification failed: 'Favorable' class (Class 2) doesn't exist.") -def calculate_generalized_weights(weights_df: pd.DataFrame) -> None: +def calculate_generalized_weights(df: pd.DataFrame, deposits) -> None: """ Calculate generalized weights. - Implementation for generalized weights that uses a DIFFERENT logic than the original implementation. + Implementation for generalized weights that uses the SAME logic than the original implementation. """ - generalized_weights = [] - generalized_s_weights = [] + total_deposits = np.sum(deposits == 1) + total_no_deposits = deposits.size - total_deposits - for gen_cls in weights_df["Generalized class"].tolist(): - subset_df = weights_df[weights_df["Generalized class"] == gen_cls] + # Class 2 + class_2_max_index = df.idxmax()["Contrast"] + class_2_count = df.loc[class_2_max_index, "Count"] + class_2_point_count = df.loc[class_2_max_index, "Point Count"] - weighted_w_plus_sum = sum(subset_df["WPlus"] * subset_df["Count"]) - total_count = subset_df["Count"].sum() + class_2_w_gen = np.log(class_2_point_count / total_deposits) - np.log( + (class_2_count - class_2_point_count) / total_no_deposits + ) + clas_2_s_wpls_gen = np.sqrt((1 / class_2_point_count) + (1 / (class_2_count - class_2_point_count))) - generalized_weights.append(round(weighted_w_plus_sum / total_count, 4) if total_count else 0) + df["Generalized WPlus"] = round(class_2_w_gen, 4) + df["Generalized S_WPlus"] = round(clas_2_s_wpls_gen, 4) - weights_df["Generalized WPlus"] = generalized_weights - weights_df["Generalized S_WPlus"] = generalized_s_weights + # Class 1 + class_1_count = df.loc[len(df.index) - 1, "Count"] - class_2_count + class_1_point_count = df.loc[len(df.index) - 1, "Point Count"] - class_2_point_count + + class_1_w_gen = np.log(class_1_point_count / total_deposits) - np.log( + (class_1_count - class_1_point_count) / total_no_deposits + ) + clas_1_s_wpls_gen = np.sqrt((1 / class_1_point_count) + (1 / (class_1_count - class_1_point_count))) + df.loc[df["Generalized class"] == 1, "Generalized WPlus"] = round(class_1_w_gen, 4) + df.loc[df["Generalized class"] == 1, "Generalized S_WPlus"] = round(clas_1_s_wpls_gen, 4) -def calculate_generalized_weights_alternative(weights_df: pd.DataFrame, deposits) -> None: +def calculate_generalized_weights_alternative(weights_df: pd.DataFrame) -> None: """ Calculate generalized weights. - Implementation for generalized weights that uses the SAME logic as the original implementation. + Implementation for generalized weights that uses a DIFFERENT logic than the original implementation. """ - total_deposits = np.sum(deposits == 1) - total_no_deposits = deposits.size - total_deposits - generalized_weights = [] generalized_s_weights = [] for gen_cls in weights_df["Generalized class"].tolist(): subset_df = weights_df[weights_df["Generalized class"] == gen_cls] - cumulative_deposit_count = subset_df["Point Count"].sum() - cumulative_no_deposit_count = subset_df["Count"].sum() - cumulative_deposit_count - - W_Gen = np.log(cumulative_deposit_count / total_deposits) - np.log( - cumulative_no_deposit_count / total_no_deposits - ) - s_wpls_gen = np.sqrt((1 / cumulative_deposit_count) + (1 / cumulative_no_deposit_count)) + weighted_w_plus_sum = sum(subset_df["WPlus"] * subset_df["Count"]) + total_count = subset_df["Count"].sum() - generalized_weights.append(round(W_Gen, 4)) - generalized_s_weights.append(round(s_wpls_gen, 4)) + generalized_weights.append(round(weighted_w_plus_sum / total_count, 4) if total_count else 0) weights_df["Generalized WPlus"] = generalized_weights weights_df["Generalized S_WPlus"] = generalized_s_weights @@ -218,7 +185,6 @@ def weights_of_evidence( resolution: Optional[float] = None, weights_type: Literal["unique", "ascending", "descending"] = "unique", studentized_contrast_threshold: Number = 2, - laplace_smoothing: bool = False, rasters_to_generate: Union[Sequence[str], str, None] = None, ) -> Tuple[pd.DataFrame, dict, dict]: """ @@ -234,8 +200,6 @@ def weights_of_evidence( studentized_contrast_threshold: Studentized contrast threshold value used to reclassify all classes. Reclassification is used when creating generalized rasters with cumulative weight type selection. Not needed if weights_type is 'unique'. Defaults to 2. - laplace_smoothing: If smoothing is applied in logarithmic calculations. If no smoothing is applied, - the problematic cases result into weight value of 0 for the class. Defaults to False. rasters_to_generate: Rasters to generate from the computed weight metrics. All column names in the produced weights_df are valid choices. If None, defaults to ["Class", "WPlus", "S_WPlus"] for "unique" weights_type or ["Class", "WPlus", "S_WPlus", "Generalized WPlus", "Generalized S_WPlus"] @@ -272,15 +236,11 @@ def weights_of_evidence( # 2. WofE calculations if weights_type == "unique": - wofe_weights = unique_weights(masked_deposit_array, masked_evidence_array, laplace_smoothing) + wofe_weights = unique_weights(masked_deposit_array, masked_evidence_array) elif weights_type == "ascending": - wofe_weights = cumulative_weights( - masked_deposit_array, masked_evidence_array, laplace_smoothing, ascending=True - ) + wofe_weights = cumulative_weights(masked_deposit_array, masked_evidence_array, ascending=True) elif weights_type == "descending": - wofe_weights = cumulative_weights( - masked_deposit_array, masked_evidence_array, laplace_smoothing, ascending=False - ) + wofe_weights = cumulative_weights(masked_deposit_array, masked_evidence_array, ascending=False) # 3. Create dataframe based on calculated metrics df_entries = [] @@ -307,7 +267,7 @@ def weights_of_evidence( if weights_type != "unique": reclassify_by_studentized_contrast(weights_df, studentized_contrast_threshold) # calculate_generalized_weights(weights_df) - calculate_generalized_weights_alternative(weights_df, masked_deposit_array) + calculate_generalized_weights(weights_df, masked_deposit_array) metrics_to_rasters = rasters_to_generate if metrics_to_rasters is None: diff --git a/notebooks/wofe_new.ipynb b/notebooks/wofe_new.ipynb index 8d420d9d..e189d212 100644 --- a/notebooks/wofe_new.ipynb +++ b/notebooks/wofe_new.ipynb @@ -267,8 +267,8 @@ " 0.5096\n", " 1.7275\n", " 2\n", - " 0.4605\n", - " 0.2396\n", + " 0.4810\n", + " 0.3389\n", " \n", " \n", " 1\n", @@ -282,9 +282,9 @@ " 0.8176\n", " 0.5095\n", " 1.6046\n", - " 2\n", - " 0.4605\n", - " 0.2396\n", + " 1\n", + " -0.3994\n", + " 0.3806\n", " \n", " \n", " 2\n", @@ -299,8 +299,8 @@ " 0.7637\n", " 0.0214\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " -0.3994\n", + " 0.3806\n", " \n", " \n", " 3\n", @@ -315,8 +315,8 @@ " 1.0422\n", " 0.1440\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " -0.3994\n", + " 0.3806\n", " \n", " \n", " 4\n", @@ -331,8 +331,8 @@ " 1.0424\n", " 0.1251\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " -0.3994\n", + " 0.3806\n", " \n", " \n", " 5\n", @@ -347,8 +347,8 @@ " 1.0765\n", " -1.4114\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " -0.3994\n", + " 0.3806\n", " \n", " \n", " 6\n", @@ -363,8 +363,8 @@ " 1.0854\n", " -1.4791\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " -0.3994\n", + " 0.3806\n", " \n", " \n", " 7\n", @@ -379,8 +379,8 @@ " 1.4450\n", " -2.7196\n", " 1\n", - " -0.0028\n", - " 0.1059\n", + " -0.3994\n", + " 0.3806\n", " \n", " \n", "\n", @@ -398,24 +398,24 @@ "7 13.0 781 16 -0.0626 0.2606 3.8673 1.4213 -3.9299 \n", "\n", " S_Contrast Studentized contrast Generalized class Generalized WPlus \\\n", - "0 0.5096 1.7275 2 0.4605 \n", - "1 0.5095 1.6046 2 0.4605 \n", - "2 0.7637 0.0214 1 -0.0028 \n", - "3 1.0422 0.1440 1 -0.0028 \n", - "4 1.0424 0.1251 1 -0.0028 \n", - "5 1.0765 -1.4114 1 -0.0028 \n", - "6 1.0854 -1.4791 1 -0.0028 \n", - "7 1.4450 -2.7196 1 -0.0028 \n", + "0 0.5096 1.7275 2 0.4810 \n", + "1 0.5095 1.6046 1 -0.3994 \n", + "2 0.7637 0.0214 1 -0.3994 \n", + "3 1.0422 0.1440 1 -0.3994 \n", + "4 1.0424 0.1251 1 -0.3994 \n", + "5 1.0765 -1.4114 1 -0.3994 \n", + "6 1.0854 -1.4791 1 -0.3994 \n", + "7 1.4450 -2.7196 1 -0.3994 \n", "\n", " Generalized S_WPlus \n", - "0 0.2396 \n", - "1 0.2396 \n", - "2 0.1059 \n", - "3 0.1059 \n", - "4 0.1059 \n", - "5 0.1059 \n", - "6 0.1059 \n", - "7 0.1059 " + "0 0.3389 \n", + "1 0.3806 \n", + "2 0.3806 \n", + "3 0.3806 \n", + "4 0.3806 \n", + "5 0.3806 \n", + "6 0.3806 \n", + "7 0.3806 " ] }, "execution_count": 4, @@ -482,9 +482,9 @@ " 0.0000\n", " 0.0000\n", " 0.0000\n", - " 1\n", - " -0.1911\n", - " 0.1730\n", + " 2\n", + " 1.4694\n", + " 1.0445\n", " \n", " \n", " 1\n", @@ -515,8 +515,8 @@ " 1.0424\n", " -0.1251\n", " 1\n", - " -0.1911\n", - " 0.1730\n", + " -0.0501\n", + " 0.2608\n", " \n", " \n", " 3\n", @@ -531,8 +531,8 @@ " 1.0422\n", " -0.1440\n", " 1\n", - " -0.1911\n", - " 0.1730\n", + " -0.0501\n", + " 0.2608\n", " \n", " \n", " 4\n", @@ -547,8 +547,8 @@ " 0.7637\n", " -0.0214\n", " 1\n", - " -0.1911\n", - " 0.1730\n", + " -0.0501\n", + " 0.2608\n", " \n", " \n", " 5\n", @@ -563,8 +563,8 @@ " 0.5095\n", " -1.6046\n", " 1\n", - " -0.1911\n", - " 0.1730\n", + " -0.0501\n", + " 0.2608\n", " \n", " \n", " 6\n", @@ -579,8 +579,8 @@ " 0.5096\n", " -1.7275\n", " 1\n", - " -0.1911\n", - " 0.1730\n", + " -0.0501\n", + " 0.2608\n", " \n", " \n", " 7\n", @@ -595,8 +595,8 @@ " 1.4450\n", " -2.7196\n", " 1\n", - " -0.1911\n", - " 0.1730\n", + " -0.0501\n", + " 0.2608\n", " \n", " \n", "\n", @@ -614,24 +614,24 @@ "7 1.0 781 16 -0.0626 0.2606 3.8673 1.4213 -3.9299 \n", "\n", " S_Contrast Studentized contrast Generalized class Generalized WPlus \\\n", - "0 0.0000 0.0000 1 -0.1911 \n", + "0 0.0000 0.0000 2 1.4694 \n", "1 1.0765 1.4114 2 1.4694 \n", - "2 1.0424 -0.1251 1 -0.1911 \n", - "3 1.0422 -0.1440 1 -0.1911 \n", - "4 0.7637 -0.0214 1 -0.1911 \n", - "5 0.5095 -1.6046 1 -0.1911 \n", - "6 0.5096 -1.7275 1 -0.1911 \n", - "7 1.4450 -2.7196 1 -0.1911 \n", + "2 1.0424 -0.1251 1 -0.0501 \n", + "3 1.0422 -0.1440 1 -0.0501 \n", + "4 0.7637 -0.0214 1 -0.0501 \n", + "5 0.5095 -1.6046 1 -0.0501 \n", + "6 0.5096 -1.7275 1 -0.0501 \n", + "7 1.4450 -2.7196 1 -0.0501 \n", "\n", " Generalized S_WPlus \n", - "0 0.1730 \n", + "0 1.0445 \n", "1 1.0445 \n", - "2 0.1730 \n", - "3 0.1730 \n", - "4 0.1730 \n", - "5 0.1730 \n", - "6 0.1730 \n", - "7 0.1730 " + "2 0.2608 \n", + "3 0.2608 \n", + "4 0.2608 \n", + "5 0.2608 \n", + "6 0.2608 \n", + "7 0.2608 " ] }, "execution_count": 5, @@ -695,7 +695,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -729,7 +729,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 050f5bc3ec9a75b4fd2e037e085c3db5c0c1aed2 Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Thu, 28 Sep 2023 10:43:14 +0300 Subject: [PATCH 18/31] Modify colnames, remove resolution specification for now, added optional nodata parameter --- eis_toolkit/prediction/wofe_new.py | 69 +++++---- notebooks/wofe_new.ipynb | 218 ++++++++++++++--------------- 2 files changed, 141 insertions(+), 146 deletions(-) diff --git a/eis_toolkit/prediction/wofe_new.py b/eis_toolkit/prediction/wofe_new.py index a0e75f71..23c17b8a 100644 --- a/eis_toolkit/prediction/wofe_new.py +++ b/eis_toolkit/prediction/wofe_new.py @@ -1,18 +1,18 @@ from numbers import Number -from typing import List, Literal, Optional, Sequence, Tuple, Union import geopandas as gpd import numpy as np import pandas as pd import rasterio +from beartype import beartype +from beartype.typing import List, Literal, Optional, Sequence, Tuple, Union from eis_toolkit.vector_processing.rasterize_vector import rasterize_vector -# from beartype import beartype - def read_and_preprocess_evidence(raster: rasterio.io.DatasetReader, nodata: Optional[Number] = None) -> np.ndarray: """Read raster data and handle NoData values.""" + array = np.array(raster.read(1), dtype=np.float32) if nodata is not None: @@ -23,7 +23,7 @@ def read_and_preprocess_evidence(raster: rasterio.io.DatasetReader, nodata: Opti return array -def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray): +def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray) -> tuple: """Calculate weights/metrics for given data.""" A = np.sum(np.logical_and(deposits == 1, evidence == 1)) B = np.sum(np.logical_and(deposits == 1, evidence == 0)) @@ -120,27 +120,27 @@ def calculate_generalized_weights(df: pd.DataFrame, deposits) -> None: # Class 2 class_2_max_index = df.idxmax()["Contrast"] - class_2_count = df.loc[class_2_max_index, "Count"] - class_2_point_count = df.loc[class_2_max_index, "Point Count"] + class_2_count = df.loc[class_2_max_index, "Pixel count"] + class_2_point_count = df.loc[class_2_max_index, "Deposit count"] class_2_w_gen = np.log(class_2_point_count / total_deposits) - np.log( (class_2_count - class_2_point_count) / total_no_deposits ) clas_2_s_wpls_gen = np.sqrt((1 / class_2_point_count) + (1 / (class_2_count - class_2_point_count))) - df["Generalized WPlus"] = round(class_2_w_gen, 4) - df["Generalized S_WPlus"] = round(clas_2_s_wpls_gen, 4) + df["Generalized W+"] = round(class_2_w_gen, 4) + df["Generalized S_W+"] = round(clas_2_s_wpls_gen, 4) # Class 1 - class_1_count = df.loc[len(df.index) - 1, "Count"] - class_2_count - class_1_point_count = df.loc[len(df.index) - 1, "Point Count"] - class_2_point_count + class_1_count = df.loc[len(df.index) - 1, "Pixel count"] - class_2_count + class_1_point_count = df.loc[len(df.index) - 1, "Deposit count"] - class_2_point_count class_1_w_gen = np.log(class_1_point_count / total_deposits) - np.log( (class_1_count - class_1_point_count) / total_no_deposits ) clas_1_s_wpls_gen = np.sqrt((1 / class_1_point_count) + (1 / (class_1_count - class_1_point_count))) - df.loc[df["Generalized class"] == 1, "Generalized WPlus"] = round(class_1_w_gen, 4) - df.loc[df["Generalized class"] == 1, "Generalized S_WPlus"] = round(clas_1_s_wpls_gen, 4) + df.loc[df["Generalized class"] == 1, "Generalized W+"] = round(class_1_w_gen, 4) + df.loc[df["Generalized class"] == 1, "Generalized S_W+"] = round(clas_1_s_wpls_gen, 4) def calculate_generalized_weights_alternative(weights_df: pd.DataFrame) -> None: @@ -155,17 +155,17 @@ def calculate_generalized_weights_alternative(weights_df: pd.DataFrame) -> None: for gen_cls in weights_df["Generalized class"].tolist(): subset_df = weights_df[weights_df["Generalized class"] == gen_cls] - weighted_w_plus_sum = sum(subset_df["WPlus"] * subset_df["Count"]) - total_count = subset_df["Count"].sum() + weighted_w_plus_sum = sum(subset_df["WPlus"] * subset_df["Pixel count"]) + total_count = subset_df["Deposit count"].sum() generalized_weights.append(round(weighted_w_plus_sum / total_count, 4) if total_count else 0) - weights_df["Generalized WPlus"] = generalized_weights - weights_df["Generalized S_WPlus"] = generalized_s_weights + weights_df["Generalized W+"] = generalized_weights + weights_df["Generalized S_W+"] = generalized_s_weights def generate_rasters_from_metrics( - evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str] = ["Class", "WPlus", "S_WPlus"] + evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str] = ["Class", "W+", "S_W+"] ) -> dict: """Generate rasters for defined metrics based.""" raster_dict = {} @@ -178,11 +178,11 @@ def generate_rasters_from_metrics( return raster_dict -# @beartype +@beartype def weights_of_evidence( evidential_raster: rasterio.io.DatasetReader, deposits: gpd.GeoDataFrame, - resolution: Optional[float] = None, + raster_nodata: Optional[Number] = None, weights_type: Literal["unique", "ascending", "descending"] = "unique", studentized_contrast_threshold: Number = 2, rasters_to_generate: Union[Sequence[str], str, None] = None, @@ -193,16 +193,16 @@ def weights_of_evidence( Args: evidential_raster: The evidential raster. deposits: Vector data representing the mineral deposits or occurences point data. - resolution: The resolution i.e. cell size of the output raster. - Optional parameter, if not given, resolution of evidential raster is used. + raster_nodata: If nodata value of raster is wanted to specify manually. Optional parameter, defaults to None + (nodata from raster metadata is used). weights_type: Accepted values are 'unique' for unique weights, 'ascending' for cumulative ascending weights, 'descending' for cumulative descending weights. Defaults to 'unique'. studentized_contrast_threshold: Studentized contrast threshold value used to reclassify all classes. Reclassification is used when creating generalized rasters with cumulative weight type selection. Not needed if weights_type is 'unique'. Defaults to 2. rasters_to_generate: Rasters to generate from the computed weight metrics. All column names - in the produced weights_df are valid choices. If None, defaults to ["Class", "WPlus", "S_WPlus"] - for "unique" weights_type or ["Class", "WPlus", "S_WPlus", "Generalized WPlus", "Generalized S_WPlus"] + in the produced weights_df are valid choices. If None, defaults to ["Class", "W+", "S_W+] + for "unique" weights_type or ["Class", "W+", "S_W+", "Generalized W+", "Generalized S_W+"] for the cumulative weight types. Returns: @@ -214,7 +214,7 @@ def weights_of_evidence( # 1. Data preprocessing # Read evidence raster - evidence_array = read_and_preprocess_evidence(evidential_raster) + evidence_array = read_and_preprocess_evidence(evidential_raster, raster_nodata) # Extract raster metadata raster_meta = evidential_raster.meta @@ -224,11 +224,6 @@ def weights_of_evidence( geodataframe=deposits, default_value=1.0, base_raster_profile=raster_meta, fill_value=0.0 ) - # Resample - if resolution is not None: - # TODO - pass - # Mask NaN out of the array nodata_mask = np.isnan(evidence_array) masked_evidence_array = evidence_array[~nodata_mask] @@ -250,12 +245,12 @@ def weights_of_evidence( df_entries.append( { "Class": cls, - "Count": A + C, - "Point Count": A, - "WPlus": w_plus, - "S_WPlus": s_w_plus, - "WMinus": w_minus, - "S_WMinus": s_w_minus, + "Pixel count": A + C, + "Deposit count": A, + "W+": w_plus, + "S_W+": s_w_plus, + "W-": w_minus, + "S_W-": s_w_minus, "Contrast": contrast, "S_Contrast": s_contrast, "Studentized contrast": studentized_contrast, @@ -271,9 +266,9 @@ def weights_of_evidence( metrics_to_rasters = rasters_to_generate if metrics_to_rasters is None: - metrics_to_rasters = ["Class", "WPlus", "S_WPlus"] + metrics_to_rasters = ["Class", "W+", "S_W+"] if weights_type != "unique": - metrics_to_rasters += ["Generalized WPlus", "Generalized S_WPlus"] + metrics_to_rasters += ["Generalized W+", "Generalized S_W+"] # 5. After the wofe_weights computation in the weights_of_evidence function raster_dict = generate_rasters_from_metrics(evidence_array, weights_df, metrics_to_rasters) diff --git a/notebooks/wofe_new.ipynb b/notebooks/wofe_new.ipynb index e189d212..37297743 100644 --- a/notebooks/wofe_new.ipynb +++ b/notebooks/wofe_new.ipynb @@ -60,12 +60,12 @@ " \n", " \n", " Class\n", - " Count\n", - " Point Count\n", - " WPlus\n", - " S_WPlus\n", - " WMinus\n", - " S_WMinus\n", + " Pixel count\n", + " Deposit count\n", + " W+\n", + " S_W+\n", + " W-\n", + " S_W-\n", " Contrast\n", " S_Contrast\n", " Studentized contrast\n", @@ -181,25 +181,25 @@ "" ], "text/plain": [ - " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", - "0 1.0 275 9 0.4810 0.3389 -0.3994 0.3806 0.8804 \n", - "1 2.0 11 0 0.0000 0.0000 0.0000 0.0000 0.0000 \n", - "2 3.0 396 5 -0.4920 0.4501 0.3409 0.3059 -0.8329 \n", - "3 5.0 43 1 0.1296 1.0118 -0.0081 0.2609 0.1377 \n", - "4 6.0 1 0 0.0000 0.0000 0.0000 0.0000 0.0000 \n", - "5 8.0 43 0 0.0000 0.0000 0.0000 0.0000 0.0000 \n", - "6 10.0 2 1 3.8673 1.4142 -0.0632 0.2607 3.9305 \n", - "7 13.0 10 0 0.0000 0.0000 0.0000 0.0000 0.0000 \n", + " Class Pixel count Deposit count W+ S_W+ W- S_W- \\\n", + "0 1.0 275 9 0.4810 0.3389 -0.3994 0.3806 \n", + "1 2.0 11 0 0.0000 0.0000 0.0000 0.0000 \n", + "2 3.0 396 5 -0.4920 0.4501 0.3409 0.3059 \n", + "3 5.0 43 1 0.1296 1.0118 -0.0081 0.2609 \n", + "4 6.0 1 0 0.0000 0.0000 0.0000 0.0000 \n", + "5 8.0 43 0 0.0000 0.0000 0.0000 0.0000 \n", + "6 10.0 2 1 3.8673 1.4142 -0.0632 0.2607 \n", + "7 13.0 10 0 0.0000 0.0000 0.0000 0.0000 \n", "\n", - " S_Contrast Studentized contrast \n", - "0 0.5096 1.7275 \n", - "1 0.0000 0.0000 \n", - "2 0.5442 -1.5306 \n", - "3 1.0449 0.1318 \n", - "4 0.0000 0.0000 \n", - "5 0.0000 0.0000 \n", - "6 1.4380 2.7332 \n", - "7 0.0000 0.0000 " + " Contrast S_Contrast Studentized contrast \n", + "0 0.8804 0.5096 1.7275 \n", + "1 0.0000 0.0000 0.0000 \n", + "2 -0.8329 0.5442 -1.5306 \n", + "3 0.1377 1.0449 0.1318 \n", + "4 0.0000 0.0000 0.0000 \n", + "5 0.0000 0.0000 0.0000 \n", + "6 3.9305 1.4380 2.7332 \n", + "7 0.0000 0.0000 0.0000 " ] }, "execution_count": 3, @@ -239,18 +239,18 @@ " \n", " \n", " Class\n", - " Count\n", - " Point Count\n", - " WPlus\n", - " S_WPlus\n", - " WMinus\n", - " S_WMinus\n", + " Pixel count\n", + " Deposit count\n", + " W+\n", + " S_W+\n", + " W-\n", + " S_W-\n", " Contrast\n", " S_Contrast\n", " Studentized contrast\n", " Generalized class\n", - " Generalized WPlus\n", - " Generalized S_WPlus\n", + " Generalized W+\n", + " Generalized S_W+\n", " \n", " \n", " \n", @@ -387,35 +387,35 @@ "" ], "text/plain": [ - " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", - "0 1.0 275 9 0.4810 0.3389 -0.3994 0.3806 0.8804 \n", - "1 2.0 286 9 0.4405 0.3387 -0.3771 0.3807 0.8176 \n", - "2 3.0 682 14 0.0021 0.2700 -0.0143 0.7144 0.0163 \n", - "3 5.0 725 15 0.0101 0.2609 -0.1400 1.0090 0.1501 \n", - "4 6.0 726 15 0.0087 0.2609 -0.1217 1.0092 0.1304 \n", - "5 8.0 769 15 -0.0501 0.2608 1.4694 1.0445 -1.5194 \n", - "6 10.0 771 16 -0.0507 0.2607 1.5547 1.0536 -1.6054 \n", - "7 13.0 781 16 -0.0626 0.2606 3.8673 1.4213 -3.9299 \n", + " Class Pixel count Deposit count W+ S_W+ W- S_W- \\\n", + "0 1.0 275 9 0.4810 0.3389 -0.3994 0.3806 \n", + "1 2.0 286 9 0.4405 0.3387 -0.3771 0.3807 \n", + "2 3.0 682 14 0.0021 0.2700 -0.0143 0.7144 \n", + "3 5.0 725 15 0.0101 0.2609 -0.1400 1.0090 \n", + "4 6.0 726 15 0.0087 0.2609 -0.1217 1.0092 \n", + "5 8.0 769 15 -0.0501 0.2608 1.4694 1.0445 \n", + "6 10.0 771 16 -0.0507 0.2607 1.5547 1.0536 \n", + "7 13.0 781 16 -0.0626 0.2606 3.8673 1.4213 \n", "\n", - " S_Contrast Studentized contrast Generalized class Generalized WPlus \\\n", - "0 0.5096 1.7275 2 0.4810 \n", - "1 0.5095 1.6046 1 -0.3994 \n", - "2 0.7637 0.0214 1 -0.3994 \n", - "3 1.0422 0.1440 1 -0.3994 \n", - "4 1.0424 0.1251 1 -0.3994 \n", - "5 1.0765 -1.4114 1 -0.3994 \n", - "6 1.0854 -1.4791 1 -0.3994 \n", - "7 1.4450 -2.7196 1 -0.3994 \n", + " Contrast S_Contrast Studentized contrast Generalized class \\\n", + "0 0.8804 0.5096 1.7275 2 \n", + "1 0.8176 0.5095 1.6046 1 \n", + "2 0.0163 0.7637 0.0214 1 \n", + "3 0.1501 1.0422 0.1440 1 \n", + "4 0.1304 1.0424 0.1251 1 \n", + "5 -1.5194 1.0765 -1.4114 1 \n", + "6 -1.6054 1.0854 -1.4791 1 \n", + "7 -3.9299 1.4450 -2.7196 1 \n", "\n", - " Generalized S_WPlus \n", - "0 0.3389 \n", - "1 0.3806 \n", - "2 0.3806 \n", - "3 0.3806 \n", - "4 0.3806 \n", - "5 0.3806 \n", - "6 0.3806 \n", - "7 0.3806 " + " Generalized W+ Generalized S_W+ \n", + "0 0.4810 0.3389 \n", + "1 -0.3994 0.3806 \n", + "2 -0.3994 0.3806 \n", + "3 -0.3994 0.3806 \n", + "4 -0.3994 0.3806 \n", + "5 -0.3994 0.3806 \n", + "6 -0.3994 0.3806 \n", + "7 -0.3994 0.3806 " ] }, "execution_count": 4, @@ -455,18 +455,18 @@ " \n", " \n", " Class\n", - " Count\n", - " Point Count\n", - " WPlus\n", - " S_WPlus\n", - " WMinus\n", - " S_WMinus\n", + " Pixel count\n", + " Deposit count\n", + " W+\n", + " S_W+\n", + " W-\n", + " S_W-\n", " Contrast\n", " S_Contrast\n", " Studentized contrast\n", " Generalized class\n", - " Generalized WPlus\n", - " Generalized S_WPlus\n", + " Generalized W+\n", + " Generalized S_W+\n", " \n", " \n", " \n", @@ -603,35 +603,35 @@ "" ], "text/plain": [ - " Class Count Point Count WPlus S_WPlus WMinus S_WMinus Contrast \\\n", - "0 13.0 10 0 0.0000 0.0000 0.0000 0.0000 0.0000 \n", - "1 10.0 12 1 1.4694 1.0445 -0.0501 0.2608 1.5194 \n", - "2 8.0 55 1 -0.1217 1.0092 0.0087 0.2609 -0.1304 \n", - "3 6.0 56 1 -0.1400 1.0090 0.0101 0.2609 -0.1501 \n", - "4 5.0 99 2 -0.0143 0.7144 0.0021 0.2700 -0.0163 \n", - "5 3.0 495 7 -0.3771 0.3807 0.4405 0.3387 -0.8176 \n", - "6 2.0 506 7 -0.3994 0.3806 0.4810 0.3389 -0.8804 \n", - "7 1.0 781 16 -0.0626 0.2606 3.8673 1.4213 -3.9299 \n", + " Class Pixel count Deposit count W+ S_W+ W- S_W- \\\n", + "0 13.0 10 0 0.0000 0.0000 0.0000 0.0000 \n", + "1 10.0 12 1 1.4694 1.0445 -0.0501 0.2608 \n", + "2 8.0 55 1 -0.1217 1.0092 0.0087 0.2609 \n", + "3 6.0 56 1 -0.1400 1.0090 0.0101 0.2609 \n", + "4 5.0 99 2 -0.0143 0.7144 0.0021 0.2700 \n", + "5 3.0 495 7 -0.3771 0.3807 0.4405 0.3387 \n", + "6 2.0 506 7 -0.3994 0.3806 0.4810 0.3389 \n", + "7 1.0 781 16 -0.0626 0.2606 3.8673 1.4213 \n", "\n", - " S_Contrast Studentized contrast Generalized class Generalized WPlus \\\n", - "0 0.0000 0.0000 2 1.4694 \n", - "1 1.0765 1.4114 2 1.4694 \n", - "2 1.0424 -0.1251 1 -0.0501 \n", - "3 1.0422 -0.1440 1 -0.0501 \n", - "4 0.7637 -0.0214 1 -0.0501 \n", - "5 0.5095 -1.6046 1 -0.0501 \n", - "6 0.5096 -1.7275 1 -0.0501 \n", - "7 1.4450 -2.7196 1 -0.0501 \n", + " Contrast S_Contrast Studentized contrast Generalized class \\\n", + "0 0.0000 0.0000 0.0000 2 \n", + "1 1.5194 1.0765 1.4114 2 \n", + "2 -0.1304 1.0424 -0.1251 1 \n", + "3 -0.1501 1.0422 -0.1440 1 \n", + "4 -0.0163 0.7637 -0.0214 1 \n", + "5 -0.8176 0.5095 -1.6046 1 \n", + "6 -0.8804 0.5096 -1.7275 1 \n", + "7 -3.9299 1.4450 -2.7196 1 \n", "\n", - " Generalized S_WPlus \n", - "0 1.0445 \n", - "1 1.0445 \n", - "2 0.2608 \n", - "3 0.2608 \n", - "4 0.2608 \n", - "5 0.2608 \n", - "6 0.2608 \n", - "7 0.2608 " + " Generalized W+ Generalized S_W+ \n", + "0 1.4694 1.0445 \n", + "1 1.4694 1.0445 \n", + "2 -0.0501 0.2608 \n", + "3 -0.0501 0.2608 \n", + "4 -0.0501 0.2608 \n", + "5 -0.0501 0.2608 \n", + "6 -0.0501 0.2608 \n", + "7 -0.0501 0.2608 " ] }, "execution_count": 5, @@ -652,7 +652,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -661,7 +661,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -672,10 +672,10 @@ ], "source": [ "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Generalized weights\")\n", - "clrbar = ax.imshow(test_gen_un_[\"WPlus\"], cmap='terrain')\n", + "ax.set_title(\"Unique weights - W+\")\n", + "clrbar = ax.imshow(test_gen_un_[\"W+\"], cmap='terrain')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_un_[\"WPlus\"], ax = ax, transform = test_ev.transform, cmap='terrain')" + "show(test_gen_un_[\"W+\"], ax = ax, transform = test_ev.transform, cmap='terrain')" ] }, { @@ -686,7 +686,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -695,7 +695,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -706,10 +706,10 @@ ], "source": [ "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Generalized weights\")\n", - "clrbar = ax.imshow(test_gen_asc_[\"Generalized WPlus\"], cmap='viridis')\n", + "ax.set_title(\"Ascending weights - Generalized weights (W+)\")\n", + "clrbar = ax.imshow(test_gen_asc_[\"Generalized W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_asc_[\"Generalized WPlus\"], ax = ax, transform = test_ev.transform, cmap='viridis')" + "show(test_gen_asc_[\"Generalized W+\"], ax = ax, transform = test_ev.transform, cmap='viridis')" ] }, { @@ -720,7 +720,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 8, @@ -729,7 +729,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -740,10 +740,10 @@ ], "source": [ "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Generalized weights\")\n", - "clrbar = ax.imshow(test_gen_dsc_[\"Generalized WPlus\"], cmap='viridis')\n", + "ax.set_title(\"Descending weights - Generalized weighst (W+)\")\n", + "clrbar = ax.imshow(test_gen_dsc_[\"Generalized W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_dsc_[\"Generalized WPlus\"], ax = ax, transform = test_ev.transform, cmap='viridis')" + "show(test_gen_dsc_[\"Generalized W+\"], ax = ax, transform = test_ev.transform, cmap='viridis')" ] } ], From c4242289f2b0efc0bd03f3e84fb0e91840936128 Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Thu, 28 Sep 2023 10:50:43 +0300 Subject: [PATCH 19/31] Deleted old files, renamed new versions, changed some functions to private, added doc file --- docs/prediction/weights_of_evidence.md | 3 + .../{wofe_new.py => weights_of_evidence.py} | 36 +- .../weights_of_evidence/basic_calculations.py | 63 -- .../calculate_responses.py | 40 - .../weights_of_evidence/calculate_weights.py | 67 -- .../generalized_weights.py | 28 - .../weights_of_evidence/post_probabilities.py | 94 -- .../weights_of_evidence/save_weights.py | 49 - .../prediction/weights_of_evidence/weights.py | 86 -- .../weights_of_evidence/weights_arrays.py | 80 -- .../weights_calculations.py | 78 -- .../weights_of_evidence/weights_cleanup.py | 67 -- .../weights_generalizations.py | 101 -- .../weights_of_evidence/weights_type.py | 74 -- eis_toolkit/prediction/wofe_new_old.py | 466 -------- notebooks/weights_of_evidence.ipynb | 1008 ++++++++++------- notebooks/wofe_new.ipynb | 772 ------------- tests/wofe_calculate_responses_test.py | 46 - tests/wofe_weights_calculations_test.py | 47 - 19 files changed, 623 insertions(+), 2582 deletions(-) create mode 100644 docs/prediction/weights_of_evidence.md rename eis_toolkit/prediction/{wofe_new.py => weights_of_evidence.py} (85%) delete mode 100644 eis_toolkit/prediction/weights_of_evidence/basic_calculations.py delete mode 100644 eis_toolkit/prediction/weights_of_evidence/calculate_responses.py delete mode 100644 eis_toolkit/prediction/weights_of_evidence/calculate_weights.py delete mode 100644 eis_toolkit/prediction/weights_of_evidence/generalized_weights.py delete mode 100644 eis_toolkit/prediction/weights_of_evidence/post_probabilities.py delete mode 100644 eis_toolkit/prediction/weights_of_evidence/save_weights.py delete mode 100644 eis_toolkit/prediction/weights_of_evidence/weights.py delete mode 100644 eis_toolkit/prediction/weights_of_evidence/weights_arrays.py delete mode 100644 eis_toolkit/prediction/weights_of_evidence/weights_calculations.py delete mode 100644 eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py delete mode 100644 eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py delete mode 100644 eis_toolkit/prediction/weights_of_evidence/weights_type.py delete mode 100644 eis_toolkit/prediction/wofe_new_old.py delete mode 100644 notebooks/wofe_new.ipynb delete mode 100644 tests/wofe_calculate_responses_test.py delete mode 100644 tests/wofe_weights_calculations_test.py diff --git a/docs/prediction/weights_of_evidence.md b/docs/prediction/weights_of_evidence.md new file mode 100644 index 00000000..e642df88 --- /dev/null +++ b/docs/prediction/weights_of_evidence.md @@ -0,0 +1,3 @@ +# Weights of evidence + +::: eis_toolkit.prediction.weights_of_evidence diff --git a/eis_toolkit/prediction/wofe_new.py b/eis_toolkit/prediction/weights_of_evidence.py similarity index 85% rename from eis_toolkit/prediction/wofe_new.py rename to eis_toolkit/prediction/weights_of_evidence.py index 23c17b8a..66a0143a 100644 --- a/eis_toolkit/prediction/wofe_new.py +++ b/eis_toolkit/prediction/weights_of_evidence.py @@ -10,7 +10,7 @@ from eis_toolkit.vector_processing.rasterize_vector import rasterize_vector -def read_and_preprocess_evidence(raster: rasterio.io.DatasetReader, nodata: Optional[Number] = None) -> np.ndarray: +def _read_and_preprocess_evidence(raster: rasterio.io.DatasetReader, nodata: Optional[Number] = None) -> np.ndarray: """Read raster data and handle NoData values.""" array = np.array(raster.read(1), dtype=np.float32) @@ -23,7 +23,7 @@ def read_and_preprocess_evidence(raster: rasterio.io.DatasetReader, nodata: Opti return array -def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray) -> tuple: +def _calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray) -> tuple: """Calculate weights/metrics for given data.""" A = np.sum(np.logical_and(deposits == 1, evidence == 1)) B = np.sum(np.logical_and(deposits == 1, evidence == 0)) @@ -69,23 +69,23 @@ def calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray) -> t return A, B, C, D, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast, studentized_contrast -def unique_weights(deposits: np.ndarray, evidence: np.ndarray) -> dict: +def _unique_weights(deposits: np.ndarray, evidence: np.ndarray) -> dict: """Calculate unique weights for each class.""" classes = np.unique(evidence) - return {cls: calculate_metrics_for_class(deposits, evidence == cls) for cls in classes} + return {cls: _calculate_metrics_for_class(deposits, evidence == cls) for cls in classes} -def cumulative_weights(deposits: np.ndarray, evidence: np.ndarray, ascending: bool = True) -> dict: +def _cumulative_weights(deposits: np.ndarray, evidence: np.ndarray, ascending: bool = True) -> dict: """Calculate cumulative weights (ascending or descending) for each class.""" classes = sorted(np.unique(evidence), reverse=not ascending) cumulative_classes = [classes[: i + 1] for i in range(len(classes))] return { - cls[i]: calculate_metrics_for_class(deposits, np.isin(evidence, cls)) + cls[i]: _calculate_metrics_for_class(deposits, np.isin(evidence, cls)) for i, cls in enumerate(cumulative_classes) } -def reclassify_by_studentized_contrast(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: +def _reclassify_by_studentized_contrast(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: """Create generalized classes based on the studentized contrast threhsold value.""" index = df.idxmax()["Contrast"] @@ -97,7 +97,7 @@ def reclassify_by_studentized_contrast(df: pd.DataFrame, studentized_contrast_th df.loc[i, "Generalized class"] = 2 -def reclassify_by_studentized_contrast_alternative(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: +def _reclassify_by_studentized_contrast_alternative(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: """Create generalized classes based on the studentized contrast threhsold value.""" df["Generalized class"] = np.where(df["Studentized contrast"] >= studentized_contrast_threshold, 2, 1) @@ -109,7 +109,7 @@ def reclassify_by_studentized_contrast_alternative(df: pd.DataFrame, studentized raise ValueError("Reclassification failed: 'Favorable' class (Class 2) doesn't exist.") -def calculate_generalized_weights(df: pd.DataFrame, deposits) -> None: +def _calculate_generalized_weights(df: pd.DataFrame, deposits) -> None: """ Calculate generalized weights. @@ -143,7 +143,7 @@ def calculate_generalized_weights(df: pd.DataFrame, deposits) -> None: df.loc[df["Generalized class"] == 1, "Generalized S_W+"] = round(clas_1_s_wpls_gen, 4) -def calculate_generalized_weights_alternative(weights_df: pd.DataFrame) -> None: +def _calculate_generalized_weights_alternative(weights_df: pd.DataFrame) -> None: """ Calculate generalized weights. @@ -164,7 +164,7 @@ def calculate_generalized_weights_alternative(weights_df: pd.DataFrame) -> None: weights_df["Generalized S_W+"] = generalized_s_weights -def generate_rasters_from_metrics( +def _generate_rasters_from_metrics( evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str] = ["Class", "W+", "S_W+"] ) -> dict: """Generate rasters for defined metrics based.""" @@ -214,7 +214,7 @@ def weights_of_evidence( # 1. Data preprocessing # Read evidence raster - evidence_array = read_and_preprocess_evidence(evidential_raster, raster_nodata) + evidence_array = _read_and_preprocess_evidence(evidential_raster, raster_nodata) # Extract raster metadata raster_meta = evidential_raster.meta @@ -231,11 +231,11 @@ def weights_of_evidence( # 2. WofE calculations if weights_type == "unique": - wofe_weights = unique_weights(masked_deposit_array, masked_evidence_array) + wofe_weights = _unique_weights(masked_deposit_array, masked_evidence_array) elif weights_type == "ascending": - wofe_weights = cumulative_weights(masked_deposit_array, masked_evidence_array, ascending=True) + wofe_weights = _cumulative_weights(masked_deposit_array, masked_evidence_array, ascending=True) elif weights_type == "descending": - wofe_weights = cumulative_weights(masked_deposit_array, masked_evidence_array, ascending=False) + wofe_weights = _cumulative_weights(masked_deposit_array, masked_evidence_array, ascending=False) # 3. Create dataframe based on calculated metrics df_entries = [] @@ -260,9 +260,9 @@ def weights_of_evidence( # 4. If we use cumulative weights type, reclassify and calculate generalized weights if weights_type != "unique": - reclassify_by_studentized_contrast(weights_df, studentized_contrast_threshold) + _reclassify_by_studentized_contrast(weights_df, studentized_contrast_threshold) # calculate_generalized_weights(weights_df) - calculate_generalized_weights(weights_df, masked_deposit_array) + _calculate_generalized_weights(weights_df, masked_deposit_array) metrics_to_rasters = rasters_to_generate if metrics_to_rasters is None: @@ -271,6 +271,6 @@ def weights_of_evidence( metrics_to_rasters += ["Generalized W+", "Generalized S_W+"] # 5. After the wofe_weights computation in the weights_of_evidence function - raster_dict = generate_rasters_from_metrics(evidence_array, weights_df, metrics_to_rasters) + raster_dict = _generate_rasters_from_metrics(evidence_array, weights_df, metrics_to_rasters) return weights_df, raster_dict, raster_meta diff --git a/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py b/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py deleted file mode 100644 index 411397d6..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/basic_calculations.py +++ /dev/null @@ -1,63 +0,0 @@ -"""Basic calculations""" - -import pandas as pd -import rasterio -import numpy as np - - -def _basic_calculations( - ev_rst: rasterio.io.DatasetReader, - dep_rst: rasterio.io.DatasetReader, - nan_val: float -) -> pd.DataFrame: - - geol, dep_ar = np.array(ev_rst.read(1)), np.array(dep_rst.read(1)) - tot_pxls = np.size(geol) - np.count_nonzero(geol <= nan_val) - dep1s, dep0s = np.count_nonzero(dep_ar == 1), np.count_nonzero(dep_ar == 0) - d_flat, g_flat = dep_ar.flatten(), geol.flatten() - df_flt = pd.DataFrame({"Clss": g_flat, "Ds": d_flat}) - Geol_Dep = df_flt.groupby("Clss")["Ds"] - Geol_Unq = np.unique(g_flat) - Geol_Cnt, Geol_Dep_Sum = Geol_Dep.count(), Geol_Dep.sum() - Geol_NoDep = Geol_Dep.count() - Geol_Dep.sum() - - calc_df = pd.DataFrame( - {"Class": Geol_Unq, "Count": Geol_Cnt, - "Point_Count": Geol_Dep_Sum, - "No_Dep_Cnt": Geol_NoDep, "Total_Area": tot_pxls, - "Total_Deposits": dep1s, "Tot_No_Dep_Cnt": dep0s - } - ) - - cols = ['Class', 'Count', 'Point_Count', 'No_Dep_Cnt', - 'Total_Area', 'Total_Deposits', 'Tot_No_Dep_Cnt'] - # replace_cols = ['Class', 'Count', 'Point_Count', 'No_Dep_Cnt', 'Total_Area', - # 'Total_Deposits', 'Tot_No_Dep_Cnt', 'Dep_outsidefeat', 'Non_Feat_Non_Dep'] - - return (calc_df - [cols] - .assign(Dep_outsidefeat=lambda calc_df: calc_df.Total_Deposits - calc_df.Point_Count) - .assign(Non_feat_Pxls=lambda calc_df: calc_df.Total_Area - calc_df.Count) - .assign(Non_Feat_Non_Dep=lambda calc_df: calc_df.Non_feat_Pxls - calc_df.Dep_outsidefeat) - # [replace_cols].replace({0: 0.0001, 1: 1.0001}), #FIX THIS? - ) - - -def basic_calculations( - ev_rst: rasterio.io.DatasetReader, - dep_rst: rasterio.io.DatasetReader, - nan_val: float -) -> pd.DataFrame: - """Performs basic calculations about the number of point pixels per class of the input raster. - - Args: - ev_rst (rasterio.io.DatasetReader): The evidential raster. - dep_rst (rasterio.io.DatasetReader): Deposit raster - nan_val (float): value of no data. - - Returns: - basic_clcs (pandas.DataFrame): dataframe with basic calculations. - - """ - basic_clcs = _basic_calculations(ev_rst, dep_rst, nan_val) - return basic_clcs diff --git a/eis_toolkit/prediction/weights_of_evidence/calculate_responses.py b/eis_toolkit/prediction/weights_of_evidence/calculate_responses.py deleted file mode 100644 index 61059e70..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/calculate_responses.py +++ /dev/null @@ -1,40 +0,0 @@ -from eis_toolkit.prediction.weights_of_evidence.post_probabilities import prior_odds, extract_arrays, pprb, pprb_stat -import rasterio -from typing import Tuple, List -import numpy as np - - -def _calculate_responses( - dep_rst: rasterio.io.DatasetReader, - rasters_gen: List -) -> Tuple[np.ndarray, np.ndarray, np.ndarray, dict]: - rstr_meta = dep_rst.meta.copy() - prior_odds_, inv_dep1s = prior_odds(dep_rst) - gen_wgts_sum, var_gen_sum = extract_arrays(rasters_gen) - pprb_array = pprb(gen_wgts_sum, prior_odds_) - pprb_std, pprb_conf = pprb_stat(inv_dep1s, pprb_array, var_gen_sum) - return pprb_array, pprb_std, pprb_conf, rstr_meta - - -def calculate_responses( - dep_rst: rasterio.io.DatasetReader, - rasters_gen: List -) -> Tuple[np.ndarray, np.ndarray, np.ndarray, dict]: - """Calculates the posterior probability for presence of the targeted mineral deposit for the given evidential layers. - - Args: - dep_rst (rasterio.io.DatasetReader): Raster representing the mineral deposits or occurences point data. - rasters_gen (List): List of raster arrays for all evidential rasters, - where each element is a 3d array of generalized classes, - generalized weights and standard deviation of the corresponding generalized weights. - - Returns: - pprb_array (np.ndarray): Array of posterior probabilites of presence of the targeted mineral deposit for the given evidential layers. - pprb_std (np.ndarray): Standard deviations in the posterior probability calculations because of the deviations in weights of the evidential rasters. - pprb_conf(np.ndarray): Confidence of the prospectivity values obtained in the posterior probability array. - array_meta (dict): Resulting raster array's metadata (for visualizations and writing the array to raster file). - - """ - pprb_array, pprb_std, pprb_conf, array_meta = _calculate_responses( - dep_rst, rasters_gen) - return pprb_array, pprb_std, pprb_conf, array_meta diff --git a/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py b/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py deleted file mode 100644 index 516aaf88..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/calculate_weights.py +++ /dev/null @@ -1,67 +0,0 @@ -from typing import Tuple, List, Dict -import rasterio -import pandas as pd - -from eis_toolkit.prediction.weights_of_evidence.weights_calculations import weights_calculations -from eis_toolkit.prediction.weights_of_evidence.basic_calculations import basic_calculations -from eis_toolkit.checks.crs import check_matching_crs -#from eis_toolkit.exceptions import NonMatchingCrsException - -def _calculate_weights( - ev_rst: rasterio.io.DatasetReader, - dep_rst: rasterio.io.DatasetReader, - nan_val: float, - w_type: int = 0, - stud_cont: float = 2 -) -> Tuple[pd.DataFrame, List, Dict]: - - bsc_clc_df = basic_calculations(ev_rst, dep_rst, nan_val) - weights_df, raster_gen, raster_meta = weights_calculations( - ev_rst, bsc_clc_df, nan_val, w_type, stud_cont) - return weights_df, raster_gen, raster_meta - - -def calculate_weights( - ev_rst: rasterio.io.DatasetReader, - dep_rst: rasterio.io.DatasetReader, - nan_val: float, - w_type: int = 0, - stud_cont: float = 2 -) -> Tuple[pd.DataFrame, List, Dict]: - """Calculates weights of spatial associations. - - Args: - ev_rst (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the dep_rst. - dep_rst (rasterio.io.DatasetReader): Raster representing the mineral deposits or occurences point data. - nan_val (float): value of no data - w_type (int, optional): Accepted values are 0 for unique weights, 1 for cumulative ascending weights, 2 for cumulative descending weights. Defaults to 0. - stud_cont (float, optional): studentized contrast value to be used for genralization of classes. Not needed if w_type = 0. Defaults to 2. - - Returns: - weights_df (pd.DataFrame): Dataframe with weights of spatial association between the input rasters - raster_gen (List): List of output raster arrays with generalized or unique classes, generalized weights and standard deviation of generalized weights - raster_meta (Dict): Raster array's metadata. - - Raises: - ValueError: Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. - The below exceptions will be incorporated into the function later as the development for other related functions progresses in the toolkit. - NonMatchingCrsException: The input rasters are not in the same crs - InvalidParameterValueException: Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. (status - pending) - NonMatchingTransformException: The input rasters do not have the same cell size and/or same extent (status - pending) - NonMatchingCoRegistrationException: The input rasters are not coregistered (status - pending) - """ - - w_type_acc = [0, 1, 2] - if w_type not in w_type_acc: - raise ValueError( - "Invalid parameter values. Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively") - """ - if not check_matching_crs( - objects=[ev_rst, dep_rst] - ): - raise NonMatchingCrsException - """ - weights_df, raster_gen, raster_meta = _calculate_weights(ev_rst, dep_rst, nan_val, w_type, stud_cont) - - return weights_df, raster_gen, raster_meta - diff --git a/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py b/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py deleted file mode 100644 index 3ae4e369..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/generalized_weights.py +++ /dev/null @@ -1,28 +0,0 @@ -import pandas as pd - -from eis_toolkit.prediction.weights_of_evidence.weights_generalizations import reclass_gen, gen_weights_finalization -from eis_toolkit.prediction.weights_of_evidence.weights_cleanup import weights_cleanup - -def _weights_generalization( - df_wgts: pd.DataFrame, w_type: int, stud_cont: float = 2 -) -> pd.DataFrame: - - rcls_df = reclass_gen(df_wgts, stud_cont) - wgts_gen = gen_weights_finalization(rcls_df) - wgts_fnl = weights_cleanup(wgts_gen, w_type) - return wgts_fnl - -def weights_generalization( - df_wgts: pd.DataFrame, w_type: int, stud_cont: float = 2 - - -) -> pd.DataFrame: - """Identifies the favourable and unfavorable classes based on the weights for ascending and descending weights and recalculates the generalized weitghts - Args: - df_wgts (pandas.DataFrame): dataframe with the weights - stud_cont (float, def = 2): studentized contrast value to be used for genralization of classes - Returns: - wgts_fnl (pandas.DataFrame): dataframe with generalized weights and generalized classes - """ - wgts_fnl=_weights_generalization(df_wgts, w_type, stud_cont) - return wgts_fnl diff --git a/eis_toolkit/prediction/weights_of_evidence/post_probabilities.py b/eis_toolkit/prediction/weights_of_evidence/post_probabilities.py deleted file mode 100644 index a6eb5946..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/post_probabilities.py +++ /dev/null @@ -1,94 +0,0 @@ -import math -import numpy as np -import rasterio -from typing import Tuple, List - - -def prior_odds( - dep_rst: rasterio.io.DatasetReader -) -> Tuple[float, float]: - """Calculates the prior odds for the training points per unit cell of the study area. - - Args: - dep_rst (rasterio.io.DatasetReader): Raster representing the mineral deposits or occurences point data. - - Returns: - prior_odds_ (float): Prior odds for the mineral deposit per unit cell of the study area. - inv_dep1s (float): Reciprocal of number of deposit pixels. - """ - dep_rst_arr = np.array(dep_rst.read(1)) - #dep_size = np.size(dep_rst_arr) - dep1s = np.count_nonzero(dep_rst_arr == 1) - dep0s = np.count_nonzero(dep_rst_arr == 0) - inv_dep1s = 1/dep1s - prior_probab = dep1s/(dep1s+dep0s) - prior_odds_ = math.log(prior_probab)/(1-prior_probab) - return prior_odds_, inv_dep1s - - -def extract_arrays( - rasters_gen: List -) -> Tuple[np.ndarray, np.ndarray]: - """Creates weights summations and variance summations for all evidential rasters - - Args: - rasters_gen (List): List of raster arrays for all evidential rasters, - where each element is a 3d array of generalized classes, - generalized weights and standard deviation of the corresponding generalized weights. - - Returns: - gen_wgts_sum (np.ndarray): Array of sum of generalized weights of all input evidential raster arrays - var_gen_sum (np.ndarray)]: Array of sum of generalized variance of all input evidential raster arrays - - """ - wgts_gen_ev = [row[1] for row in rasters_gen] - std_wgts_gen = [row[2] for row in rasters_gen] - gen_wgts_sum = np.sum(wgts_gen_ev, axis=0) - var_gen = np.square(std_wgts_gen) - var_gen_sum = np.sum(var_gen, axis=0) - return gen_wgts_sum, var_gen_sum - - -def pprb( - gen_wgts_sum: np.ndarray, - prior_odds_: float -) -> np.ndarray: - """Calculates the final posterior probabilites of presence of the targeted mineral deposit for the given evidential layers. - - Args: - gen_wgts_sum (np.ndarray): Array of sum of generalized weights of all input evidential raster arrays - prior_odds (float): Prior odds for the mineral deposit per unit cell of the study area. - - Returns: - pprb_array (np.ndarray): Array of posterior probabilites of presence of the targeted mineral deposit for the given evidential layers. - - """ - #e = 2.718281828 - #pprb_array =(e**(gen_wgts_sum + prior_odds))/(1+(e**(gen_wgts_sum + prior_odds))) - pprb_array = (np.exp(gen_wgts_sum + prior_odds_)) / \ - (1+(np.exp(gen_wgts_sum + prior_odds_))) - return pprb_array - - -def pprb_stat( - inv_dep1s: float, - pprb_array: np.ndarray, - var_gen_sum: np.ndarray -) -> Tuple[np.ndarray, np.ndarray]: - """Calculates the standard deviation and the confidence arrays of the posterior probability calculations. - - Args: - inv_dep1s (float): Reciprocal of number of deposit pixels. - pprb_array (np.ndarray): Array of posterior probabilites of presence of the targeted mineral deposit for the given evidential layers. - var_gen_sum (np.ndarray): Array of sum of generalized variance of all input evidential raster arrays. - - Returns: - pprb_std (np.ndarray): Standard deviations in the posterior probability calculations because of the deviations in weights of the evidential rasters. - pprb_conf(np.ndarray): Confidence of the prospectivity values obtained in the posterior probability array. - - - """ - pprb_sqr = np.square(pprb_array) - pprb_std = np.sqrt((inv_dep1s + var_gen_sum) * pprb_sqr) - pprb_conf = pprb_array/pprb_std - return pprb_std, pprb_conf diff --git a/eis_toolkit/prediction/weights_of_evidence/save_weights.py b/eis_toolkit/prediction/weights_of_evidence/save_weights.py deleted file mode 100644 index d128c984..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/save_weights.py +++ /dev/null @@ -1,49 +0,0 @@ -import pandas as pd - - -def _save_weights( - df: pd.DataFrame, w_type: int = 0 -) -> pd.DataFrame: - - drop_cols = ['No_Dep_Cnt', 'Total_Area', 'Total_Deposits', 'Tot_No_Dep_Cnt', - 'Dep_outsidefeat', 'Non_feat_Pxls', 'Non_Feat_Non_Dep', - 'N_cls', 'Num_wpls', 'Deno_wpls', 'var_wpls', 'Num_wmns', - 'Non_Feat_Pxls_cm', 'Deno_wmns', 'var_wmns', 'var_wpls_gen', - 'cmltv_dep_cnt', 'cmltv_cnt', 'cmltv_no_dep_cnt' - ] - - if w_type != 0: - cols_rename = {'Class': 'Class', 'Point_Count': 'Cmltv. Point Count', 'Count': 'Cmltv. Count', - 'Act_Count': 'Count_', 'Act_Point_Count': 'Point Count_', - 'wpls': 'WPlus', 's_wpls': 'S_WPlus', 'wmns': 'WMinus', 's_wmns': 'S_WMinus', - 'contrast': 'Contrast', 's_contrast': 'S_Contrast', 'Stud_Cont': 'Stud. Contrast', - 'Rcls': 'Gen_Class', 'W_Gen': 'Gen_Weights', 's_wpls_gen': 'S_Gen_Weights' - } - else: - cols_rename = {'Class': 'Class', 'Point_Count': 'Point Count', 'Count': 'Count', - 'wpls': 'WPlus', 's_wpls': 'S_WPlus', 'wmns': 'WMinus', 's_wmns': 'S_WMinus', - 'contrast': 'Contrast', 's_contrast': 'S_Contrast', 'Stud_Cont': 'Stud. Contrast', - } - df = df.drop([col for col in drop_cols if col in df.columns], - axis=1).rename(columns=cols_rename).round(4) - return df - - -def save_weights( - df: pd.DataFrame, w_type: int = 0 -) -> pd.DataFrame: - """ Removes unnecessary columns and creates a clean dataframe with important spatial associations quantities. - For caterogical data with weights calculations type 'unique', this function is called after the weights calculations. - For numerical data this function is called after reclassification and generalized weights calculations. - - Args: - df (pandas.DataFrame): Data frame with all the calculations; obtained from the contrast function (for categorical data) or from the generalized weights function (for ordinal data) - w_type (int, def = 0): 0 = unique weights, 1 = cumulative ascending weights, 2 = cumulative descending weights - Returns: - df_weights (pandas.DataFrame): Final dataframe with only the necessary values. - Raises: - - """ - - df_weights = _save_weights(df, w_type) - return df_weights diff --git a/eis_toolkit/prediction/weights_of_evidence/weights.py b/eis_toolkit/prediction/weights_of_evidence/weights.py deleted file mode 100644 index 930391c3..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/weights.py +++ /dev/null @@ -1,86 +0,0 @@ -import pandas as pd -import numpy as np - - -def positive_weights( - df: pd.DataFrame -) -> pd.DataFrame: - """ Calculates positive weights of spatial associations between the input data and the points - Args: - df (pandas.DataFrame): The dataframe containing data values, obtained from the weights_type function - Returns: - df_wpls (pandas.DataFrame): The dataframe with positive weights of spatial associaton for each data class - Raises: - - """ - pd.set_option('mode.chained_assignment', None) - df_wpls = (df - .assign(Point_Count=lambda df: df.Point_Count. - replace(0, 0.0001)) - .assign(Num_wpls=lambda df: (df.Point_Count/df.Total_Deposits) - .replace(0, 0.0001).replace(1, 1.0001)) - .assign(Deno_wpls=lambda df: df.No_Dep_Cnt/df.Tot_No_Dep_Cnt) - .assign(wpls=lambda df: np.log(df.Num_wpls)-np.log(df.Deno_wpls)) - .assign(var_wpls=lambda df: (1/df.Point_Count)+(1/df.No_Dep_Cnt)) - .assign(s_wpls=lambda df: np.sqrt(df.var_wpls)) - ) - return df_wpls - - -def negative_weights( - df_: pd.DataFrame, w_type: int = 0 -) -> pd.DataFrame: - """ Calculates negative weights of spatial associations between the input data and the points. - Args: - df (pandas.DataFrame): The dataframe containing the positive weights for the data values; obtained from the positive_weights function - w_type (int = 0): 0 = unique weights, 1 = cumulative ascending weights, 2 = cumulative descending weights. - Returns: - df_wmns (pandas.DataFrame): The dataframe with the negative weights of spatial association for each class. - Raises: - - """ - df = df_.copy() - pd.set_option('mode.chained_assignment', None) - if w_type != 0: - df.rename(columns={"Count": "Act_Count", - "cmltv_cnt": "Count"}, inplace=True) - - df_wmns = (df - .assign(Num_wmns=lambda df: (df.Total_Deposits - (df.Point_Count/df.Total_Deposits)) - .replace(0, 0.0001)) - .assign(Dep_outsidefeat=lambda df: (df.Total_Deposits - df.Point_Count) - .replace(0, 0.0001)) - .assign(Non_Feat_Pxls_cm=lambda df: (df.Total_Area - df.Count) - .replace(0, 0.0001)) - .assign(Non_Feat_Non_Dep=lambda df: (df.Non_Feat_Pxls_cm - df.Dep_outsidefeat) - .replace(0, 0.0001)) - .assign(Deno_wmns=lambda df: (df.Non_Feat_Pxls_cm - (df.Dep_outsidefeat/df.Tot_No_Dep_Cnt)) - .replace(0, 0.0001)) - .assign(wmns=lambda df: np.log(df.Num_wmns)-np.log(df.Deno_wmns)) - .assign(var_wmns=lambda df: (1/df.Dep_outsidefeat)+(1/df.Non_Feat_Non_Dep)) - .assign(s_wmns=lambda df: np.sqrt(df.var_wmns)) - .round(4) - ) # some of these calculations could be clubbed together - # this should be before 'wmns' assignment, check at some point - df_wmns.loc[df_wmns["Num_wmns"] == - df_wmns["Deno_wmns"], "Num_wmns"] = 1.0001 - return df_wmns - - -def contrast(df: pd.DataFrame - ) -> pd.DataFrame: - """Calculates the contrast and the studentized contrast values from the postive and negative spatial associations quantified as weights in the positive_weights and negative_weights functions - Args: - df (pandas.DataFrame): The dataframe containing the positive and negative weights of spatial associations; obtained from the negative_weights function - Returns: - df_cont (pandas.DataFrame): The dataframe with contrast and studentized contrast values - """ - - df_cont = (df - .assign(contrast=lambda df: df.wpls - df.wmns) - .assign(s_contrast=lambda df: np.sqrt(df.var_wpls + df.var_wmns)) - .assign(Stud_Cont=lambda df: df.contrast/df.s_contrast) - .round(3) - ) - #df_stud_cont = df_cont[['Class', 'contrast', 's_contrast', 'Stud_Cont']] - return df_cont diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_arrays.py b/eis_toolkit/prediction/weights_of_evidence/weights_arrays.py deleted file mode 100644 index dae6e362..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/weights_arrays.py +++ /dev/null @@ -1,80 +0,0 @@ - -from typing import Tuple, List -import pandas as pd -import numpy as np -import rasterio -import functools - - -def _raster_array( - ev_rst: rasterio.io.DatasetReader, - df_wgts_nan: pd.DataFrame, col: str -) -> np.ndarray: - #rstr_meta = ev_rst.meta.copy() - rstr_arry = np.array(ev_rst.read(1)) - s = rstr_arry.shape - #print(df_wgts_nan.Class) - wgts_mapping_dct = {} - wgts_mapping_dct = pd.Series(df_wgts_nan.loc[:, col],index=df_wgts_nan.Class).to_dict() - replace_array = np.array([list(wgts_mapping_dct.keys()), list(wgts_mapping_dct.values())]) - rstr_arry_wgts = rstr_arry.reshape(-1) - mask_array = np.isin(rstr_arry_wgts, replace_array[0, :]) - ss_rplc_array = np.searchsorted(replace_array[0, :], rstr_arry_wgts[mask_array]) - rstr_arry_rplcd = replace_array[1, ss_rplc_array] - rstr_arry_rplcd = rstr_arry_rplcd.reshape(s) - return rstr_arry_rplcd - - -def raster_array( - ev_rst: rasterio.io.DatasetReader, - df_wgts_nan: pd.DataFrame, col: str -) -> np.ndarray: - """Converts the generalized weights dataaframe to numpy arrays with the extent and shape of the input raster - - Args: - ev_rst (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the dep_rst. - df_wgts_nan (pd.DataFrame): Generalized weights dataframe with info on NaN data also. - col (str): Columns to use for generation of raster object arrays. - - Returns: - np.ndarray: Individual raster object arrays for generalized or unique classes, generalized weights and standard deviation of generalized weights - """ - raster_array_ = _raster_array(ev_rst, df_wgts_nan, col) - return raster_array_ - - -def _weights_arrays( - ev_rst: rasterio.io.DatasetReader, - df_wgts: pd.DataFrame, - col_names: List -) -> Tuple[List, dict]: - rstr_meta = ev_rst.meta.copy() - list_cols = list(df_wgts.columns) - nan_row = {val: -1.e+09 for val in list_cols} - nan_row_df = pd.DataFrame.from_dict(nan_row, orient = 'index') - nan_row_df_t = nan_row_df.T - df_wgts_nan = pd.concat([nan_row_df_t, df_wgts]) - class_rstr, w_gen_rstr, std_rstr = map( - functools.partial(raster_array, ev_rst, df_wgts_nan), - col_names) - gen_arrys = [class_rstr, w_gen_rstr, std_rstr] - return gen_arrys, rstr_meta - -def weights_arrays( - ev_rst: rasterio.io.DatasetReader, - df_wgts: pd.DataFrame, col_names: List -) -> Tuple[List, dict]: - """Calls the raster_arrays function to convert the generalized weights dataaframe to numpy arrays. - - Args: - ev_rst (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the dep_rst. - df_wgts (pd.DataFrame): Dataframe with the weights. - col_names (List): Columns to generate the arrays from. - - Returns: - gen_arrys (List): List of individual raster object arrays for generalized or unique classes, generalized weights and standard deviation of generalized weights - rstr_meta (dict): Raster array's metadata. - """ - - gen_arrys, rstr_meta = _weights_arrays(ev_rst, df_wgts, col_names) - return gen_arrys, rstr_meta diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py b/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py deleted file mode 100644 index da8dcc32..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/weights_calculations.py +++ /dev/null @@ -1,78 +0,0 @@ -from typing import Tuple, List -import rasterio -import pandas as pd -from enum import Enum - -from eis_toolkit.prediction.weights_of_evidence.generalized_weights import weights_generalization -from eis_toolkit.prediction.weights_of_evidence.weights_arrays import weights_arrays -from eis_toolkit.prediction.weights_of_evidence.weights_cleanup import weights_cleanup -from eis_toolkit.prediction.weights_of_evidence.weights import positive_weights, negative_weights, contrast -from eis_toolkit.prediction.weights_of_evidence.weights_type import weights_type - -class WeightsOfEvidenceType(Enum): - Unique = 0 - CumulativeAscending = 1 - CumulativeDescending = 2 - - def __str__(self): - return f'{self.name.lower()}({self.value})' - - def __eq__(self, other): - if isinstance(other, int): - return self.value == other - - if isinstance(other, WeightsOfEvidenceType): - return self is other - - return False - -def _weights_calculations( - ev_rst: rasterio.io.DatasetReader, - bsc_clc: pd.DataFrame, - nan_val: float, - w_type: int = 0, stud_cont: float = 2 -) -> Tuple[pd.DataFrame, List, dict]: - - df_wgts_test, df_nan = weights_type( - bsc_clc, nan_val, w_type) # df_nan is not needed - wpls_df = positive_weights(df_wgts_test) - wmns_df = negative_weights(wpls_df, w_type) - contrast_df = contrast(wmns_df) - - if w_type == WeightsOfEvidenceType.Unique: - cat_wgts = weights_cleanup(contrast_df) - col_names = ['Class', 'WPlus', 'S_WPlus'] - gen_arrys, rstr_meta = weights_arrays(ev_rst, cat_wgts, col_names) - return cat_wgts, gen_arrys, rstr_meta - else: - num_weights = weights_generalization(contrast_df, w_type, stud_cont,) - col_names = ['Gen_Class', 'Gen_Weights', 'S_Gen_Weights'] - gen_arrys, rstr_meta = weights_arrays(ev_rst, num_weights, col_names) - return num_weights, gen_arrys, rstr_meta - - -def weights_calculations( - ev_rst: rasterio.io.DatasetReader, - bsc_clc: pd.DataFrame, - nan_val:float, - w_type: int = 0, stud_cont: float = 2 -) -> Tuple[pd.DataFrame, List, dict]: - """ Calculates weights of spatial associations. - - Args: - ev_rst (rasterio.io.DatasetReader): The evidential raster. - bsc_clc(pd.DataFrame): Dataframe obtained from basic_calculations function. - nan_val (float): value of no data - w_type (int, optional): Accepted values are 0 for unique weights, 1 for cumulative ascending weights, 2 for cumulative descending weights. Defaults to 0. - stud_cont (float, optional): studentized contrast value to be used for genralization of classes. Not needed if w_type = 0. Defaults to 2. - - Returns: - weights_df (pd.DataFrame): Dataframe with weights of spatial association between the input rasters. - gen_arrays (List): List of output raster arrays with generalized or unique classes, generalized weights and standard deviation of generalized weights. - raster_meta (dict): Raster array's metadata. - - """ - - weights_df, gen_arrys, raster_meta = _weights_calculations( - ev_rst, bsc_clc, nan_val, w_type, stud_cont) - return weights_df, gen_arrys, raster_meta diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py b/eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py deleted file mode 100644 index 306d53ad..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/weights_cleanup.py +++ /dev/null @@ -1,67 +0,0 @@ -import pandas as pd - - -def _weights_cleanup( - df: pd.DataFrame, w_type: int = 0 -) -> pd.DataFrame: - - drop_cols = ['No_Dep_Cnt', 'Total_Area', 'Total_Deposits', 'Tot_No_Dep_Cnt', - 'Dep_outsidefeat', 'Non_feat_Pxls', 'Non_Feat_Non_Dep', - 'N_cls', 'Num_wpls', 'Deno_wpls', 'var_wpls', 'Num_wmns', - 'Non_Feat_Pxls_cm', 'Deno_wmns', 'var_wmns', 'var_wpls_gen', - 'cmltv_dep_cnt', 'cmltv_cnt', 'cmltv_no_dep_cnt' - ] - - if w_type != 0: - cols_rename = {'Class': 'Class', - 'Point_Count': 'Cmltv. Point Count', - 'Count': 'Cmltv. Count', - 'Act_Count': 'Count_', - 'Act_Point_Count': 'Point Count_', - 'wpls': 'WPlus', - 's_wpls': 'S_WPlus', - 'wmns': 'WMinus', - 's_wmns': 'S_WMinus', - 'contrast': 'Contrast', - 's_contrast': 'S_Contrast', - 'Stud_Cont': 'Stud. Contrast', - 'Rcls': 'Gen_Class', - 'W_Gen': 'Gen_Weights', - 's_wpls_gen': 'S_Gen_Weights' - } - else: - cols_rename = {'Class': 'Class', - 'Point_Count': 'Point Count', - 'Count': 'Count', - 'wpls': 'WPlus', - 's_wpls': 'S_WPlus', - 'wmns': 'WMinus', - 's_wmns': 'S_WMinus', - 'contrast': 'Contrast', - 's_contrast': 'S_Contrast', - 'Stud_Cont': 'Stud. Contrast', - } - df = (df.drop([col for col in drop_cols if col in df.columns], axis=1) - .rename(columns=cols_rename) - .round(4) - ) - return df - - -def weights_cleanup( - df: pd.DataFrame, w_type: int = 0 -) -> pd.DataFrame: - """ Removes unnecessary columns and creates a clean dataframe with important spatial associations quantities. - For caterogical data with weights calculations type 'unique', this function is called after the weights calculations. - For numerical data this function is called after reclassification and generalized weights calculations. - - Args: - df (pandas.DataFrame): Data frame with all the calculations; obtained from the contrast function (for categorical data) or from the generalized weights function (for ordinal data) - w_type (int, def = 0): 0 = unique weights, 1 = cumulative ascending weights, 2 = cumulative descending weights - Returns: - df_weights (pandas.DataFrame): Final dataframe with only the necessary values. - - """ - - df_weights = _weights_cleanup(df, w_type) - return df_weights diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py b/eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py deleted file mode 100644 index ca49245a..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/weights_generalizations.py +++ /dev/null @@ -1,101 +0,0 @@ -import pandas as pd -import numpy as np -import functools - -from eis_toolkit.exceptions import UnFavorableClassDoesntExistException, FavorableClassDoesntExistException - - -def _reclass_gen( - df: pd.DataFrame, stud_cont: float = 2 -) -> pd.DataFrame: - - df['Rcls'] = df.Stud_Cont.ge(stud_cont)[::-1].cummax()+1 - - df_stud_cont = df[['Class', 'contrast', 'Stud_Cont', 'Rcls']].round(4) - - if 1 not in df['Rcls'].values: - print(df_stud_cont) - raise UnFavorableClassDoesntExistException("""Exception error: Class doesn't exist. - For the given studentized contrast value, none of the classes were classified to the 'Unfavorable' class, i.e., class 1. - Check the displayed studentized contrast values ('Stud_Cont') and run weights calculations again using a suitable threshold value.""") - - elif 2 not in df['Rcls'].values: - print(df_stud_cont) - raise FavorableClassDoesntExistException("""Exception error: Class doesn't exist. - For the given studentized contrast value none of the classes were classified to the 'Favorable' class, i.e., class 2. - Check the displayed studentized contrast values ('Stud_Cont') and run weights calculations again using a suitable threshold value.""") - - else: - df_ = df.round(4).sort_values(by="Class", ascending=True) - return df_ - - -def reclass_gen( - df: pd.DataFrame, stud_cont: float = 2 -) -> pd.DataFrame: - """Performs reclassification of classes into favourable and unfavourable categories for ordianl data, based on studentized contrast values provided by the user. - Args: - df (pandas.DataFrame): The dataframe with all the weights calculations; obtained from the contrast function - stud_cont (float, def = 2): The threshold for studentized contrast for reclassification - Returns: - df_rcls (pandas.DataFrame): The dataframe with data classes categorized as favourable and unfavourable - Raises: - UnFavorableClassDoesntExistException: Failure to generalize classes using the given studentised contrast threshold value. Class 1 (unfavorable class) doesn't exist - FavorableClassDoesntExistException: Failure to generalize classes using the given studentised contrast threshold value. Class 2 (favorable class) doesn't exist - """ - df_rcls = _reclass_gen(df, stud_cont) - return df_rcls - - -def gen_weights( - df: pd.DataFrame, gen_cls: int -) -> pd.DataFrame: - """_summary_ - Args: - df (pd.DataFrame): - gen_cls (int): List of generalized class values - Returns: - df_gen_wgts (pd.DataFrame): Dataframe with positives weights of associations for generalized classes - Raises: - - """ - df_rc = df.groupby('Rcls') - df_rc_ = df_rc.get_group(gen_cls) - df_gen_wgts = (df_rc_ - .assign(cmltv_dep_cnt=lambda df_rc_: df_rc_.Point_Count.cumsum()) - .assign(cmltv_cnt=lambda df_rc_: df_rc_.Count.cumsum()) - .assign(cmltv_no_dep_cnt=lambda df_rc_: df_rc_.No_Dep_Cnt.cumsum()) - .iloc[[-1]] - ) - - return (df_gen_wgts - .assign(Num_wpls=lambda df_gen_wgts: df_gen_wgts.cmltv_dep_cnt/df_gen_wgts.Total_Deposits) - .assign(Deno_wpls=lambda df_gen_wgts: df_gen_wgts.cmltv_no_dep_cnt/df_gen_wgts.Tot_No_Dep_Cnt) - .assign(W_Gen=lambda df_gen_wgts: np.log(df_gen_wgts.Num_wpls)-np.log(df_gen_wgts.Deno_wpls)) - .assign(var_wpls_gen=lambda df_gen_wgts: (1/df_gen_wgts.cmltv_dep_cnt)+(1/df_gen_wgts.cmltv_no_dep_cnt)) - .assign(s_wpls_gen=lambda df_gen_wgts: np.sqrt(df_gen_wgts.var_wpls_gen)) - ) - - -def gen_weights_finalization( - df: pd.DataFrame -) -> pd.DataFrame: - """ Calls the gen_weights function and calculates positives weights of associations for each generalized class - - Args: - df (pd.DataFrame): Dataframe with weights of associations - Returns: - df (pd.DataFrame): Dataframe with positives weights of associations for generalized classes - """ - gen_cls = [1, 2] - gw_1, gw_2 = map(functools.partial(gen_weights, df), gen_cls) - gw = pd.concat([gw_1, gw_2]) - for i, clss in enumerate(gen_cls): - w = gw.iloc[i, 31] - s_w = gw.iloc[i, 33] - v_w = gw.iloc[i, 32] - df.loc[df.Rcls == clss, 'W_Gen'] = w - df.loc[df.Rcls == clss, 's_wpls_gen'] = s_w - df.loc[df.Rcls == clss, 'var_wpls_gen'] = v_w - df.round(4) - return df diff --git a/eis_toolkit/prediction/weights_of_evidence/weights_type.py b/eis_toolkit/prediction/weights_of_evidence/weights_type.py deleted file mode 100644 index 8bae0c8d..00000000 --- a/eis_toolkit/prediction/weights_of_evidence/weights_type.py +++ /dev/null @@ -1,74 +0,0 @@ -from typing import Tuple -import pandas as pd -from enum import Enum - -class WeightsOfEvidenceType(Enum): - Unique = 0 - CumulativeAscending = 1 - CumulativeDescending = 2 - - def __str__(self): - return f'{self.name.lower()}({self.value})' - - def __eq__(self, other): - if isinstance(other, int): - return self.value == other - - if isinstance(other, WeightsOfEvidenceType): - return self is other - - return False - -def _weights_type( - df: pd.DataFrame, nan_val: float, w_type: int = 0 -) -> Tuple [pd.DataFrame, pd.DataFrame]: - - df.loc[df.Class <= nan_val, 'N_cls'] = 'NaN' # not needed as such - df.loc[df.Class > nan_val, 'N_cls'] = 'Data' - df_rcl=df.groupby('N_cls') - df_rcl_dt = df_rcl.get_group('Data') - df_rcl_nan = df_rcl.get_group('NaN') - - pd.set_option('mode.chained_assignment', None) - if w_type == WeightsOfEvidenceType.Unique: - #returns the df with the data classes for categorical weights calculations - return df_rcl_dt, df_rcl_nan - #for sorting of classes for numerical weights calculations - else: #w_type != 0: - df_rcl_dt.rename(columns = {"Point_Count":"Act_Point_Count"}, inplace = True) - if w_type == WeightsOfEvidenceType.CumulativeAscending: - df_srtd = df_rcl_dt.sort_values(by = "Class", ascending=True) - #return df_srtd - elif w_type == WeightsOfEvidenceType.CumulativeDescending: - df_srtd = df_rcl_dt.sort_values(by = "Class", ascending=False) - - pd.set_option('mode.chained_assignment', None) - df_data_srtd = (df_srtd - .assign(Point_Count = lambda df_srtd: df_srtd.Act_Point_Count.cumsum().replace(0,0.0001)) - .assign(cmltv_cnt = lambda df_srtd: df_srtd.Count.cumsum()) - .assign(No_Dep_Cnt = lambda df_srtd: df_srtd.No_Dep_Cnt.cumsum().replace(0, 0.0001)) - ) - return df_data_srtd, df_rcl_nan - - - -def weights_type( - df: pd.DataFrame, nan_val: float, w_type: int = 0 -) -> Tuple[pd.DataFrame, pd.DataFrame]: - """ - Identifies NoData and separates it out from subsequent calculations. Based on the type of weights selected by the user, the function performs the sorting and cumulative count calculations. - Args: - df (pandas.DataFrame): The dataframe with basic calculations performed in the basic_calculations function - nan_val (float): value of no data - w_type(int, def = 0): 0 = unique weights, 1 = cumulative ascending weights, 2 = cumulative descending weights - Returns: - df_data (pandas.DataFrame): The dataframe with data values and sorted is weights calculations type is numerical (i.e., w_type = 1 or 2) - df_nan (pandas.DataFrame): The dataframe with information on NoData - - """ - w_type_acc = [0,1,2] - if w_type not in w_type_acc: - raise ValueError("Accepted values of w_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively") - else: - df_data, df_nan = _weights_type(df, nan_val, w_type) - return df_data, df_nan diff --git a/eis_toolkit/prediction/wofe_new_old.py b/eis_toolkit/prediction/wofe_new_old.py deleted file mode 100644 index e0c6b0c2..00000000 --- a/eis_toolkit/prediction/wofe_new_old.py +++ /dev/null @@ -1,466 +0,0 @@ -import numpy as np -import functools - -from eis_toolkit import exceptions -from typing import Dict, List, Tuple, Literal - -import pandas as pd -import rasterio - - -SMALL_VALUE = 0.0001 -LARGE_VALUE = 1.0001 - - - -def weights_of_evidence( - evidential_raster: rasterio.io.DatasetReader, - deposit_raster: rasterio.io.DatasetReader, - weights_type: Literal['unique', 'ascending', 'descending'] = 'unique', - studentized_contrast: float = 2, -) -> Tuple[pd.DataFrame, List, Dict]: - """Calculates weights of spatial associations. - - Args: - evidential_raster: The evidential raster with spatial resolution and extent identical to that of the deposit_raster. - deposit_raster: Raster representing the mineral deposits or occurences point data. - weights_type: Accepted values are 'unique' for unique weights, 'ascending' for cumulative ascending weights, - 'descending' for cumulative descending weights. Defaults to 'unique'. - studentized_contrast: Studentized contrast value to be used for genralization of classes. - Not needed if weights_type is 'unique'. Defaults to 2. - - Returns: - weights_df: Dataframe with weights of spatial association between the input rasters - raster_gen: List of output raster arrays with generalized or unique classes, generalized weights - and standard deviation of generalized weights - raster_meta: Raster array's metadata. - - Raises: - ValueError: Accepted values of weights_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. - The below exceptions will be incorporated into the function later as the development for other related functions progresses in the toolkit. - NonMatchingCrsException: The input rasters are not in the same crs - InvalidParameterValueException: Accepted values of weights_type are 0, 1, 2 for unique, cumulative ascending and cumulative descending weights respectively. (status - pending) - NonMatchingTransformException: The input rasters do not have the same cell size and/or same extent (status - pending) - NonMatchingCoRegistrationException: The input rasters are not coregistered (status - pending) - """ - - basic_calculations_df = _basic_calculations(evidential_raster, deposit_raster) - weights_df, raster_gen, raster_meta = _weights_calculations( - evidential_raster, - basic_calculations_df, - weights_type, - studentized_contrast - ) - return weights_df, raster_gen, raster_meta - - -def _basic_calculations( - evidential_raster: rasterio.io.DatasetReader, deposit_raster: rasterio.io.DatasetReader -) -> pd.DataFrame: - """Performs basic calculations about the number of point pixels per class of the input raster. - - Args: - evidential_raster (rasterio.io.DatasetReader): The evidential raster. - deposit_raster (rasterio.io.DatasetReader): Deposit raster. - - Returns: - basic_calculations_df (pandas.DataFrame): dataframe with basic calculations. - """ - - # Read raster data - evidential_array, deposit_array = np.array(evidential_raster.read(1)), np.array(deposit_raster.read(1)) - - # Convert nodata values to np.nan - evidential_array[evidential_array == evidential_raster.meta.nodata] = np.nan - deposit_array[deposit_array == deposit_raster.meta.nodata] = np.nan - - total_pixels = np.size(evidential_array) - np.isnan(evidential_array).sum() - dep1s, dep0s = np.count_nonzero(deposit_array == 1), np.count_nonzero(deposit_array == 0) # CHECK - - df_flat = pd.DataFrame( - {"Class": evidential_array.flatten(), - "Deposits": deposit_array.flatten()} - ) - - geol_dep = df_flat.groupby("Class")["Deposits"] - geol_count = geol_dep.count() - geol_dep_sum = geol_dep.sum() - - basic_calculations_df = pd.DataFrame( - { - "Class": np.unique(evidential_array), - "Count": geol_count, - "Point_Count": geol_dep_sum, - "No_Dep_Cnt": geol_count - geol_dep_sum, - "Total_Area": total_pixels, - "Total_Deposits": dep1s, - "Tot_No_Dep_Cnt": dep0s, - 'Dep_outsidefeat': dep1s - geol_dep_sum, - 'Non_feat_pixels': total_pixels - geol_count, - } - ) - basic_calculations_df['Non_Feat_Non_Dep'] = basic_calculations_df['Non_feat_pixels'] - basic_calculations_df['Dep_outsidefeat'] - - return basic_calculations_df - - -def _weights_calculations( - evidential_raster: rasterio.io.DatasetReader, - basic_calculations_df: pd.DataFrame, - weight_type: Literal['unique', 'ascending', 'descending'], - studentized_contrast: float -) -> Tuple[pd.DataFrame, List, dict]: - """Calculates weights of spatial associations. - - Args: - evidential_raster: The evidential raster. - basic_calculations_df: Dataframe obtained from basic_calculations function. - weights_type: Accepted values are 'unique' for unique weights, 'ascending' for cumulative ascending weights, - 'descending' for cumulative descending weights. - studentized_contrast: Studentized contrast value to be used for genralization of classes. - Not needed if weight_type = 'unique'. - - Returns: - weights_df (pd.DataFrame): Dataframe with weights of spatial association between the input rasters. - gen_arrays (List): List of output raster arrays with generalized or unique classes, generalized weights and standard deviation of generalized weights. - raster_meta (dict): Raster array's metadata. - - """ - weights_df_test = _weights_type(basic_calculations_df, weight_type) - wpls_df = _positive_weights(weights_df_test) - wmns_df = _negative_weights(wpls_df, weight_type) - contrast_df = _contrast(wmns_df) - - if weight_type == 'unique': - cat_wgts = _weights_cleanup(contrast_df) - col_names = ["Class", "WPlus", "S_WPlus"] - gen_arrys, raster_meta = _weights_arrays(evidential_raster, cat_wgts, col_names) - return cat_wgts, gen_arrys, raster_meta - else: - num_weights = _weights_generalization( - contrast_df, - weight_type, - studentized_contrast, - ) - col_names = ["Gen_Class", "Gen_Weights", "S_Gen_Weights"] - gen_arrys, raster_meta = _weights_arrays(evidential_raster, num_weights, col_names) - return num_weights, gen_arrys, raster_meta - - - -def _weights_type(df: pd.DataFrame, weight_type: Literal['unique', 'ascending', 'descending']) -> pd.DataFrame: - """ - Based on the type of weights selected by the user, the function performs the sorting and cumulative count calculations. - - Args: - df (pandas.DataFrame): The dataframe with basic calculations performed in the basic_calculations function - weight_type(str): 'unique' = unique weights, 'ascending' = cumulative ascending weights, - 'descending' = cumulative descending weights - - Returns: - df_data: The dataframe with data values sorted if weights calculation type is numerical - (i.e., weight_type = 'ascending' or 'descending') - """ - # To replace: Point_Count, No_Dep_Cnt - df_data = df.dropna(subset=['Class']) - - if weight_type != 'unique': - df_data = df_data.copy() # Avoid SettingWithCopyWarning - df_data.rename(columns={"Point_Count": "Act_Point_Count"}, inplace=True) - df_data.sort_values(by="Class", ascending=(weight_type == 'ascending'), inplace=True) - df_data['Point_Count'] = df_data['Act_Point_Count'].cumsum() - df_data['cmltv_cnt'] = df_data['Count'].cumsum() - df_data['No_Dep_Cnt'] = df_data['No_Dep_Cnt'].cumsum() - - return df_data - - -def _positive_weights(df: pd.DataFrame) -> pd.DataFrame: - """Calculates positive weights of spatial associations between the input data and the points. - - Args: - df: The dataframe containing data values, obtained from the weights_type function - Returns: - df: The dataframe with positive weights of spatial associaton for each data class - """ - # To replace: Point_Count, Num_wpls (also LARGE) - df['Deno_wpls'] = df['No_Dep_Cnt'] / df['Tot_No_Dep_Cnt'] - df['wpls'] = np.log(df['Num_wpls']) - np.log(df['Deno_wpls']) - df['var_wpls'] = (1 / df['Point_Count']) + (1 / df['No_Dep_Cnt']) - df['s_wpls'] = np.sqrt(df['var_wpls']) - return df - - -def _negative_weights(df_: pd.DataFrame, weight_type: Literal['unique', 'ascending', 'descending']) -> pd.DataFrame: - """Calculates negative weights of spatial associations between the input data and the points. - - Args: - df: The dataframe containing already the positive weights for the data values. - weight_type: 'unique' = unique weights, 'ascending' = cumulative ascending weights, - 'descending' = cumulative descending weights - Returns: - df_wmns: The dataframe with the negative weights of spatial association for each class. - """ - # To replace: Num_wmns, Dep_outsidefeat, Non_Feat_Pxls_cm, Non_Feat_Non_Dep, Deno_wmns - df = df_.copy() - # if weight_type != 0: - # df.rename(columns={"Count": "Act_Count", "cmltv_cnt": "Count"}, inplace=True) - - df["Num_wmns"] = df['Total_Deposits'] - (df['Point_Count'] / df['Total_Deposits']) - df['Dep_outsidefeat'] = df['Total_Deposits'] - df['Point_Count'] - df['Non_Feat_Pxls_cm'] = df['Total_Area'] - df['Count'] - df['Non_Feat_Non_Dep'] = df['Non_Feat_Pxls_cm'] - df['Dep_outsidefeat'] - df['Deno_wmns'] = df['Non_Feat_Pxls_cm'] - (df['Dep_outsidefeat'] / df['Tot_No_Dep_Cnt']) - df['wmns'] = np.log(df['Num_wmns']) - np.log(df['Deno_wmns']) - df['var_wmns'] = (1 / df['Dep_outsidefeat']) + (1 / df['Non_Feat_Non_Dep']) - df['s_wmns'] = np.sqrt(df['var_wmns']) - - df = df.round(4) - - df.loc[df["Num_wmns"] == df["Deno_wmns"], "Num_wmns"] = LARGE_VALUE - return df - - -def _contrast(df: pd.DataFrame) -> pd.DataFrame: - """ - Calculates the contrast and the studentized contrast values from the postive and negative spatial - associations quantified as weights in the positive_weights and negative_weights functions. - - Args: - df: The dataframe containing the positive and negative weights of spatial associations. - Returns: - Dataframe with contrast and studentized contrast values. - """ - df['contrast'] = df['wpls'] - df['wmns'] - df['s_contrast'] = np.sqrt(df['var_wpls'] + df['var_wmns']) - df['Stud_Cont'] = df['contrast'] / df['s_contrast'] - - df = df.round(3) - return df - - - - - - - - - - -def _weights_cleanup(df: pd.DataFrame, weight_type: int = 0) -> pd.DataFrame: - """ - Removes unnecessary columns and creates a clean dataframe with important spatial associations quantities. - For caterogical data with weights calculations type 'unique', this function is called after the weights calculations. - For numerical data this function is called after reclassification and generalized weights calculations. - - Args: - df: Dataframe with all the calculations; obtained from the contrast function (for categorical data) or from the generalized weights function (for ordinal data) - weight_type: - Returns: - Final dataframe with only the necessary values. - """ - - drop_cols = [ - "No_Dep_Cnt", - "Total_Area", - "Total_Deposits", - "Tot_No_Dep_Cnt", - "Dep_outsidefeat", - "Non_feat_pixels", - "Non_Feat_Non_Dep", - "N_cls", - "Num_wpls", - "Deno_wpls", - "var_wpls", - "Num_wmns", - "Non_Feat_Pxls_cm", - "Deno_wmns", - "var_wmns", - "var_wpls_gen", - "cmltv_dep_cnt", - "cmltv_cnt", - "cmltv_no_dep_cnt", - ] - - if weight_type != 0: - cols_rename = { - "Class": "Class", - "Point_Count": "Cmltv. Point Count", - "Count": "Cmltv. Count", - "Act_Count": "Count_", - "Act_Point_Count": "Point Count_", - "wpls": "WPlus", - "s_wpls": "S_WPlus", - "wmns": "WMinus", - "s_wmns": "S_WMinus", - "contrast": "Contrast", - "s_contrast": "S_Contrast", - "Stud_Cont": "Stud. Contrast", - "Rcls": "Gen_Class", - "W_Gen": "Gen_Weights", - "s_wpls_gen": "S_Gen_Weights", - } - else: - cols_rename = { - "Class": "Class", - "Point_Count": "Point Count", - "Count": "Count", - "wpls": "WPlus", - "s_wpls": "S_WPlus", - "wmns": "WMinus", - "s_wmns": "S_WMinus", - "contrast": "Contrast", - "s_contrast": "S_Contrast", - "Stud_Cont": "Stud. Contrast", - } - df = df.drop([col for col in drop_cols if col in df.columns], axis=1).rename(columns=cols_rename).round(4) - return df - - -def _weights_generalization(weights_df: pd.DataFrame, weight_type: int, studentized_contrast: float = 2) -> pd.DataFrame: - """Identifies the favourable and unfavorable classes based on the weights for ascending and descending weights and recalculates the generalized weitghts - Args: - weights_df (pandas.DataFrame): dataframe with the weights - studentized_contrast (float, def = 2): studentized contrast value to be used for genralization of classes - Returns: - wgts_fnl (pandas.DataFrame): dataframe with generalized weights and generalized classes - """ - - rcls_df = _reclass_gen(weights_df, studentized_contrast) - wgts_gen = gen_weights_finalization(rcls_df) - wgts_fnl = _weights_cleanup(wgts_gen, weight_type) - return wgts_fnl - - -def _reclass_gen(df: pd.DataFrame, studentized_contrast: float = 2) -> pd.DataFrame: - """Performs reclassification of classes into favourable and unfavourable categories for ordianl data, based on studentized contrast values provided by the user. - Args: - df (pandas.DataFrame): The dataframe with all the weights calculations; obtained from the contrast function - studentized_contrast (float, def = 2): The threshold for studentized contrast for reclassification - Returns: - df_rcls (pandas.DataFrame): The dataframe with data classes categorized as favourable and unfavourable - Raises: - UnFavorableClassDoesntExistException: Failure to generalize classes using the given studentised contrast threshold value. Class 1 (unfavorable class) doesn't exist - FavorableClassDoesntExistException: Failure to generalize classes using the given studentised contrast threshold value. Class 2 (favorable class) doesn't exist - """ - - df["Rcls"] = df.Stud_Cont.ge(studentized_contrast)[::-1].cummax() + 1 - - df_studentized_contrast = df[["Class", "contrast", "Stud_Cont", "Rcls"]].round(4) - - if 1 not in df["Rcls"].values: - print(df_studentized_contrast) - raise exceptions.UnFavorableClassDoesntExistException( - """Exception error: Class doesn't exist. - For the given studentized contrast value, none of the classes were classified to the 'Unfavorable' class, i.e., class 1. - Check the displayed studentized contrast values ('Stud_Cont') and run weights calculations again using a suitable threshold value.""" - ) - - elif 2 not in df["Rcls"].values: - print(df_studentized_contrast) - raise exceptions.FavorableClassDoesntExistException( - """Exception error: Class doesn't exist. - For the given studentized contrast value none of the classes were classified to the 'Favorable' class, i.e., class 2. - Check the displayed studentized contrast values ('Stud_Cont') and run weights calculations again using a suitable threshold value.""" - ) - - else: - df_ = df.round(4).sort_values(by="Class", ascending=True) - return df_ - - -def gen_weights_finalization(df: pd.DataFrame) -> pd.DataFrame: - """Calls the gen_weights function and calculates positives weights of associations for each generalized class - - Args: - df (pd.DataFrame): Dataframe with weights of associations - Returns: - df (pd.DataFrame): Dataframe with positives weights of associations for generalized classes - """ - gen_cls = [1, 2] - gw_1, gw_2 = map(functools.partial(gen_weights, df), gen_cls) - gw = pd.concat([gw_1, gw_2]) - for i, clss in enumerate(gen_cls): - w = gw.iloc[i, 31] - s_w = gw.iloc[i, 33] - v_w = gw.iloc[i, 32] - df.loc[df.Rcls == clss, "W_Gen"] = w - df.loc[df.Rcls == clss, "s_wpls_gen"] = s_w - df.loc[df.Rcls == clss, "var_wpls_gen"] = v_w - df.round(4) - return df - - -def gen_weights(df: pd.DataFrame, gen_cls: int) -> pd.DataFrame: - """_summary_ - Args: - df (pd.DataFrame): - gen_cls (int): List of generalized class values - Returns: - df_gen_wgts (pd.DataFrame): Dataframe with positives weights of associations for generalized classes - Raises: - - """ - df_rc = df.groupby("Rcls") - df_rc_ = df_rc.get_group(gen_cls) - df_gen_wgts = ( - df_rc_.assign(cmltv_dep_cnt=lambda df_rc_: df_rc_.Point_Count.cumsum()) - .assign(cmltv_cnt=lambda df_rc_: df_rc_.Count.cumsum()) - .assign(cmltv_no_dep_cnt=lambda df_rc_: df_rc_.No_Dep_Cnt.cumsum()) - .iloc[[-1]] - ) - - return ( - df_gen_wgts.assign(Num_wpls=lambda df_gen_wgts: df_gen_wgts.cmltv_dep_cnt / df_gen_wgts.Total_Deposits) - .assign(Deno_wpls=lambda df_gen_wgts: df_gen_wgts.cmltv_no_dep_cnt / df_gen_wgts.Tot_No_Dep_Cnt) - .assign(W_Gen=lambda df_gen_wgts: np.log(df_gen_wgts.Num_wpls) - np.log(df_gen_wgts.Deno_wpls)) - .assign(var_wpls_gen=lambda df_gen_wgts: (1 / df_gen_wgts.cmltv_dep_cnt) + (1 / df_gen_wgts.cmltv_no_dep_cnt)) - .assign(s_wpls_gen=lambda df_gen_wgts: np.sqrt(df_gen_wgts.var_wpls_gen)) - ) - - -def _weights_arrays(evidential_raster: rasterio.io.DatasetReader, weights_df: pd.DataFrame, col_names: List) -> Tuple[List, dict]: - """Calls the raster_arrays function to convert the generalized weights dataaframe to numpy arrays. - - Args: - evidential_raster (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the deposit_raster. - weights_df (pd.DataFrame): Dataframe with the weights. - col_names (List): Columns to generate the arrays from. - - Returns: - gen_arrys (List): List of individual raster object arrays for generalized or unique classes, generalized weights and standard deviation of generalized weights - raster_meta (dict): Raster array's metadata. - """ - raster_meta = evidential_raster.meta.copy() - list_cols = list(weights_df.columns) - nan_row = {val: -1.0e09 for val in list_cols} - nan_row_df = pd.DataFrame.from_dict(nan_row, orient="index") - nan_row_df_t = nan_row_df.T - weights_df_nan = pd.concat([nan_row_df_t, weights_df]) - class_rstr, w_gen_rstr, std_rstr = map(functools.partial(_raster_array, evidential_raster, weights_df_nan), col_names) - gen_arrys = [class_rstr, w_gen_rstr, std_rstr] - return gen_arrys, raster_meta - - -def _raster_array(evidential_raster: rasterio.io.DatasetReader, weights_df_nan: pd.DataFrame, col: str) -> np.ndarray: - """Converts the generalized weights dataframe to numpy arrays with the extent and shape of the input raster - - Args: - evidential_raster (rasterio.io.DatasetReader): The evidential raster with spatial resolution and extent identical to that of the deposit_raster. - weights_df_nan (pd.DataFrame): Generalized weights dataframe with info on NaN data also. - col (str): Columns to use for generation of raster object arrays. - - Returns: - np.ndarray: Individual raster object arrays for generalized or unique classes, generalized weights and standard deviation of generalized weights - """ - # raster_meta = evidential_raster.meta.copy() - raster_array = np.array(evidential_raster.read(1)) - weights_mapping_dict = {} - weights_mapping_dict = pd.Series(weights_df_nan.loc[:, col], index=weights_df_nan.Class).to_dict() - replace_array = np.array([list(weights_mapping_dict.keys()), list(weights_mapping_dict.values())]) - raster_array_wgts = raster_array.reshape(-1) - mask_array = np.isin(raster_array_wgts, replace_array[0, :]) - ss_rplc_array = np.searchsorted(replace_array[0, :], raster_array_wgts[mask_array]) - raster_array_replaced = replace_array[1, ss_rplc_array] - raster_array_replaced = raster_array_replaced.reshape(raster_array.shape) - return raster_array_replaced diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb index b792d40d..37297743 100644 --- a/notebooks/weights_of_evidence.ipynb +++ b/notebooks/weights_of_evidence.ipynb @@ -1,403 +1,667 @@ { "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Basic implementation of weights of evidence for predictive mapping of mineral deposits" - ] - }, { "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "sys.path.insert(0, \"..\")" - ] - }, - { - "cell_type": "code", - "execution_count": 41, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import rasterio\n", - "import pandas as pd\n", - "from rasterio import Affine\n", "from matplotlib import pyplot as plt\n", "from rasterio.plot import show\n", - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "test_ev = rasterio.open(\"../tests/data/remote/wofe/wofe_ev_nan.tif\")\n", - "test_dep = rasterio.open(\"../tests/data/remote/wofe/wofe_dep_nan_.tif\")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Weights Calculations - Use the weights_calculations function" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [], - "source": [ - "from eis_toolkit.prediction.weights_of_evidence.calculate_weights import calculate_weights " - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Calculate weights for weights type - Unique" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [], - "source": [ - "test_wgt_un_, test_gen_un_, test_rst_meta = calculate_weights(test_ev, test_dep, -1000000000.0, 0, 2)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Calculate weights for weights type - Cumulative Ascending" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [], - "source": [ - "test_wgt_asc_, test_gen_asc_, test_rst_meta = calculate_weights(test_ev, test_dep, -1000000000.0, 1, 2)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Calculate weights for weights type - Cumulative Descending" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [], - "source": [ - "test_wgt_dsc_, test_gen_dsc_, test_rst_meta = calculate_weights(test_ev, test_dep, -1000000000.0, 2, 2)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Optional: Save results to csv " - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "tab_names = ['test_wgt_un_', 'test_wgt_asc_', 'test_wgt_dsc_']\n", - "weights_tables = [test_wgt_un_, test_wgt_asc_, test_wgt_dsc_]" + "import geopandas as gpd\n", + "\n", + "import sys\n", + "sys.path.insert(0, \"..\")\n", + "\n", + "from eis_toolkit.prediction.wofe_new import weights_of_evidence" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "for tab_name, tab in zip(tab_names, weights_tables):\n", - " tab.to_csv(f'../tests/data/{tab_name}.csv')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot arrays: Example - Generalized weights for weights type 'Unique'" + "# with rasterio.open(\"../tests/data/remote/wofe/wofe_ev_nan.tif\") as test_ev:\n", + "# with rasterio.open(\"../tests/data/remote/wofe/wofe_dep_nan_.tif\") as test_dep:\n", + "with rasterio.open(\"../tests/data/local/Int_wofe_ev_nan.tif\") as test_ev:\n", + " # with rasterio.open(\"../tests/data/local/wofe_dep_new.tif\") as test_dep:\n", + " gdf = gpd.read_file(\"../tests/data/local/Dep1s.shp\")\n", + " test_wgt_un_, test_gen_un_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='unique')\n", + " test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='ascending', studentized_contrast_threshold=1)\n", + " test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='descending', studentized_contrast_threshold=1)" ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ClassPixel countDeposit countW+S_W+W-S_W-ContrastS_ContrastStudentized contrast
01.027590.48100.3389-0.39940.38060.88040.50961.7275
12.01100.00000.00000.00000.00000.00000.00000.0000
23.03965-0.49200.45010.34090.3059-0.83290.5442-1.5306
35.04310.12961.0118-0.00810.26090.13771.04490.1318
46.0100.00000.00000.00000.00000.00000.00000.0000
58.04300.00000.00000.00000.00000.00000.00000.0000
610.0213.86731.4142-0.06320.26073.93051.43802.7332
713.01000.00000.00000.00000.00000.00000.00000.0000
\n", + "
" + ], "text/plain": [ - "" + " Class Pixel count Deposit count W+ S_W+ W- S_W- \\\n", + "0 1.0 275 9 0.4810 0.3389 -0.3994 0.3806 \n", + "1 2.0 11 0 0.0000 0.0000 0.0000 0.0000 \n", + "2 3.0 396 5 -0.4920 0.4501 0.3409 0.3059 \n", + "3 5.0 43 1 0.1296 1.0118 -0.0081 0.2609 \n", + "4 6.0 1 0 0.0000 0.0000 0.0000 0.0000 \n", + "5 8.0 43 0 0.0000 0.0000 0.0000 0.0000 \n", + "6 10.0 2 1 3.8673 1.4142 -0.0632 0.2607 \n", + "7 13.0 10 0 0.0000 0.0000 0.0000 0.0000 \n", + "\n", + " Contrast S_Contrast Studentized contrast \n", + "0 0.8804 0.5096 1.7275 \n", + "1 0.0000 0.0000 0.0000 \n", + "2 -0.8329 0.5442 -1.5306 \n", + "3 0.1377 1.0449 0.1318 \n", + "4 0.0000 0.0000 0.0000 \n", + "5 0.0000 0.0000 0.0000 \n", + "6 3.9305 1.4380 2.7332 \n", + "7 0.0000 0.0000 0.0000 " ] }, - "execution_count": 47, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Generalized weights\")\n", - "clrbar = ax.imshow(test_gen_un_[1], cmap='terrain')\n", - "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_un_[1], ax = ax, transform = test_ev.transform, cmap='terrain')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot arrays: Example - Generalized weights for weights type 'Cumulative Ascending'" + "# UNIQUE\n", + "test_wgt_un_" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ClassPixel countDeposit countW+S_W+W-S_W-ContrastS_ContrastStudentized contrastGeneralized classGeneralized W+Generalized S_W+
01.027590.48100.3389-0.39940.38060.88040.50961.727520.48100.3389
12.028690.44050.3387-0.37710.38070.81760.50951.60461-0.39940.3806
23.0682140.00210.2700-0.01430.71440.01630.76370.02141-0.39940.3806
35.0725150.01010.2609-0.14001.00900.15011.04220.14401-0.39940.3806
46.0726150.00870.2609-0.12171.00920.13041.04240.12511-0.39940.3806
58.076915-0.05010.26081.46941.0445-1.51941.0765-1.41141-0.39940.3806
610.077116-0.05070.26071.55471.0536-1.60541.0854-1.47911-0.39940.3806
713.078116-0.06260.26063.86731.4213-3.92991.4450-2.71961-0.39940.3806
\n", + "
" + ], "text/plain": [ - "" + " Class Pixel count Deposit count W+ S_W+ W- S_W- \\\n", + "0 1.0 275 9 0.4810 0.3389 -0.3994 0.3806 \n", + "1 2.0 286 9 0.4405 0.3387 -0.3771 0.3807 \n", + "2 3.0 682 14 0.0021 0.2700 -0.0143 0.7144 \n", + "3 5.0 725 15 0.0101 0.2609 -0.1400 1.0090 \n", + "4 6.0 726 15 0.0087 0.2609 -0.1217 1.0092 \n", + "5 8.0 769 15 -0.0501 0.2608 1.4694 1.0445 \n", + "6 10.0 771 16 -0.0507 0.2607 1.5547 1.0536 \n", + "7 13.0 781 16 -0.0626 0.2606 3.8673 1.4213 \n", + "\n", + " Contrast S_Contrast Studentized contrast Generalized class \\\n", + "0 0.8804 0.5096 1.7275 2 \n", + "1 0.8176 0.5095 1.6046 1 \n", + "2 0.0163 0.7637 0.0214 1 \n", + "3 0.1501 1.0422 0.1440 1 \n", + "4 0.1304 1.0424 0.1251 1 \n", + "5 -1.5194 1.0765 -1.4114 1 \n", + "6 -1.6054 1.0854 -1.4791 1 \n", + "7 -3.9299 1.4450 -2.7196 1 \n", + "\n", + " Generalized W+ Generalized S_W+ \n", + "0 0.4810 0.3389 \n", + "1 -0.3994 0.3806 \n", + "2 -0.3994 0.3806 \n", + "3 -0.3994 0.3806 \n", + "4 -0.3994 0.3806 \n", + "5 -0.3994 0.3806 \n", + "6 -0.3994 0.3806 \n", + "7 -0.3994 0.3806 " ] }, - "execution_count": 48, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Generalized weights\")\n", - "clrbar = ax.imshow(test_gen_asc_[1], cmap='viridis')\n", - "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_asc_[1], ax = ax, transform = test_ev.transform, cmap='viridis')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot arrays: Example - Generalized weights for weights type 'Cumulative Descending'" + "# ASCENDING\n", + "test_wgt_asc_" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ClassPixel countDeposit countW+S_W+W-S_W-ContrastS_ContrastStudentized contrastGeneralized classGeneralized W+Generalized S_W+
013.01000.00000.00000.00000.00000.00000.00000.000021.46941.0445
110.01211.46941.0445-0.05010.26081.51941.07651.411421.46941.0445
28.0551-0.12171.00920.00870.2609-0.13041.0424-0.12511-0.05010.2608
36.0561-0.14001.00900.01010.2609-0.15011.0422-0.14401-0.05010.2608
45.0992-0.01430.71440.00210.2700-0.01630.7637-0.02141-0.05010.2608
53.04957-0.37710.38070.44050.3387-0.81760.5095-1.60461-0.05010.2608
62.05067-0.39940.38060.48100.3389-0.88040.5096-1.72751-0.05010.2608
71.078116-0.06260.26063.86731.4213-3.92991.4450-2.71961-0.05010.2608
\n", + "
" + ], "text/plain": [ - "" + " Class Pixel count Deposit count W+ S_W+ W- S_W- \\\n", + "0 13.0 10 0 0.0000 0.0000 0.0000 0.0000 \n", + "1 10.0 12 1 1.4694 1.0445 -0.0501 0.2608 \n", + "2 8.0 55 1 -0.1217 1.0092 0.0087 0.2609 \n", + "3 6.0 56 1 -0.1400 1.0090 0.0101 0.2609 \n", + "4 5.0 99 2 -0.0143 0.7144 0.0021 0.2700 \n", + "5 3.0 495 7 -0.3771 0.3807 0.4405 0.3387 \n", + "6 2.0 506 7 -0.3994 0.3806 0.4810 0.3389 \n", + "7 1.0 781 16 -0.0626 0.2606 3.8673 1.4213 \n", + "\n", + " Contrast S_Contrast Studentized contrast Generalized class \\\n", + "0 0.0000 0.0000 0.0000 2 \n", + "1 1.5194 1.0765 1.4114 2 \n", + "2 -0.1304 1.0424 -0.1251 1 \n", + "3 -0.1501 1.0422 -0.1440 1 \n", + "4 -0.0163 0.7637 -0.0214 1 \n", + "5 -0.8176 0.5095 -1.6046 1 \n", + "6 -0.8804 0.5096 -1.7275 1 \n", + "7 -3.9299 1.4450 -2.7196 1 \n", + "\n", + " Generalized W+ Generalized S_W+ \n", + "0 1.4694 1.0445 \n", + "1 1.4694 1.0445 \n", + "2 -0.0501 0.2608 \n", + "3 -0.0501 0.2608 \n", + "4 -0.0501 0.2608 \n", + "5 -0.0501 0.2608 \n", + "6 -0.0501 0.2608 \n", + "7 -0.0501 0.2608 " ] }, - "execution_count": 49, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAAK5CAYAAACMta6pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAABNP0lEQVR4nO3de5xVdb038O/AwIAgIyqXGUVANEhERfQIGKJxE0nLylumKNrJE6bmIR951Ec0X2pK59jNSl+G8eAtG7RSjzBTkHbASwom3iIvoFzkaMJQJoPMev7oYcdm5gczw4YZ4P1+vfbrtfda3/Vbv7V/ay34zNp77aIsy7IAAACgjlbN3QEAAICWSmACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAtiJ/PGPf4wLLrgg+vTpE+3bt4/27dvHwQcfHF/96lfjD3/4Q3N3r6DuvvvuKCoqirfeeis37bzzzotevXrt8L706tUrzjvvvB2+3k299dZbUVRUFHfffXeTli8qKoqLL754q3Xz5s2LKVOmxOrVq5u0HoBdjcAEsJP4yU9+EoMGDYqnn346Lr300njkkUfi0UcfjcsuuyxeeumlOProo+P1119v7m5uV9dcc0089NBDzd2NZlFWVhbz58+PcePGbdf1zJs3L6677jqBCeD/K27uDgCwdf/93/8dX/va12LcuHHxi1/8Itq2bZub9+lPfzomTpwYDz74YLRv374Ze7llH374Yeyxxx7b1EafPn0K1JudT0lJSQwePLi5uwGw23GFCWAncOONN0br1q3jJz/5SV5Y2tRpp50W5eXledP+8Ic/xCmnnBJ77713tGvXLgYOHBg///nP82o2fvRtzpw58W//9m+x7777xj777BOf//znY/ny5XXW88ADD8SQIUOiQ4cO0bFjxxgzZkwsWLAgr+a8886Ljh07xosvvhijR4+OPffcM0aMGBEREZWVlfHZz3429t9//2jXrl0cdNBB8dWvfjXee++9rb4Pm38kb8qUKVFUVFTvY9OP0NXU1MQNN9wQ/fr1i5KSkujSpUucf/758T//8z957a9fvz6uuOKK6N69e+yxxx7xqU99Kp555pmt9isi4uijj65z9WfAgAFRVFQUzz77bG7azJkzo6ioKF588cXctMWLF8eXvvSl6Nq1a5SUlMQnP/nJ+OEPf5jXVuojeb/85S/jsMMOi5KSkjjwwAPju9/9bu59qc///b//Nz75yU/GHnvsEYcffng88sgjee/nN7/5zYiI6N27d+69nDt3bkRE/Pa3v43jjz8+9tlnn2jfvn0ccMAB8YUvfCE+/PDDBr1HADsjV5gAWrgNGzbEnDlz4qijjoqysrIGLzdnzpw48cQT45hjjokf//jHUVpaGvfff3+cccYZ8eGHH9b5Ts6FF14Y48aNi3vvvTfefvvt+OY3vxlf/vKX47e//W2u5sYbb4yrr746zj///Lj66qujpqYmbr311hg2bFg888wzccghh+Rqa2pq4pRTTomvfvWrceWVV8bHH38cERGvv/56DBkyJC688MIoLS2Nt956K/7jP/4jPvWpT8WLL74Ybdq0afA2XnjhhXHiiSfmTZs5c2bceuut0b9//4iIqK2tjc9+9rPx5JNPxhVXXBFDhw6NJUuWxLXXXhvHH398/OEPf8hdmfvKV74S06dPj0mTJsWoUaNi0aJF8fnPfz7Wrl271b6MHDkyfvCDH8T69eujTZs28e6778aiRYuiffv2UVlZGUcffXRERFRVVUW3bt1iwIABERHx8ssvx9ChQ+OAAw6I73znO9G9e/eYNWtWXHLJJfHee+/Ftddem1zn448/Hp///OfjuOOOiwceeCA+/vjjmDp1arz77rv11j/66KPx7LPPxvXXXx8dO3aMW265JU499dR47bXX4sADD4wLL7ww/vKXv8T3v//9mDlzZm5/O+SQQ+Ktt96KcePGxbBhw+KnP/1p7LXXXrFs2bJ4/PHHo6amZpuvHgK0WBkALdrKlSuziMjOPPPMOvM+/vjjbP369blHbW1tbl6/fv2ygQMHZuvXr89b5jOf+UxWVlaWbdiwIcuyLJs2bVoWEdnXvva1vLpbbrkli4hsxYoVWZZl2dKlS7Pi4uLs61//el7d2rVrs+7du2enn356btr48eOziMh++tOfbnHbamtrs/Xr12dLlizJIiL75S9/mZu3sV9vvvlmXrs9e/ZMtvfkk09m7dq1y84+++zce3HfffdlEZFVVFTk1T777LNZRGS33357lmVZ9sorr2QRkX3jG9/Iq7vnnnuyiMjGjx+/xW2pqqrKIiJ74oknsizLshkzZmR77rln9rWvfS074YQTcnUHH3xw9qUvfSn3esyYMdn++++frVmzJq+9iy++OGvXrl32l7/8JcuyLHvzzTeziMimTZuWqzn66KOzHj16ZOvWrctNW7t2bbbPPvtkm/8THxFZt27dsurq6ty0lStXZq1atcpuuumm3LRbb721zvueZVn2i1/8IouIbOHChVt8HwB2NbvlR/KeeOKJOPnkk6O8vDyKiori4YcfbnQbWZbF1KlT4xOf+ESUlJREjx494sYbbyx8ZwG2YNCgQdGmTZvc4zvf+U5ERPz5z3+OV199Nc4+++yIiPj4449zj5NOOilWrFgRr732Wl5bp5xySt7rww47LCIilixZEhERs2bNio8//jjOPffcvPbatWsXw4cPz31sa1Nf+MIX6kxbtWpVXHTRRdGjR48oLi6ONm3aRM+ePSMi4pVXXmnye/HKK6/EKaecEkOHDo2f/vSnuY+kPfLII7HXXnvFySefnNfvI444Irp3757r95w5cyIicu/ZRqeffnoUF2/9AxnHHntstGvXLqqqqiLiHx89PP744+PEE0+MefPmxYcffhhvv/12LF68OEaOHBkRER999FH85je/iVNPPTX22GOPOuP00UcfxVNPPVXv+v72t7/FH/7wh/jc5z6X9zHNjh07xsknn1zvMieccELsueeeudfdunWLrl275sZ4S4444oho27Zt/Ou//mv87Gc/izfeeGOrywDsCnbLj+T97W9/i8MPPzzOP//8ev8xb4hLL700Zs+eHVOnTo0BAwbEmjVrGvT5e4DG2nfffaN9+/b1/qf23nvvjQ8//DBWrFiRF3g2fiRr0qRJMWnSpHrb3fyctc8+++S9LikpiYiIv//973ltbvxo2eZatcr/G9wee+wRnTp1yptWW1sbo0ePjuXLl8c111wTAwYMiA4dOkRtbW0MHjw4t67GWr58eZx44omx//77x8yZM/MCxLvvvhurV69Ofvdr4/vw/vvvR0RE9+7d8+YXFxfXeW/q065duzj22GOjqqoqrrvuuvjNb34TV1xxRRx//PGxYcOGePLJJ2PZsmUREbnA9P7778fHH38c3//+9+P73//+Fvu3uQ8++CCyLItu3brVmVfftIi6Yxzxj3FuyPvep0+fqKqqiltuuSUmTpwYf/vb3+LAAw+MSy65JC699NKtLg+ws9otA9PYsWNj7Nixyfk1NTVx9dVXxz333BOrV6+OQw89NL797W/H8ccfHxH/+Cvmj370o1i0aFH07dt3B/Ua2F21bt06Pv3pT8fs2bNjxYoVed9j2vidoU1/qyjiHyErImLy5Mnx+c9/vt52G3v+2tjmL37xi9wVoS2p76YDixYtihdeeCHuvvvuGD9+fG76n//850b1ZVPV1dVx0kknRW1tbTz22GNRWlpap9/77LNPPP744/Uuv/GKy8YwsXLlythvv/1y8z/++ONcmNqaESNGxP/5P/8nnnnmmXjnnXdi1KhRseeee8bRRx8dlZWVsXz58vjEJz4RPXr0iIiIzp07R+vWreOcc86JiRMn1ttm7969653euXPnKCoqqvf7SitXrmxQfxtr2LBhMWzYsNiwYUP84Q9/iO9///tx2WWXRbdu3eLMM8/cLusEaG67ZWDamvPPPz/eeuutuP/++6O8vDweeuihOPHEE+PFF1+Mgw8+OH7961/HgQceGI888kiceOKJkWVZjBw5Mm655ZbYe++9m7v7wC5o8uTJ8V//9V9x0UUXxS9+8Yut3hihb9++cfDBB8cLL7xQsI8LjxkzJoqLi+P1119v8tX5jSFq49WrjX7yk580qb2ampo49dRT46233orf//73sf/++9ep+cxnPhP3339/bNiwIY455phkWxv/KHbPPffEoEGDctN//vOf525YsTUjR46M//2//3dcc801sf/++0e/fv1y03/1q1/FypUr8967PfbYI0444YRYsGBBHHbYYcmrYPXp0KFDHHXUUfHwww/H1KlTc8v+9a9/zbvzXWNtfmWxPq1bt45jjjkm+vXrF/fcc088//zzAhOwyxKYNvP666/HfffdF++8807u9ryTJk2Kxx9/PKZNmxY33nhjvPHGG7FkyZJ48MEHY/r06bFhw4b4xje+EV/84hfz7iYFUCjHHnts/PCHP4yvf/3rceSRR8a//uu/Rv/+/aNVq1axYsWKqKioiIjI+wjcT37ykxg7dmyMGTMmzjvvvNhvv/3iL3/5S7zyyivx/PPPx4MPPtioPvTq1Suuv/76uOqqq+KNN96IE088MTp37hzvvvtuPPPMM9GhQ4e47rrrtthGv379ok+fPnHllVdGlmWx9957x69//euorKxs/JsSEd/4xjfit7/9bdx4443x17/+Ne/7Pl26dIk+ffrEmWeeGffcc0+cdNJJcemll8a//Mu/RJs2beKdd96JOXPmxGc/+9k49dRT45Of/GR8+ctfjttuuy3atGkTI0eOjEWLFsXUqVPrfLQwZdCgQdG5c+eYPXt2nH/++bnpI0eOjG9961u555v67ne/G5/61Kdi2LBh8W//9m/Rq1evWLt2bfz5z3+OX//611v8d+X666+PcePGxZgxY+LSSy+NDRs2xK233hodO3aMv/zlL415K3M23r3vu9/9bowfPz7atGkTffv2jXvuuSd++9vfxrhx4+KAAw6Ijz76KH7605/Wu00Au5TmvedE84uI7KGHHsq9/vnPf55FRNahQ4e8R3Fxce4OUF/5yleyiMhee+213HLPPfdcFhHZq6++uqM3AdiNLFy4MDv//POz3r17ZyUlJVm7du2ygw46KDv33HOz3/zmN3XqX3jhhez000/PunbtmrVp0ybr3r179ulPfzr78Y9/nKvZeDe6Z599Nm/ZOXPmZBGRzZkzJ2/6ww8/nJ1wwglZp06dspKSkqxnz57ZF7/4xayqqipXM378+KxDhw71bsPLL7+cjRo1Kttzzz2zzp07Z6eddlq2dOnSLCKya6+9tk6/tnSXvOHDh2cRUe9j07varV+/Pps6dWp2+OGHZ+3atcs6duyY9evXL/vqV7+aLV68OFe3bt267N///d+zrl27Zu3atcsGDx6czZ8/P+vZs+dW75K30amnnppFRHbPPffkptXU1GQdOnTIWrVqlX3wwQd1lnnzzTezCRMmZPvtt1/Wpk2brEuXLtnQoUOzG264Ia8mNrtLXpZl2UMPPZQNGDAga9u2bXbAAQdkN998c3bJJZdknTt3zquLiGzixIl11l3ftk2ePDkrLy/PWrVqldsH5s+fn5166qlZz549s5KSkmyfffbJhg8fnv3qV79q0PsCsLMqyrIs29EhrSUpKiqKhx56KD73uc9FxD9+kPHss8+Ol156KVq3bp1X27Fjx+jevXtce+21ceONN8b69etz8/7+97/HHnvsEbNnz45Ro0btyE0AgJz169fHEUccEfvtt1/Mnj27ubsDsNPzkbzNDBw4MDZs2BCrVq2KYcOG1Vtz7LHHxscffxyvv/569OnTJyIi/vSnP0VENOiL0ABQKBdccEGMGjUqysrKYuXKlfHjH/84Xnnllfjud7/b3F0D2CXsloHpr3/9a94dmd58881YuHBh7L333vGJT3wizj777Dj33HPjO9/5TgwcODDee++9+O1vfxsDBgyIk046KUaOHBlHHnlkTJgwIW677baora2NiRMnxqhRo+ITn/hEM24ZALubtWvXxqRJk+J//ud/ok2bNnHkkUfGY4895ntFAAWyW34kb+7cuXHCCSfUmT5+/Pi4++67Y/369XHDDTfE9OnTY9myZbHPPvvEkCFD4rrrrst9GXb58uXx9a9/PWbPnh0dOnSIsWPHxne+8x13yQMAgF3IbhmYAAAAGqLV1ksAAAB2TwITAABAwm5104fa2tpYvnx57LnnnrlfmwcAAHY/WZbF2rVro7y8PFq1Sl9H2q0C0/Lly6NHjx7N3Q0AAKCFePvtt2P//fdPzt+tAtOee+4ZEf94Uzp16tTMvQEAAJpLdXV19OjRI5cRUnarwLTxY3idOnUSmAAAgK1+VcdNHwAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASChu7g6Qb1Sr05q7C/x/s5YvbO4ubNGY8iOauwtbVFn7YHN3AQBgm7nCBAAAkNCowNSrV68oKiqq85g4cWK99XPnzq23/tVXX83V3HnnnTFs2LDo3LlzdO7cOUaOHBnPPPNMXjtTpkyp00b37t2bsLkAAAAN16iP5D377LOxYcOG3OtFixbFqFGj4rTTtvwxstdeey06deqUe92lS5fc87lz58ZZZ50VQ4cOjXbt2sUtt9wSo0ePjpdeein222+/XF3//v2jqqoq97p169aN6ToAAECjNSowbRp0IiJuvvnm6NOnTwwfPnyLy3Xt2jX22muveufdc889ea/vvPPO+MUvfhG/+c1v4txzz/1nR4uLXVUCAAB2qCZ/h6mmpiZmzJgREyZMiKKioi3WDhw4MMrKymLEiBExZ86cLdZ++OGHsX79+th7773zpi9evDjKy8ujd+/eceaZZ8Ybb7yx1T6uW7cuqqur8x4AAAAN1eTA9PDDD8fq1avjvPPOS9aUlZXFHXfcERUVFTFz5szo27dvjBgxIp544onkMldeeWXst99+MXLkyNy0Y445JqZPnx6zZs2KO++8M1auXBlDhw6N999/f4t9vOmmm6K0tDT36NGjR6O3EwAA2H0VZVmWNWXBMWPGRNu2bePXv/51o5Y7+eSTo6ioKH71q1/VmXfLLbfEzTffHHPnzo3DDjss2cbf/va36NOnT1xxxRVx+eWXJ+vWrVsX69aty72urq6OHj16xJo1a/K+U9WSuK14y+G24tvGbcUBgJasuro6SktLt5oNmvQ7TEuWLImqqqqYOXNmo5cdPHhwzJgxo870qVOnxo033hhVVVVbDEsRER06dIgBAwbE4sWLt1hXUlISJSUlje4jAABARBM/kjdt2rTo2rVrjBs3rtHLLliwIMrKyvKm3XrrrfGtb30rHn/88TjqqKO22sa6devilVdeqdMOAABAITX6ClNtbW1MmzYtxo8fH8XF+YtPnjw5li1bFtOnT4+IiNtuuy169eoV/fv3z90koqKiIioqKnLL3HLLLXHNNdfEvffeG7169YqVK1dGRETHjh2jY8eOERExadKkOPnkk+OAAw6IVatWxQ033BDV1dUxfvz4Jm84AADA1jQ6MFVVVcXSpUtjwoQJdeatWLEili5dmntdU1MTkyZNimXLlkX79u2jf//+8eijj8ZJJ52Uq7n99tujpqYmvvjFL+a1de2118aUKVMiIuKdd96Js846K957773o0qVLDB48OJ566qno2bNnY7sPAADQYE2+6cPOqKFf7GpObvrQcrjpw7Zx0wcAoCVraDZo8m3FAQAAdnUCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQ4HeYWpjalQcXtL2W/Fs9Lf13jnY3LXlfYdfmN7sAaA5+hwkAAGAbCUwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQEJRlmVZc3diR6muro7S0tJYs2ZNdOrUqbm7U69RrU5r7i7stGYtX9jcXWATY8qPaO4uQItTWftgc3cBgP+vodnAFSYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASCjKsixr7k7sKNXV1VFaWhpr1qyJTp06NXd36lW78uDm7gK0OGPKj2juLgBNUFn7YHN3ASCpodnAFSYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIKG4uTtAvjHlRxS0vVnLFxa0PWgOLX0/LvRxC7uKUa1Oa+4u7FCVtQ82dxeA7cAVJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIKG7uDgDs7GYtX1jQ9saUH1HQ9oAdY1Sr05q7CztMZe2Dzd0F2GFcYQIAAEhoVGDq1atXFBUV1XlMnDix3vq5c+fWW//qq6/mau68884YNmxYdO7cOTp37hwjR46MZ555pk5bt99+e/Tu3TvatWsXgwYNiieffLKRmwoAANA4jQpMzz77bKxYsSL3qKysjIiI007b8iXo1157LW+5gw8+ODdv7ty5cdZZZ8WcOXNi/vz5ccABB8To0aNj2bJluZoHHnggLrvssrjqqqtiwYIFMWzYsBg7dmwsXbq0Md0HAABolKIsy7KmLnzZZZfFI488EosXL46ioqI68+fOnRsnnHBCfPDBB7HXXns1qM0NGzZE586d4wc/+EGce+65ERFxzDHHxJFHHhk/+tGPcnWf/OQn43Of+1zcdNNNDe5vdXV1lJaWxpo1a6JTp04NXm5HKvTnnwv93Qpg+/MdJqCl8x0mdgUNzQZN/g5TTU1NzJgxIyZMmFBvWNrUwIEDo6ysLEaMGBFz5szZYu2HH34Y69evj7333ju3nueeey5Gjx6dVzd69OiYN2/eFttat25dVFdX5z0AAAAaqsmB6eGHH47Vq1fHeeedl6wpKyuLO+64IyoqKmLmzJnRt2/fGDFiRDzxxBPJZa688srYb7/9YuTIkRER8d5778WGDRuiW7dueXXdunWLlStXbrGPN910U5SWluYePXr0aPgGAgAAu70m31b8rrvuirFjx0Z5eXmypm/fvtG3b9/c6yFDhsTbb78dU6dOjeOOO65O/S233BL33XdfzJ07N9q1a5c3b/OrWFmWbfXK1uTJk+Pyyy/Pva6urhaaAACABmtSYFqyZElUVVXFzJkzG73s4MGDY8aMGXWmT506NW688caoqqqKww47LDd93333jdatW9e5mrRq1ao6V502V1JSEiUlJY3uIwAAQEQTP5I3bdq06Nq1a4wbN67Ryy5YsCDKysrypt16663xrW99Kx5//PE46qij8ua1bds2Bg0alLsj30aVlZUxdOjQxnceAACggRp9ham2tjamTZsW48ePj+Li/MUnT54cy5Yti+nTp0dExG233Ra9evWK/v37524SUVFRERUVFbllbrnllrjmmmvi3nvvjV69euWuJHXs2DE6duwYERGXX355nHPOOXHUUUfFkCFD4o477oilS5fGRRdd1OQNBwAA2JpGB6aqqqpYunRpTJgwoc68FStW5P02Uk1NTUyaNCmWLVsW7du3j/79+8ejjz4aJ510Uq7m9ttvj5qamvjiF7+Y19a1114bU6ZMiYiIM844I95///24/vrrY8WKFXHooYfGY489Fj179mxs9wEAABpsm36HaWfjd5iAnYHfYQJaOr/DxK5gu/8OEwAAwK5OYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEvwOUwtTu/LggrZXyN9z8ZtONJdC/y7R7rYv+10ngJbF71i1DH6HCQAAYBsJTAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAQnFzd4B8Y8qPaO4u7DCF3tZZyxcWtL2WrqXvK7vbeABAQ41qdVpzd2GHqax9sLm7sM1cYQIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACAhKIsy7Lm7sSOUl1dHaWlpbFmzZro1KlTc3enXrUrDy5oe2PKjyhoe4U0a/nCgrZX6G1t6f3bnRR6LNg29mUAmktl7YMFa6uh2cAVJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIKG7uDrB9zVq+sLm7kDSm/Ijm7sJOrdBjW+jxaMn7HgBAQ7nCBAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJxc3dAfKNKT+ioO3NWr6woO3tTozFtink+7e7vXcAQMvhChMAAEBCowJTr169oqioqM5j4sSJ9dbPnTu33vpXX301V/PSSy/FF77whVzbt912W512pkyZUqeN7t27N25LAQAAGqlRH8l79tlnY8OGDbnXixYtilGjRsVpp522xeVee+216NSpU+51ly5dcs8//PDDOPDAA+O0006Lb3zjG8k2+vfvH1VVVbnXrVu3bkzXAQAAGq1RgWnToBMRcfPNN0efPn1i+PDhW1yua9eusddee9U77+ijj46jjz46IiKuvPLKdEeLi11VAgAAdqgmf4eppqYmZsyYERMmTIiioqIt1g4cODDKyspixIgRMWfOnCatb/HixVFeXh69e/eOM888M954442tLrNu3bqorq7OewAAADRUkwPTww8/HKtXr47zzjsvWVNWVhZ33HFHVFRUxMyZM6Nv374xYsSIeOKJJxq1rmOOOSamT58es2bNijvvvDNWrlwZQ4cOjffff3+Ly910001RWlqae/To0aNR6wUAAHZvTb6t+F133RVjx46N8vLyZE3fvn2jb9++uddDhgyJt99+O6ZOnRrHHXdcg9c1duzY3PMBAwbEkCFDok+fPvGzn/0sLr/88uRykydPzptfXV0tNAEAAA3WpMC0ZMmSqKqqipkzZzZ62cGDB8eMGTOastqcDh06xIABA2Lx4sVbrCspKYmSkpJtWhcAALD7atJH8qZNmxZdu3aNcePGNXrZBQsWRFlZWVNWm7Nu3bp45ZVXtrkdAACALWn0Faba2tqYNm1ajB8/PoqL8xefPHlyLFu2LKZPnx4REbfddlv06tUr+vfvn7tJREVFRVRUVOSWqampiZdffjn3fNmyZbFw4cLo2LFjHHTQQRERMWnSpDj55JPjgAMOiFWrVsUNN9wQ1dXVMX78+CZvOAAAwNY0OjBVVVXF0qVLY8KECXXmrVixIpYuXZp7XVNTE5MmTYply5ZF+/bto3///vHoo4/GSSedlKtZvnx5DBw4MPd66tSpMXXq1Bg+fHjMnTs3IiLeeeedOOuss+K9996LLl26xODBg+Opp56Knj17Nrb7AAAADVaUZVnW3J3YUaqrq6O0tDTWrFmT90O6LcmoVlv+EeDGmrV8YUHbK6Qx5Uc0dxd2qJY8FhEtezxa+nu3u2nJ+woAu7bK2gcL1lZDs0GTbysOAACwqxOYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAICERv9wLdtXS/69Gb+9sm28f+wqWvJ5KqKwx1qht9V5AGDn4woTAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQUN3cHyDem/Ijm7gLbyazlC5u7C1tU6H2vkNvbkvtGy9OS9z0Adj6uMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACcXN3QF2X7OWL2zuLuxQY8qPaO4ubFFLHo+W3Dd2bYXe91r6eaCla+nnAuMLuyZXmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgobi5O0C+WcsXNncXdpgx5UcUtL3d6b2LaPnbW8jxbenbCuwYhf53A6AhXGECAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgITi5u4A+caUH1HQ9mYtX1iwtlpy33YGu9v2tmSF3pcLzb6ybQo5vi19LArdv5Z+bNB09hVoOleYAAAAEhoVmHr16hVFRUV1HhMnTqy3fu7cufXWv/rqq7mal156Kb7whS/k2r7tttvqbev222+P3r17R7t27WLQoEHx5JNPNqbrAAAAjdaowPTss8/GihUrco/KysqIiDjttNO2uNxrr72Wt9zBBx+cm/fhhx/GgQceGDfffHN079693uUfeOCBuOyyy+Kqq66KBQsWxLBhw2Ls2LGxdOnSxnQfAACgURr1HaYuXbrkvb755pujT58+MXz48C0u17Vr19hrr73qnXf00UfH0UcfHRERV155Zb01//Ef/xEXXHBBXHjhhRERcdttt8WsWbPiRz/6Udx0002N2QQAAIAGa/J3mGpqamLGjBkxYcKEKCoq2mLtwIEDo6ysLEaMGBFz5sxp9Hqee+65GD16dN700aNHx7x587a47Lp166K6ujrvAQAA0FBNDkwPP/xwrF69Os4777xkTVlZWdxxxx1RUVERM2fOjL59+8aIESPiiSeeaPB63nvvvdiwYUN069Ytb3q3bt1i5cqVW1z2pptuitLS0tyjR48eDV4vAABAk28rftddd8XYsWOjvLw8WdO3b9/o27dv7vWQIUPi7bffjqlTp8Zxxx3XqPVtfhUry7KtXtmaPHlyXH755bnX1dXVQhMAANBgTQpMS5Ysiaqqqpg5c2ajlx08eHDMmDGjwfX77rtvtG7dus7VpFWrVtW56rS5kpKSKCkpaXQfAQAAIpr4kbxp06ZF165dY9y4cY1edsGCBVFWVtbg+rZt28agQYNyd+TbqLKyMoYOHdro9QMAADRUo68w1dbWxrRp02L8+PFRXJy/+OTJk2PZsmUxffr0iPjH3ex69eoV/fv3z90koqKiIioqKnLL1NTUxMsvv5x7vmzZsli4cGF07NgxDjrooIiIuPzyy+Occ86Jo446KoYMGRJ33HFHLF26NC666KImbzgAAMDWNDowVVVVxdKlS2PChAl15q1YsSLvt5Fqampi0qRJsWzZsmjfvn30798/Hn300TjppJNyNcuXL4+BAwfmXk+dOjWmTp0aw4cPj7lz50ZExBlnnBHvv/9+XH/99bFixYo49NBD47HHHouePXs2tvsAAAAN1ujANHr06MiyrN55d999d97rK664Iq644oottterV69ke5v62te+Fl/72tca3E8AAIBt1eTbigMAAOzqBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIKHRv8PE9jVr+cKCtjem/IiCtgfNwX68a2vJ49uS+xbR8vtHy2FfgaZzhQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEoqbuwPkG1N+REHbm7V8YUHb250Yi21TyO0t9Fi0dLvb9kJzKfR52bELuyZXmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgobi5O0C+WcsXFrS9MeVHFKytQvetpdvdtrfQCrnvAUS0/PNyS+6fczI0nStMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJBQ3NwdIN+Y8iOauwtJhe7brOULC9re7qYl7yuwq9jdzlMt/bzi36GmK/S2tvR9BQrJFSYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASChu7g6w+xpTfkRB25u1fGFB2yu0Qm8vQEvX0s/LNF2hx9a/kbRkjbrC1KtXrygqKqrzmDhxYr31c+fOrbf+1VdfzaurqKiIQw45JEpKSuKQQw6Jhx56KG/+lClT6rTRvXv3Rm4qAABA4zTqCtOzzz4bGzZsyL1etGhRjBo1Kk477bQtLvfaa69Fp06dcq+7dOmSez5//vw444wz4lvf+laceuqp8dBDD8Xpp58ev//97+OYY47J1fXv3z+qqqpyr1u3bt2YrgMAADRaowLTpkEnIuLmm2+OPn36xPDhw7e4XNeuXWOvvfaqd95tt90Wo0aNismTJ0dExOTJk+N3v/td3HbbbXHffff9s6PFxa4qAQAAO1STb/pQU1MTM2bMiAkTJkRRUdEWawcOHBhlZWUxYsSImDNnTt68+fPnx+jRo/OmjRkzJubNm5c3bfHixVFeXh69e/eOM888M954442t9nHdunVRXV2d9wAAAGioJgemhx9+OFavXh3nnXdesqasrCzuuOOOqKioiJkzZ0bfvn1jxIgR8cQTT+RqVq5cGd26dctbrlu3brFy5crc62OOOSamT58es2bNijvvvDNWrlwZQ4cOjffff3+LfbzpppuitLQ09+jRo0fTNhYAANgtNfkueXfddVeMHTs2ysvLkzV9+/aNvn375l4PGTIk3n777Zg6dWocd9xxuembX6HKsixv2tixY3PPBwwYEEOGDIk+ffrEz372s7j88suT6588eXLe/OrqaqEJAABosCYFpiVLlkRVVVXMnDmz0csOHjw4ZsyYkXvdvXv3vKtJERGrVq2qc9VpUx06dIgBAwbE4sWLt7iukpKSKCkpaXQfAQAAIpr4kbxp06ZF165dY9y4cY1edsGCBVFWVpZ7PWTIkKisrMyrmT17dgwdOjTZxrp16+KVV17JawcAAKDQGn2Fqba2NqZNmxbjx4+P4uL8xSdPnhzLli2L6dOnR8Q/7oDXq1ev6N+/f+4mERUVFVFRUZFb5tJLL43jjjsuvv3tb8dnP/vZ+OUvfxlVVVXx+9//PlczadKkOPnkk+OAAw6IVatWxQ033BDV1dUxfvz4pm43AADAVjU6MFVVVcXSpUtjwoQJdeatWLEili5dmntdU1MTkyZNimXLlkX79u2jf//+8eijj8ZJJ52Uqxk6dGjcf//9cfXVV8c111wTffr0iQceeCDvN5jeeeedOOuss+K9996LLl26xODBg+Opp56Knj17Nrb7AAAADVaUZVnW3J3YUaqrq6O0tDTWrFmT90O6LcmoVlv+EWDSZi1f2Nxd2KIx5Uc0dxeARmrp55VCK/R5and7/2g6/0bSUJW1DxasrYZmgybfVhwAAGBXJzABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQEJxc3eAfIX8Ma5Ca+k/qtvSf3Cxpf+Aox8NZFfR0o+1lsx7B1CXK0wAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQEJxc3eAnUdl7YPN3YUdalSr0wra3qzlCwvaHuwqHBsAtGSuMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAQnFzdwBaqsraB5u7CzvYac3dgaRZyxc2dxe2aEz5Ec3dhZ1aod+/lr6/wK7AeY/diStMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJBQ3NwdAFqGytoHm7sLO0ztyoObuwtAE4wpP6Kg7c1avrCg7bVkhX7vYHfiChMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJBQ3dwcAdrRW3RcXtL3K2oI21+KNanVac3eB3dSs5QsL2l6hzwUt2e52noJCcoUJAAAgoVGBqVevXlFUVFTnMXHixHrr586dW2/9q6++mldXUVERhxxySJSUlMQhhxwSDz30UJ22br/99ujdu3e0a9cuBg0aFE8++WRjug4AANBojQpMzz77bKxYsSL3qKysjIiI007b8sczXnvttbzlDj744Ny8+fPnxxlnnBHnnHNOvPDCC3HOOefE6aefHk8//XSu5oEHHojLLrssrrrqqliwYEEMGzYsxo4dG0uXLm1M9wEAABqlKMuyrKkLX3bZZfHII4/E4sWLo6ioqM78uXPnxgknnBAffPBB7LXXXvW2ccYZZ0R1dXX813/9V27aiSeeGJ07d4777rsvIiKOOeaYOPLII+NHP/pRruaTn/xkfO5zn4ubbrqpwf2trq6O0tLSWLNmTXTq1KnBywHwTy39O0yF/p4Lu67d6TtMQF0NzQZN/g5TTU1NzJgxIyZMmFBvWNrUwIEDo6ysLEaMGBFz5szJmzd//vwYPXp03rQxY8bEvHnzcut57rnn6tSMHj06V5Oybt26qK6uznsAAAA0VJMD08MPPxyrV6+O8847L1lTVlYWd9xxR1RUVMTMmTOjb9++MWLEiHjiiSdyNStXroxu3brlLdetW7dYuXJlRES89957sWHDhi3WpNx0001RWlqae/To0aORWwkAAOzOmnxb8bvuuivGjh0b5eXlyZq+fftG3759c6+HDBkSb7/9dkydOjWOO+643PTNr1BlWVZnWkNqNjd58uS4/PLLc6+rq6uFJgAAoMGaFJiWLFkSVVVVMXPmzEYvO3jw4JgxY0budffu3etcKVq1alXuitK+++4brVu33mJNSklJSZSUlDS6jwAAABFN/EjetGnTomvXrjFu3LhGL7tgwYIoKyvLvR4yZEjubnsbzZ49O4YOHRoREW3bto1BgwbVqamsrMzVAAAAbA+NvsJUW1sb06ZNi/Hjx0dxcf7ikydPjmXLlsX06dMjIuK2226LXr16Rf/+/XM3iaioqIiKiorcMpdeemkcd9xx8e1vfzs++9nPxi9/+cuoqqqK3//+97mayy+/PM4555w46qijYsiQIXHHHXfE0qVL46KLLmrqdgMAAGxVowNTVVVVLF26NCZMmFBn3ooVK/J+G6mmpiYmTZoUy5Yti/bt20f//v3j0UcfjZNOOilXM3To0Lj//vvj6quvjmuuuSb69OkTDzzwQBxzzDG5mjPOOCPef//9uP7662PFihVx6KGHxmOPPRY9e/ZsbPcBAAAabJt+h2ln43eYALad32FiV+F3mGD3tt1/hwkAAGBXJzABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAmN/uFaAHZvlbUPNncXAGCHcYUJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgobu4O7EhZlkVERHV1dTP3BAAAaE4bM8HGjJCyWwWmtWvXRkREjx49mrknAABAS7B27dooLS1Nzi/KthapdiG1tbWxfPny2HPPPaOoqKi5u7Nbqq6ujh49esTbb78dnTp1au7u7PaMR8thLFoOY9GyGI+Ww1i0LMZj22VZFmvXro3y8vJo1Sr9TaXd6gpTq1atYv/992/ubhARnTp1cnC3IMaj5TAWLYexaFmMR8thLFoW47FttnRlaSM3fQAAAEgQmAAAABIEJnaokpKSuPbaa6OkpKS5u0IYj5bEWLQcxqJlMR4th7FoWYzHjrNb3fQBAACgMVxhAgAASBCYAAAAEgQmAACABIEJAAAgQWAi6aabboqioqK47LLLctNmzpwZY8aMiX333TeKiopi4cKFdZZbt25dfP3rX4999903OnToEKecckq88847eTUffPBBnHPOOVFaWhqlpaVxzjnnxOrVq/Nqli5dGieffHJ06NAh9t1337jkkkuipqYmr+bFF1+M4cOHR/v27WO//faL66+/PnbV+5g0dTyOP/74KCoqynuceeaZeTXGo3E2H4v169fH//pf/ysGDBgQHTp0iPLy8jj33HNj+fLlecs5NraPpo6HY6Pw6jtPTZkyJfr16xcdOnSIzp07x8iRI+Ppp5/OW86xUXhNHQvHxfZR33hs6qtf/WoUFRXFbbfdljfdsdFCZFCPZ555JuvVq1d22GGHZZdeemlu+vTp07Prrrsuu/POO7OIyBYsWFBn2Ysuuijbb7/9ssrKyuz555/PTjjhhOzwww/PPv7441zNiSeemB166KHZvHnzsnnz5mWHHnpo9pnPfCY3/+OPP84OPfTQ7IQTTsief/75rLKyMisvL88uvvjiXM2aNWuybt26ZWeeeWb24osvZhUVFdmee+6ZTZ06dbu8J81pW8Zj+PDh2Ve+8pVsxYoVucfq1avzaoxHw9U3FqtXr85GjhyZPfDAA9mrr76azZ8/PzvmmGOyQYMG5S3r2Ci8bRkPx0Zhpc5T99xzT1ZZWZm9/vrr2aJFi7ILLrgg69SpU7Zq1apcjWOjsLZlLBwXhZcaj40eeuih7PDDD8/Ky8uz//zP/8yb59hoGQQm6li7dm128MEHZ5WVldnw4cPrPbjffPPNev+Dvnr16qxNmzbZ/fffn5u2bNmyrFWrVtnjjz+eZVmWvfzyy1lEZE899VSuZv78+VlEZK+++mqWZVn22GOPZa1atcqWLVuWq7nvvvuykpKSbM2aNVmWZdntt9+elZaWZh999FGu5qabbsrKy8uz2trabX4fWoptGY8sy5LLbGQ8Gq4hY7HRM888k0VEtmTJkizLHBvbw7aMR5Y5NgqpMWOxZs2aLCKyqqqqLMscG4W2LWORZY6LQtvaeLzzzjvZfvvtly1atCjr2bNnXmBybLQcPpJHHRMnToxx48bFyJEjG73sc889F+vXr4/Ro0fnppWXl8ehhx4a8+bNi4iI+fPnR2lpaRxzzDG5msGDB0dpaWlezaGHHhrl5eW5mjFjxsS6deviueeey9UMHz487wfbxowZE8uXL4+33nqr0X1vqbZlPDa65557Yt99943+/fvHpEmTYu3atbl5xqPhGjMWa9asiaKiothrr70iwrGxPWzLeGzk2CiMho5FTU1N3HHHHVFaWhqHH354RDg2Cm1bxmIjx0XhbGk8amtr45xzzolvfvOb0b9//zrzHRstR3Fzd4CW5f7774/nn38+nn322SYtv3Llymjbtm107tw5b3q3bt1i5cqVuZquXbvWWbZr1655Nd26dcub37lz52jbtm1eTa9eveqsZ+O83r17N2kbWpJtHY+IiLPPPjt69+4d3bt3j0WLFsXkyZPjhRdeiMrKyogwHg3VmLH46KOP4sorr4wvfelL0alTp4hwbBTato5HhGOjUBoyFo888kiceeaZ8eGHH0ZZWVlUVlbGvvvuGxGOjULa1rGIcFwU0tbG49vf/nYUFxfHJZdcUu98x0bLITCR8/bbb8ell14as2fPjnbt2hW07SzLoqioKPd60+eFrMn+/5cT61t2Z1Oo8fjKV76Se37ooYfGwQcfHEcddVQ8//zzceSRR0aE8diaxozF+vXr48wzz4za2tq4/fbbt9q2Y6PxCjUejo1t19CxOOGEE2LhwoXx3nvvxZ133hmnn356PP300/X+R28jx0bjFGosHBeFsbXxeO655+K73/1uPP/8843eXsfGjucjeeQ899xzsWrVqhg0aFAUFxdHcXFx/O53v4vvfe97UVxcHBs2bNhqG927d4+ampr44IMP8qavWrUq95eK7t27x7vvvltn2f/5n//Jq9n4V4+NPvjgg1i/fv0Wa1atWhURUecvKTujQoxHfY488sho06ZNLF68OCKMR0M0dCzWr18fp59+erz55ptRWVmZdzXDsVE4hRiP+jg2Gq+hY9GhQ4c46KCDYvDgwXHXXXdFcXFx3HXXXRHh2CiUQoxFfRwXTbO18Zg7d26sWrUqDjjggNz8JUuWxL//+7/nrvQ4NloOgYmcESNGxIsvvhgLFy7MPY466qg4++yzY+HChdG6deuttjFo0KBo06ZN7tJ9RMSKFSti0aJFMXTo0IiIGDJkSKxZsyaeeeaZXM3TTz8da9asyatZtGhRrFixIlcze/bsKCkpiUGDBuVqnnjiibzbYs6ePTvKy8vrXFbeGRViPOrz0ksvxfr166OsrCwijEdDNGQsNv7nfPHixVFVVRX77LNPXhuOjcIpxHjUx7HReE09T2VZFuvWrYsIx0ahFGIs6uO4aJqtjcd5550Xf/zjH/Pml5eXxze/+c2YNWtWRDg2WpQddHMJdlKb39Hl/fffzxYsWJA9+uijWURk999/f7ZgwYJsxYoVuZqLLroo23///bOqqqrs+eefzz796U/XewvMww47LJs/f342f/78bMCAAfXeAnPEiBHZ888/n1VVVWX7779/3i0wV69enXXr1i0766yzshdffDGbOXNm1qlTp136FpiNHY8///nP2XXXXZc9++yz2Ztvvpk9+uijWb9+/bKBAwcaj2206VisX78+O+WUU7L9998/W7hwYd7teNetW5dbxrGx/TR2PBwb28+mY/HXv/41mzx5cjZ//vzsrbfeyp577rnsggsuyEpKSrJFixbllnFsbB+NHQvHxfa1tTsQbn6XvCxzbLQUAhNbtPnBPW3atCwi6jyuvfbaXM3f//737OKLL8723nvvrH379tlnPvOZbOnSpXntvv/++9nZZ5+d7bnnntmee+6ZnX322dkHH3yQV7NkyZJs3LhxWfv27bO99947u/jii/Nud5llWfbHP/4xGzZsWFZSUpJ17949mzJlyi59+8vGjsfSpUuz4447Ltt7772ztm3bZn369MkuueSS7P33389r13g03qZjsfG27vU95syZk1vGsbH9NHY8HBvbz6Zj8fe//z079dRTs/Ly8qxt27ZZWVlZdsopp2TPPPNM3jKOje2jsWPhuNi+mhKYHBstQ1GW+QlfAACA+vgOEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACcXN3YEd7aOPPoqamprm7gYAANDM2rZtG+3atdtizW4VmD766KMobd85auKj5u4KAADQzLp37x5vvvnmFkPTbhWYampqoiY+ik/FSVEcbSKK/vmJxKJWRbHJi8T0TZ4nphe1apWoT0zfdNlN1ptqv2FtRv3Tk202YL3RuPchy6tJ9Cev/aYs/8+nWQO2v0E1iXVlqfc01YdWiel59Yl1xabTN3neKtWfBrRZqPrNP8TbgLYaVr8t0xvy/m6HPkQDajadnqjflv5sU01Dl48C1WzTNmQNqGlsHzZpMxKSbWb11jRkXY1ts86h1JB1R6qt+re0qCHr3qSmKO/51vuWV59Yb/KfueR66182Vd8qGtKHTeobMD2vzVTNZu95al5RA2qSzyNVU5tYV2rZf9a3Tra/aZv/7HPrvPei/vXmt5moSU3fpM1N+986b12b9P+fXdtsemJbEuvdvE9560v1Y9O2Eu3k9yn1vqfWu/U+tE6McaqmKDEGrRP71qbT82vin8/z+vBPrfP2m6JEzabTt/48vz7/Pyr5da3qTK9eWxs9B70VNTU1AtPmiqNNFBdtFpgSASI1vUGhpyHLtkosu02BKfkvz9b71pD1tpjA1Lj6nSYwpf4TtJMGpsIFo9T0hry/27cPu3RgakhNNKBmm7ZzOwemxLbs0oGpQdPrX2866GxLYGpcANqmwNSQ+h0cmNKhp/CBqSH1DQtMqf80b9/AlAwqDQhG6enbJzC1ztu2f+54rTbZCTednv8ebTq9/vr8PmxakwpeUX9NXj8bUrP1wNR6OwSm/Pr635+GB6bG3cbBTR8AAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACAhOLm7kBz+DjWR2QRm+bFoqxok4rU9E2eJ6YXZa3qnR6p6bWbLFuUqClKPN807+bVRP3Tk202YL2p6Vn907O8mkR/8tpvyvKbdmPT97QBbSbeo/xh2nTZRvahVWJ6chfaZF2x6fRNnrdK9acBbRaqfvM/sTSgrYbVb8v0hry/26EP0YCaxG5cqP5sU01Dl48C1WzTNmQNqGlsHzZpMxKSbWb11jRkXY1ts86h1JB1R6qt+re0qCHr3qSmKO/51vuWV59Yb+qfhiy53vqXTdVnUX8fahP1rRowvVU0oGaz9zw1r6gBNcnnkaqprXd6UaSW/Wd962T7m7b5zz63znsv6l9vfpuJmtT0TdrctP+t89a1Sf//2bXNpie2JbHezfuUt75UPzZtK9FOfp9S73tqvVvvQ+vEGKdqihJj0Dqxb206Pb8m/vk8rw//1DpvvylK1Gw6fevP8+vz5dfV7V/12tpoiN0qMLVt2za6d+8ev1/52D8mbHpMbGiWLgEAAM2ke/fu0bZt2y3WFGVZlvzj2q7oo48+ipqamubuBs2ouro6evToEW+//XZ06tSpubtDC2G/YHP2Cepjv6A+9oudV9u2baNdu3ZbrNmtrjBFRLRr126rbwq7h06dOjmpUYf9gs3ZJ6iP/YL62C92TW76AAAAkCAwAQAAJAhM7HZKSkri2muvjZKSkubuCi2I/YLN2Seoj/2C+tgvdm273U0fAAAAGsoVJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIGJnd7tt98evXv3jnbt2sWgQYPiySefTNauWLEivvSlL0Xfvn2jVatWcdlll9VbV1FREYccckiUlJTEIYccEg899NB26j3bS6H3i7vvvjuKiorqPD766KPtuBUUWmP2i5kzZ8aoUaOiS5cu0alTpxgyZEjMmjWrTp3zxc6t0PuEc8WuoTH7xe9///s49thjY5999on27dtHv3794j//8z/r1DlX7LwEJnZqDzzwQFx22WVx1VVXxYIFC2LYsGExduzYWLp0ab3169atiy5dusRVV10Vhx9+eL018+fPjzPOOCPOOeeceOGFF+Kcc86J008/PZ5++untuSkU0PbYLyIiOnXqFCtWrMh7tGvXbnttBgXW2P3iiSeeiFGjRsVjjz0Wzz33XJxwwglx8sknx4IFC3I1zhc7t+2xT0Q4V+zsGrtfdOjQIS6++OJ44okn4pVXXomrr746rr766rjjjjtyNc4VO7kMdmL/8i//kl100UV50/r165ddeeWVW112+PDh2aWXXlpn+umnn56deOKJedPGjBmTnXnmmdvUV3ac7bFfTJs2LSstLS1QD2kO27JfbHTIIYdk1113Xe6188XObXvsE84VO79C7Bennnpq9uUvfzn32rli5+YKEzutmpqaeO6552L06NF500ePHh3z5s1rcrvz58+v0+aYMWO2qU12nO21X0RE/PWvf42ePXvG/vvvH5/5zGfq/FWZlqsQ+0VtbW2sXbs29t5779w054ud1/baJyKcK3ZmhdgvFixYEPPmzYvhw4fnpjlX7NwEJnZa7733XmzYsCG6deuWN71bt26xcuXKJre7cuXKgrfJjrO99ot+/frF3XffHb/61a/ivvvui3bt2sWxxx4bixcv3tYuswMUYr/4zne+E3/729/i9NNPz01zvth5ba99wrli57Yt+8X+++8fJSUlcdRRR8XEiRPjwgsvzM1zrti5FTd3B2BbFRUV5b3OsqzOtJbQJjtWocdw8ODBMXjw4NzrY489No488sj4/ve/H9/73vea3C47VlP3i/vuuy+mTJkSv/zlL6Nr164FaZOWodD7hHPFrqEp+8WTTz4Zf/3rX+Opp56KK6+8Mg466KA466yztqlNWgaBiZ3WvvvuG61bt67z15lVq1bV+StOY3Tv3r3gbbLjbK/9YnOtWrWKo48+2l+NdxLbsl888MADccEFF8SDDz4YI0eOzJvnfLHz2l77xOacK3Yu27Jf9O7dOyIiBgwYEO+++25MmTIlF5icK3ZuPpLHTqtt27YxaNCgqKyszJteWVkZQ4cObXK7Q4YMqdPm7Nmzt6lNdpzttV9sLsuyWLhwYZSVlRWsTbafpu4X9913X5x33nlx7733xrhx4+rMd77YeW2vfWJzzhU7l0L9G5JlWaxbty732rliJ9dMN5uAgrj//vuzNm3aZHfddVf28ssvZ5dddlnWoUOH7K233sqyLMuuvPLK7JxzzslbZsGCBdmCBQuyQYMGZV/60peyBQsWZC+99FJu/n//939nrVu3zm6++ebslVdeyW6++easuLg4e+qpp3bottF022O/mDJlSvb4449nr7/+erZgwYLs/PPPz4qLi7Onn356h24bTdfY/eLee+/NiouLsx/+8IfZihUrco/Vq1fnapwvdm7bY59wrtj5NXa/+MEPfpD96le/yv70pz9lf/rTn7Kf/vSnWadOnbKrrroqV+NcsXMTmNjp/fCHP8x69uyZtW3bNjvyyCOz3/3ud7l548ePz4YPH55XHxF1Hj179syrefDBB7O+fftmbdq0yfr165dVVFTsgC2hkAq9X1x22WXZAQcckLVt2zbr0qVLNnr06GzevHk7aGsolMbsF8OHD693vxg/fnxem84XO7dC7xPOFbuGxuwX3/ve97L+/ftne+yxR9apU6ds4MCB2e23355t2LAhr03nip1XUZZl2Y69pgUAALBz8B0mAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASPh/vVrgwOsD1LQAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Generalized weights\")\n", - "clrbar = ax.imshow(test_gen_dsc_[1], cmap='viridis')\n", - "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_dsc_[1], ax = ax, transform = test_ev.transform, cmap='viridis')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Optional: Use the following function to save the arrays as a Geotif file. Example given below. By default the raster will be stored in the notebooks directory. " - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "def arry_tif (out_meta, rstr_name, rst_arr, indx):\n", - " rst_cls = rasterio.open(rstr_name, 'w', **out_meta)\n", - " rst_cls.write(rst_arr[indx], 1)\n", - " rst_cls.close()\n", - " test_tf = rasterio.open(rstr_name)\n", - " show(test_tf, 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "out_meta = test_ev.meta.copy()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "arry_tif(out_meta, 'rst_clss_dsc_.tif', test_gen_dsc_, 0) #saves the generalized classes\n", - "arry_tif(out_meta, 'rst_gen_wgts_dsc_.tif', test_gen_dsc_, 1) #saves the generalized weights of the generalized classes\n", - "arry_tif(out_meta, 'rst_gen_std_dsc_.tif', test_gen_dsc_, 2) #saves the standard deviations of the generalized weights " - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Integration of generalized weights rasters to calculate the posterior probabilities - use the 'calculate_responses' function" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "from eis_toolkit.prediction.weights_of_evidence.calculate_responses import calculate_responses" + "# DESCENDING\n", + "test_wgt_dsc_" ] }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "test_wgts_arr = [test_gen_un_, test_gen_asc_, test_gen_dsc_]" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "t_pprb_array, t_pprb_std, t_pprb_conf, array_meta = calculate_responses(test_dep, test_wgts_arr)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting the Posterior Probability Raster" - ] - }, - { - "cell_type": "code", - "execution_count": 18, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 18, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAAK5CAYAAACMta6pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAABIiUlEQVR4nO3df5xVdb0v/vdmRgbix6jJjxkFIbIxBypELz/6KhIKgempU4bmVYg6jzxp6fFwzpGHlmhdUaMO5zxKT3iNIky93UE7hSeFkrDE9Cocf6Qc+iGj/AjlCoOZDM6s7x9dt2xnPjB72Mwe5fl8PPbjsffan89nvdf+rDXDi7VnrVyWZVkAAADQRo9yFwAAANBdCUwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAJTEd7/73cjlcvlHZWVlHHPMMfHpT386Nm3aVLL15HK5uOSSS0o23rPPPhu5XC4WLFiw37avb+Ozzz6bXzZr1qwYNmxYQbthw4bFrFmz8q83b94c8+bNi3Xr1pWmaAC6TGW5CwDg7WXx4sVx/PHHx5///OdYvXp1zJ8/P37xi1/EE088EX369Cl3eQfkzDPPjDVr1kRNTc0+2911113Rv3///OvNmzfHNddcE8OGDYsPfOADB7lKAEpJYAKgpEaOHBknnXRSRERMmjQpWlpa4itf+Urcfffdcf7557dp/8orr8Q73vGOri6zUwYMGBADBgzYb7vRo0d3QTUAdAVfyQPgoBo3blxERGzcuDFmzZoVffv2jSeeeCKmTJkS/fr1i8mTJ0dExP/9v/83Pv/5z8fRRx8dPXv2jHe9611x5ZVXxu7du9sd99vf/na85z3viaqqqjjhhBPijjvuKHj/hRdeiM9//vNxwgknRN++fWPgwIHxoQ99KB544IF2x2ttbY3/8T/+RwwdOjR69eoVJ510UvzsZz8raNPeV/Las/dX8latWhUnn3xyRER8+tOfzn9lcd68efH9738/crlcrFmzps0Y1157bRx22GGxefPmfa4LgIPLGSYADqrf/va3EfGXszP/9V//Fc3NzXH22WfH5z73ubjiiivitddei1dffTUmTZoUv/vd7+Kaa66J973vffHAAw/E/PnzY926dbF8+fKCMf/93/897r///rj22mujT58+cdNNN8V5550XlZWV8YlPfCIi/hLAIiKuvvrqGDx4cLz88stx1113xWmnnRY/+9nP4rTTTisY85vf/GYce+yxsXDhwmhtbY0bb7wxpk2bFr/4xS9i/Pjxnd7+E088MRYvXhyf/vSn46qrroozzzwzIiKOOeaYGDhwYPzjP/5jfOtb3ypYx2uvvRbf/va342Mf+1jU1tZ2et0AHDiBCYCSamlpyYegX/ziF/HVr341+vXrF2effXb86le/ij179sSXv/zl+PSnP53v8+1vfzsef/zx+F//63/FOeecExERZ5xxRvTt2zf+6Z/+KVasWBFnnHFGvv2LL74YjzzySAwaNCgiIqZPnx4jR46MuXPn5gNTXV1d3HTTTQV1TZ06NZ599tn413/91zaBqaWlJVasWBG9evWKiIipU6fGsGHD4stf/nKsWLGi059H//79Y+TIkRERMWLEiPwZt9d97nOfi/nz58c3vvGNGDhwYERELFu2LDZv3lzSi1sA0DmH5FfyVq9eHWeddVbU1tZGLpeLu+++u+gxsiyLBQsW5L8OMmTIkLjuuutKXyzAW8y4cePisMMOi379+sVHPvKRGDx4cPzHf/xHPtxERHz84x8v6PPzn/88+vTpkw87r3v9a21v/mrc5MmTC8arqKiIGTNmxG9/+9t4/vnn88v/7d/+LU488cTo1atXVFZWxmGHHRY/+9nP4umnn25T91//9V/nw1JERL9+/eKss86K1atXR0tLS/EfRAf97d/+bURE3HLLLfll3/zmN2PUqFFx6qmnHrT1AtAxh2Rg+tOf/hTvf//745vf/Ganx7j00kvjf/7P/xkLFiyIZ555Jn784x/Hf/tv/62EVQK8NS1ZsiQeeeSRWLt2bWzevDkef/zx+OAHP5h//x3veEfBFeQiIrZv3x6DBw+OXC5XsHzgwIFRWVkZ27dvL1g+ePDgNut9fdnrbb/xjW/E3/7t38bYsWOjoaEhHnrooXjkkUfiwx/+cPz5z39O9n/zsubm5nj55Zc7uPXFGzRoUMyYMSO+/e1vR0tLSzz++OPxwAMPOLsE0E0ckl/JmzZtWkybNi35fnNzc1x11VVx2223xY4dO2LkyJFxww035L++8fTTT8fNN98cTz75ZNTV1XVR1QBvDe9973vzV8lrz5tDUUTEO9/5zvj1r38dWZYVvL9t27Z47bXX4qijjipov3Xr1jZjvL7sne98Z0RELF26NE477bS4+eabC9rt2rWr3bpSY/bs2TP69u2b3J5SuPTSS+P73/9+/OhHP4qf/vSncfjhh7d7RUEAut4heYZpfz796U/Hr371q7jjjjvi8ccfj3POOSc+/OEPx4YNGyIi4sc//nG8613vip/85CcxfPjwGDZsWHz2s5/N/4ExAMWZPHlyvPzyy22+Ir1kyZL8+3v72c9+Fn/84x/zr1taWuLOO++MESNGxDHHHBMRfwlmVVVVBf0ef/zxdq9IF/GXvxt69dVX86937doVP/7xj+OUU06JioqKTm9bROTraO/MVkTEmDFjYsKECXHDDTfEbbfdFrNmzXrL37MK4O3ikDzDtC+/+93v4vbbb4/nn38+f2WiOXPmxE9/+tNYvHhxXHfddfH73/8+Nm7cGD/84Q9jyZIl0dLSEn/3d38Xn/jEJ+LnP/95mbcA4K3nwgsvjG9961sxc+bMePbZZ2PUqFHxy1/+Mq677rqYPn16nH766QXtjzrqqPjQhz4UX/rSl/JXyXvmmWcKLi3+kY98JL7yla/E1VdfHRMnToz169fHtddeG8OHD4/XXnutTQ0VFRVxxhlnxOWXXx6tra1xww03RFNTU1xzzTUHvH0jRoyI3r17x2233Rbvfe97o2/fvlFbW1twBbxLL700ZsyYEblcLj7/+c8f8DoBKA2B6U0ee+yxyLIs3vOe9xQs3717d/5rHq2trbF79+5YsmRJvt2tt94aY8aMifXr1/uaHkCRevXqFffff39ceeWV8bWvfS1eeOGFOProo2POnDlx9dVXt2l/9tlnR319fVx11VXR2NgYI0aMiNtuuy1mzJiRb3PllVfGK6+8ErfeemvceOONccIJJ8S//du/xV133RWrVq1qM+Yll1wSr776anzxi1+Mbdu2RX19fSxfvrzg76866x3veEd85zvfiWuuuSamTJkSe/bsiauvvjrmzZuXb/PRj340qqqqYtKkSXHccccd8DoBKI1clmVZuYsop1wuF3fddVd89KMfjYiIO++8M84///x46qmn2nwFo2/fvjF48OC4+uqr47rrros9e/bk3/vzn/8c73jHO+K+++4ruPQtAHTEj3/84zj77LNj+fLlMX369HKXA8D/4wzTm4wePTpaWlpi27Ztccopp7Tb5oMf/GC89tpr8bvf/S5GjBgRERH/9V//FRERxx57bJfVCsBb329+85vYuHFj/P3f/3184AMf2OdFiQDoeofkGaaXX345f+f50aNHxze+8Y2YNGlSHHnkkTF06ND47//9v8evfvWr+PrXvx6jR4+OF198MX7+85/HqFGjYvr06dHa2honn3xy9O3bN39H+Isvvjj69+8f9913X5m3DoC3ktNOOy1+9atfxYknnhjf+9734vjjjy93SQDs5ZAMTKtWrYpJkya1WT5z5sz47ne/G3v27ImvfvWrsWTJkti0aVO8853vjPHjx8c111wTo0aNioiIzZs3xxe+8IW47777ok+fPjFt2rT4+te/HkceeWRXbw4AAHCQHJKBCQAAoCPchwkAACBBYAIAAEg4pK6S19raGps3b45+/fpFLpcrdzkAAECZZFkWu3btitra2ujRI30e6ZAKTJs3b44hQ4aUuwwAAKCbeO655+KYY45Jvn9IBaZ+/fpFxF8+lP79+5e5GgAAoFyamppiyJAh+YyQckgFpte/hte/f3+BCQAA2O+f6rjoAwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACZXlLoBCU6tnl7sE/p/c0Npyl7BPWePmcpewT/fu/E65SwAAOGDOMAEAACQUFZiGDRsWuVyuzePiiy9ut/2qVavabf/MM8/k29xyyy1xyimnxBFHHBFHHHFEnH766fHwww8XjDNv3rw2YwwePLgTmwsAANBxRX0l75FHHomWlpb86yeffDLOOOOMOOecc/bZb/369dG/f//86wEDBuSfr1q1Ks4777yYMGFC9OrVK2688caYMmVKPPXUU3H00Ufn29XX18fKlSvzrysqKoopHQAAoGhFBaa9g05ExPXXXx8jRoyIiRMn7rPfwIED4/DDD2/3vdtuu63g9S233BL/+3//7/jZz34WF1544RuFVlY6qwQAAHSpTv8NU3NzcyxdujRmz54duVxun21Hjx4dNTU1MXny5Lj//vv32faVV16JPXv2xJFHHlmwfMOGDVFbWxvDhw+Pc889N37/+9/vt8bdu3dHU1NTwQMAAKCjOh2Y7r777tixY0fMmjUr2aampiYWLVoUDQ0NsWzZsqirq4vJkyfH6tWrk32uuOKKOProo+P000/PLxs7dmwsWbIk7r333rjlllti69atMWHChNi+ffs+a5w/f35UV1fnH0OGDCl6OwEAgENXLsuyrDMdp06dGj179owf//jHRfU766yzIpfLxb//+7+3ee/GG2+M66+/PlatWhXve9/7kmP86U9/ihEjRsQ//uM/xuWXX55st3v37ti9e3f+dVNTUwwZMiR27txZ8DdV3YnLincfLit+YFxWHADozpqamqK6unq/2aBT92HauHFjrFy5MpYtW1Z033HjxsXSpUvbLF+wYEFcd911sXLlyn2GpYiIPn36xKhRo2LDhg37bFdVVRVVVVVF1wgAABDRya/kLV68OAYOHBhnnnlm0X3Xrl0bNTU1Bcu+9rWvxVe+8pX46U9/GieddNJ+x9i9e3c8/fTTbcYBAAAopaLPMLW2tsbixYtj5syZUVlZ2H3u3LmxadOmWLJkSURELFy4MIYNGxb19fX5i0Q0NDREQ0NDvs+NN94YX/rSl+IHP/hBDBs2LLZu3RoREX379o2+fftGRMScOXPirLPOiqFDh8a2bdviq1/9ajQ1NcXMmTM7veEAAAD7U3RgWrlyZTQ2Nsbs2W3/1mbLli3R2NiYf93c3Bxz5syJTZs2Re/evaO+vj6WL18e06dPz7e56aaborm5OT7xiU8UjHX11VfHvHnzIiLi+eefj/POOy9efPHFGDBgQIwbNy4eeuihOPbYY4stHwAAoMM6fdGHt6KO/mFXObnoQ/fhog8HxkUfAIDurKPZoNOXFQcAAHi7E5gAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgISib1zLwVXqe/+0PLW+pOOVUkV9XblLeEsr9b5S6vs6uacYHeWeXQB0Z84wAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAEBCZbkLoFDLU+vLXUKXKfW2VtTXlXS8Q01uaG1pB9z6QsmGypr3lGwsup+p1bPLXUKXuXfnd8pdAgBFcoYJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIqy10AhSrq68pdApTG4AElGyq39YWSjRURkTXvKel40FFTq2eXu4Qude/O75S7BIAD5gwTAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJBQWe4CKJQ1bi7peLmhtSUdD8pi8ICSDpcr6WgRsfWFkg6XNe8p6XhQLlOrZ5e7hC51787vlLsE4CBwhgkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEirLXQDAW97gASUdLrf1hZKOlzXvKel4QPumVs8u2Vitu3aVbKyDYUXrD8tdAnQZZ5gAAAASigpMw4YNi1wu1+Zx8cUXt9t+1apV7bZ/5pln8m1uueWWOOWUU+KII46II444Ik4//fR4+OGH24x10003xfDhw6NXr14xZsyYeOCBB4rcVAAAgOIUFZgeeeSR2LJlS/6xYsWKiIg455xz9tlv/fr1Bf2OO+64/HurVq2K8847L+6///5Ys2ZNDB06NKZMmRKbNm3Kt7nzzjvjsssuiyuvvDLWrl0bp5xySkybNi0aGxuLKR8AAKAouSzLss52vuyyy+InP/lJbNiwIXK5XJv3V61aFZMmTYqXXnopDj/88A6N2dLSEkcccUR885vfjAsvvDAiIsaOHRsnnnhi3Hzzzfl2733ve+OjH/1ozJ8/v8P1NjU1RXV1dezcuTP69+/f4X5dqZTff46IyA2tLel4QBfwN0xwyPM3THDwdTQbdPpvmJqbm2Pp0qUxe/bsdsPS3kaPHh01NTUxefLkuP/++/fZ9pVXXok9e/bEkUcemV/Po48+GlOmTCloN2XKlHjwwQf3Odbu3bujqamp4AEAANBRnQ5Md999d+zYsSNmzZqVbFNTUxOLFi2KhoaGWLZsWdTV1cXkyZNj9erVyT5XXHFFHH300XH66adHRMSLL74YLS0tMWjQoIJ2gwYNiq1bt+6zxvnz50d1dXX+MWTIkI5vIAAAcMjr9GXFb7311pg2bVrU1qa/8lVXVxd1dXX51+PHj4/nnnsuFixYEKeeemqb9jfeeGPcfvvtsWrVqujVq1fBe28+i5Vl2X7PbM2dOzcuv/zy/OumpiahCQAA6LBOBaaNGzfGypUrY9myZUX3HTduXCxdurTN8gULFsR1110XK1eujPe973355UcddVRUVFS0OZu0bdu2Nmed3qyqqiqqqqqKrhEAACCik1/JW7x4cQwcODDOPPPMovuuXbs2ampqCpZ97Wtfi6985Svx05/+NE466aSC93r27BljxozJX5HvdStWrIgJEyYUXzwAAEAHFX2GqbW1NRYvXhwzZ86MysrC7nPnzo1NmzbFkiVLIiJi4cKFMWzYsKivr89fJKKhoSEaGhryfW688cb40pe+FD/4wQ9i2LBh+TNJffv2jb59+0ZExOWXXx4XXHBBnHTSSTF+/PhYtGhRNDY2xkUXXdTpDQcAANifogPTypUro7GxMWbPbnv56y1bthTcG6m5uTnmzJkTmzZtit69e0d9fX0sX748pk+fnm9z0003RXNzc3ziE58oGOvqq6+OefPmRUTEjBkzYvv27XHttdfGli1bYuTIkXHPPffEscceW2z5AAAAHXZA92F6q3EfJuAtwX2Y4JDnPkxw8B30+zABAAC83QlMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAEBC0Teu5eAq9X2TssbNJRvLPZ0ol5an1pd0vIr6upKOV3KDB5R0uJz7OgEldkaPc8pdwj716Nev3CXs0707v1PuEiiCM0wAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkFBZ7gIo1PLU+nKXkFRR4vGyxs0lHS83tLak43V3pf78Su1Qmw+AUurRr1+5S9in1l27yl3CPpW6vlLPx9Tq2SUdrzu7d+d3yl3CAXOGCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASKstdAIUq6utKOl7LU+tLNlbWuLlkY0VE5IbWlnS87l5fKefiYOjRr19Jxyvl9pb6uDjkDB5Q0uFyW18o6XhZ856SjgccfKX+ndG6a1dJxyu1UtdX6s+vO5taPbuk49278zslHa8jnGECAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgITKchfAwVVRX1fuEpKyxs3lLqFL9ejXr6Tj5YbWlnS8Us9Hd973AOheSv07snXXrpKOx6HNGSYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASKgsdwEUyho3l3S83NDako53KDEXB6blqfUlG6uivq5kY9H95HoeVtLxsuY9JR0PgEObM0wAAAAJRQWmYcOGRS6Xa/O4+OKL222/atWqdts/88wz+TZPPfVUfPzjH8+PvXDhwjbjzJs3r80YgwcPLm5LAQAAilTUV/IeeeSRaGlpyb9+8skn44wzzohzzjlnn/3Wr18f/fv3z78eMGBA/vkrr7wS73rXu+Kcc86Jv/u7v0uOUV9fHytXrsy/rqioKKZ0AACAohUVmPYOOhER119/fYwYMSImTpy4z34DBw6Mww8/vN33Tj755Dj55JMjIuKKK65IF1pZ6awSAADQpTr9N0zNzc2xdOnSmD17duRyuX22HT16dNTU1MTkyZPj/vvv79T6NmzYELW1tTF8+PA499xz4/e///1+++zevTuampoKHgAAAB3V6cB09913x44dO2LWrFnJNjU1NbFo0aJoaGiIZcuWRV1dXUyePDlWr15d1LrGjh0bS5YsiXvvvTduueWW2Lp1a0yYMCG2b9++z37z58+P6urq/GPIkCFFrRcAADi0dfqy4rfeemtMmzYtamvTl0quq6uLuro3Lgc8fvz4eO6552LBggVx6qmndnhd06ZNyz8fNWpUjB8/PkaMGBHf+9734vLLL0/2mzt3bsH7TU1NQhMAANBhnQpMGzdujJUrV8ayZcuK7jtu3LhYunRpZ1ab16dPnxg1alRs2LBhn+2qqqqiqqrqgNYFAAAcujr1lbzFixfHwIED48wzzyy679q1a6OmpqYzq83bvXt3PP300wc8DgAAwL4UfYaptbU1Fi9eHDNnzozKysLuc+fOjU2bNsWSJUsiImLhwoUxbNiwqK+vz18koqGhIRoaGvJ9mpub4ze/+U3++aZNm2LdunXRt2/fePe73x0REXPmzImzzjorhg4dGtu2bYuvfvWr0dTUFDNnzuz0hgMAAOxP0YFp5cqV0djYGLNnz27z3pYtW6KxsTH/urm5OebMmRObNm2K3r17R319fSxfvjymT5+eb7N58+YYPXp0/vWCBQtiwYIFMXHixFi1alVERDz//PNx3nnnxYsvvhgDBgyIcePGxUMPPRTHHntsseUDAAB0WC7LsqzcRXSVpqamqK6ujp07dxbcSLc7mVrdNogeiNzQ9EU5yi1r3FzuErpUd56LiNLPR+uuXSUbq6K+bv+N6DpbXyh3BfuUNe8pdwlAmZXyd9DB0KNfv3KX8JZ1787vlGysjmaDTl9WHAAA4O1OYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEoq+cS0HV3e+V8+hdt+kUvP58bYxeEC5K9inXCnvE1XibfVzAOCtxxkmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEioLHcBFMoaN5e7BA6S3NDacpewTy1PrS/peBX1dSUbq9THRXefCw7Q4AGlG2vrC6UbKyJyPQ8r6XiHmqx5T7lL4C2iR79+JR2vddeubjteqbeVtpxhAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASKstdAIeu3NDacpfQpVqeWl/uEvapor6u3CUkHWr7Ct3I4AGlHW/rC6Ud7xDT7X8WlHB+s+Y9JRvrUNS6a1e5S9inHv36lbsEiuAMEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkVJa7AArlhtaWu4QukzVuLul4h9JnFxFRUV9X7hL2qZTze6jNLW9fLdv/b0nHq3jnkSUdr9vb+kK5K+gyuZ6HlXS8rHlPScc71PTo16/cJVBGzjABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQEJluQugUNa4uaTj5YbWlmys7lzbW0FFfV25S+D/KfW+XGqH2rFRaqWc324/F4MHlHa8rS+UdrwSy5r3lLuEfcr1PKzcJSSVel/u7j9He/TrV+4SeBtxhgkAACChqMA0bNiwyOVybR4XX3xxu+1XrVrVbvtnnnkm3+app56Kj3/84/mxFy5c2O5YN910UwwfPjx69eoVY8aMiQceeKCY0gEAAIpWVGB65JFHYsuWLfnHihUrIiLinHPO2We/9evXF/Q77rjj8u+98sor8a53vSuuv/76GDx4cLv977zzzrjsssviyiuvjLVr18Ypp5wS06ZNi8bGxmLKBwAAKEpRf8M0YEDhd6Wvv/76GDFiREycOHGf/QYOHBiHH354u++dfPLJcfLJJ0dExBVXXNFum2984xvxmc98Jj772c9GRMTChQvj3nvvjZtvvjnmz59fzCYAAAB0WKf/hqm5uTmWLl0as2fPjlwut8+2o0ePjpqampg8eXLcf//9Ra/n0UcfjSlTphQsnzJlSjz44IP77Lt79+5oamoqeAAAAHRUpwPT3XffHTt27IhZs2Yl29TU1MSiRYuioaEhli1bFnV1dTF58uRYvXp1h9fz4osvRktLSwwaNKhg+aBBg2Lr1q377Dt//vyorq7OP4YMGdLh9QIAAHT6suK33nprTJs2LWpr05eprKuri7q6Ny6lPH78+HjuuediwYIFceqppxa1vjefxcqybL9ntubOnRuXX355/nVTU5PQBAAAdFinAtPGjRtj5cqVsWzZsqL7jhs3LpYuXdrh9kcddVRUVFS0OZu0bdu2Nmed3qyqqiqqqqqKrhEAACCik1/JW7x4cQwcODDOPPPMovuuXbs2ampqOty+Z8+eMWbMmPwV+V63YsWKmDBhQtHrBwAA6KiizzC1trbG4sWLY+bMmVFZWdh97ty5sWnTpliyZElE/OVqdsOGDYv6+vr8RSIaGhqioaEh36e5uTl+85vf5J9v2rQp1q1bF3379o13v/vdERFx+eWXxwUXXBAnnXRSjB8/PhYtWhSNjY1x0UUXdXrDAQAA9qfowLRy5cpobGyM2bNnt3lvy5YtBfdGam5ujjlz5sSmTZuid+/eUV9fH8uXL4/p06fn22zevDlGjx6df71gwYJYsGBBTJw4MVatWhURETNmzIjt27fHtddeG1u2bImRI0fGPffcE8cee2yx5QMAAHRYLsuyrNxFdJWmpqaorq6OnTt3Rv/+/ctdTrumVrcNogciNzR9UY5iZY2bSzZWRGlro/sp5f5S6n2l1PtyqTk2Dkx33vdanlpf0vEq6uv236gYW18o7XglljXvKXcJ+5TreVi5S0gbPGD/bYrQ3X+O8vZ1787vlGysjmaDTl9WHAAA4O1OYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEoq+cS0HV3e/50cpVZS7AN4y3O/j7a07z293ri0i3DeJjuvm+wp0Z84wAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAEBCZbkLoNA9K+4s6XjTz5hR0vEOJVnj5pKOlxtaW9LxurtSbm+p56K7O9S291BS8c4jy13CPmXNe8pdQpcq9c/lUh67uZ6HlWws4MA4wwQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACZXlLoBC08+YUdLx7llxZ8nGKnVt3V1uaG25S3hLa3lqfcnG6tGvX8nGgnLKmveUu4S3tO7+c7lb17f1hZIOl+t5WEnHc2zQnTnDBAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJleUugEItT60v6XhTaz9QwtFKW1tFfV1JxzvUlHpfKbUe/fqVuwQ4YLmhteUuoUtljZvLXcI+lbq+Q2p+Bw8o6XDdfV+BUnKGCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASKstdAIeulqfWl3S8ivq6ko5Xalnj5pKO16Nfv5KOB1BquaG15S6Bg6TUc1vq35FQSkWdYRo2bFjkcrk2j4svvrjd9qtWrWq3/TPPPFPQrqGhIU444YSoqqqKE044Ie66666C9+fNm9dmjMGDBxe5qQAAAMUp6gzTI488Ei0tLfnXTz75ZJxxxhlxzjnn7LPf+vXro3///vnXAwYMyD9fs2ZNzJgxI77yla/Exz72sbjrrrvik5/8ZPzyl7+MsWPH5tvV19fHypUr868rKiqKKR0AAKBoRQWmvYNORMT1118fI0aMiIkTJ+6z38CBA+Pwww9v972FCxfGGWecEXPnzo2IiLlz58YvfvGLWLhwYdx+++1vFFpZ6awSAADQpTp90Yfm5uZYunRpzJ49O3K53D7bjh49OmpqamLy5Mlx//33F7y3Zs2amDJlSsGyqVOnxoMPPliwbMOGDVFbWxvDhw+Pc889N37/+9/vt8bdu3dHU1NTwQMAAKCjOh2Y7r777tixY0fMmjUr2aampiYWLVoUDQ0NsWzZsqirq4vJkyfH6tWr8222bt0agwYNKug3aNCg2Lp1a/712LFjY8mSJXHvvffGLbfcElu3bo0JEybE9u3b91nj/Pnzo7q6Ov8YMmRI5zYWAAA4JHX6Knm33nprTJs2LWpr01dJqauri7q6N65cNn78+HjuuediwYIFceqpp+aXv/kMVZZlBcumTZuWfz5q1KgYP358jBgxIr73ve/F5Zdfnlz/3LlzC95vamoSmgAAgA7rVGDauHFjrFy5MpYtW1Z033HjxsXSpUvzrwcPHlxwNikiYtu2bW3OOu2tT58+MWrUqNiwYcM+11VVVRVVVVVF1wgAABDRya/kLV68OAYOHBhnnnlm0X3Xrl0bNTU1+dfjx4+PFStWFLS57777YsKECckxdu/eHU8//XTBOAAAAKVW9Bmm1tbWWLx4ccycOTMqKwu7z507NzZt2hRLliyJiL9cAW/YsGFRX1+fv0hEQ0NDNDQ05Ptceumlceqpp8YNN9wQf/VXfxU/+tGPYuXKlfHLX/4y32bOnDlx1llnxdChQ2Pbtm3x1a9+NZqammLmzJmd3W4AAID9KjowrVy5MhobG2P27Nlt3tuyZUs0NjbmXzc3N8ecOXNi06ZN0bt376ivr4/ly5fH9OnT820mTJgQd9xxR1x11VXxpS99KUaMGBF33nlnwT2Ynn/++TjvvPPixRdfjAEDBsS4cePioYceimOPPbbY8gEAADosl2VZVu4iukpTU1NUV1fHzp07C26k252c0WPfNwEmraK+bv+Nyihr3FzuEoAi5YamL2z0dlTqn1OH2udH5/kdSUfdu/M7JRuro9mg05cVBwAAeLsTmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgobLcBVBoResPy11CUne/qW7LU+tLOl6pb4Tb3W/g6KaBvF1092OtO/PZQddo3bWrZGP16NevZGPRPmeYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAICEynIXwFvHitYflruELnVGj3NKOl5FfV1Jx6PzWnftKul4Pfr1K+l4h5rc0NpylwDQpfzeeGtxhgkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEirLXQB0Vytaf1juErrU1OrZ5S4hKTe0tqTjVZR0tIiscXOJRzy0lPrzK/X+ArTl5x6HEmeYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACChstwFAN3DvTu/U+4SusyHR11V7hKATmh5an1Jx6uoryvpeN1Z1ri53CXAW5YzTAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQUFnuAgC62k+f+Gq5S3hLm1o9u9wlcIiqqK8r6Xh+FgAd4QwTAABAQlGBadiwYZHL5do8Lr744nbbr1q1qt32zzzzTEG7hoaGOOGEE6KqqipOOOGEuOuuu9qMddNNN8Xw4cOjV69eMWbMmHjggQeKKR0AAKBoRQWmRx55JLZs2ZJ/rFixIiIizjnnnH32W79+fUG/4447Lv/emjVrYsaMGXHBBRfEf/7nf8YFF1wQn/zkJ+PXv/51vs2dd94Zl112WVx55ZWxdu3aOOWUU2LatGnR2NhYTPkAAABFyWVZlnW282WXXRY/+clPYsOGDZHL5dq8v2rVqpg0aVK89NJLcfjhh7c7xowZM6KpqSn+4z/+I7/swx/+cBxxxBFx++23R0TE2LFj48QTT4ybb7453+a9731vfPSjH4358+d3uN6mpqaorq6OnTt3Rv/+/TvcD4A3dPe/YcoNrS13CbxF+BsmOLR1NBt0+m+YmpubY+nSpTF79ux2w9LeRo8eHTU1NTF58uS4//77C95bs2ZNTJkypWDZ1KlT48EHH8yv59FHH23TZsqUKfk2Kbt3746mpqaCBwAAQEd1OjDdfffdsWPHjpg1a1ayTU1NTSxatCgaGhpi2bJlUVdXF5MnT47Vq1fn22zdujUGDRpU0G/QoEGxdevWiIh48cUXo6WlZZ9tUubPnx/V1dX5x5AhQ4rcSgAA4FDW6cuK33rrrTFt2rSorU1/9aGuri7q6t64BOj48ePjueeeiwULFsSpp56aX/7mM1RZlrVZ1pE2bzZ37ty4/PLL86+bmpqEJgAAoMM6FZg2btwYK1eujGXLlhXdd9y4cbF06dL868GDB7c5U7Rt27b8GaWjjjoqKioq9tkmpaqqKqqqqoquEQAAIKKTX8lbvHhxDBw4MM4888yi+65duzZqamryr8ePH5+/2t7r7rvvvpgwYUJERPTs2TPGjBnTps2KFSvybQAAAA6Gos8wtba2xuLFi2PmzJlRWVnYfe7cubFp06ZYsmRJREQsXLgwhg0bFvX19fmLRDQ0NERDQ0O+z6WXXhqnnnpq3HDDDfFXf/VX8aMf/ShWrlwZv/zlL/NtLr/88rjgggvipJNOivHjx8eiRYuisbExLrroos5uNwAAwH4VHZhWrlwZjY2NMXt228vKbtmypeDeSM3NzTFnzpzYtGlT9O7dO+rr62P58uUxffr0fJsJEybEHXfcEVdddVV86UtfihEjRsSdd94ZY8eOzbeZMWNGbN++Pa699trYsmVLjBw5Mu6555449thjiy0fAACgww7oPkxvNe7DBHDg3IeJtwv3YYJD20G/DxMAAMDbncAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQUfeNaAA5t9+78TrlLAIAu4wwTAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJAgMAEAACQITAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITAABAgsAEAACQIDABAAAkCEwAAAAJAhMAAECCwAQAAJBQWe4CulKWZRER0dTUVOZKAACAcno9E7yeEVIOqcC0a9euiIgYMmRImSsBAAC6g127dkV1dXXy/Vy2v0j1NtLa2hqbN2+Ofv36RS6XK3c5h6SmpqYYMmRIPPfcc9G/f/9yl3PIMx/dh7noPsxF92I+ug9z0b2YjwOXZVns2rUramtro0eP9F8qHVJnmHr06BHHHHNMucsgIvr37+/g7kbMR/dhLroPc9G9mI/uw1x0L+bjwOzrzNLrXPQBAAAgQWACAABIEJjoUlVVVXH11VdHVVVVuUshzEd3Yi66D3PRvZiP7sNcdC/mo+scUhd9AAAAKIYzTAAAAAkCEwAAQILABAAAkCAwAQAAJAhMJM2fPz9yuVxcdtll+WXLli2LqVOnxlFHHRW5XC7WrVvXpt/u3bvjC1/4Qhx11FHRp0+fOPvss+P5558vaPPSSy/FBRdcENXV1VFdXR0XXHBB7Nixo6BNY2NjnHXWWdGnT5846qij4otf/GI0NzcXtHniiSdi4sSJ0bt37zj66KPj2muvjbfrdUw6Ox+nnXZa5HK5gse5555b0MZ8FOfNc7Fnz574p3/6pxg1alT06dMnamtr48ILL4zNmzcX9HNsHBydnQ/HRum193Nq3rx5cfzxx0efPn3iiCOOiNNPPz1+/etfF/RzbJReZ+fCcXFwtDcfe/vc5z4XuVwuFi5cWLDcsdFNZNCOhx9+OBs2bFj2vve9L7v00kvzy5csWZJdc8012S233JJFRLZ27do2fS+66KLs6KOPzlasWJE99thj2aRJk7L3v//92WuvvZZv8+EPfzgbOXJk9uCDD2YPPvhgNnLkyOwjH/lI/v3XXnstGzlyZDZp0qTssccey1asWJHV1tZml1xySb7Nzp07s0GDBmXnnntu9sQTT2QNDQ1Zv379sgULFhyUz6ScDmQ+Jk6cmP3N3/xNtmXLlvxjx44dBW3MR8e1Nxc7duzITj/99OzOO+/MnnnmmWzNmjXZ2LFjszFjxhT0dWyU3oHMh2OjtFI/p2677bZsxYoV2e9+97vsySefzD7zmc9k/fv3z7Zt25Zv49gorQOZC8dF6aXm43V33XVX9v73vz+rra3N/vmf/7ngPcdG9yAw0cauXbuy4447LluxYkU2ceLEdg/uP/zhD+3+A33Hjh3ZYYcdlt1xxx35ZZs2bcp69OiR/fSnP82yLMt+85vfZBGRPfTQQ/k2a9asySIie+aZZ7Isy7J77rkn69GjR7Zp06Z8m9tvvz2rqqrKdu7cmWVZlt10001ZdXV19uqrr+bbzJ8/P6utrc1aW1sP+HPoLg5kPrIsS/Z5nfnouI7MxesefvjhLCKyjRs3Zlnm2DgYDmQ+ssyxUUrFzMXOnTuziMhWrlyZZZljo9QOZC6yzHFRavubj+effz47+uijsyeffDI79thjCwKTY6P78JU82rj44ovjzDPPjNNPP73ovo8++mjs2bMnpkyZkl9WW1sbI0eOjAcffDAiItasWRPV1dUxduzYfJtx48ZFdXV1QZuRI0dGbW1tvs3UqVNj9+7d8eijj+bbTJw4seCGbVOnTo3NmzfHs88+W3Tt3dWBzMfrbrvttjjqqKOivr4+5syZE7t27cq/Zz46rpi52LlzZ+RyuTj88MMjwrFxMBzIfLzOsVEaHZ2L5ubmWLRoUVRXV8f73//+iHBslNqBzMXrHBels6/5aG1tjQsuuCD+4R/+Ierr69u879joPirLXQDdyx133BGPPfZYPPLII53qv3Xr1ujZs2ccccQRBcsHDRoUW7duzbcZOHBgm74DBw4saDNo0KCC94844ojo2bNnQZthw4a1Wc/r7w0fPrxT29CdHOh8REScf/75MXz48Bg8eHA8+eSTMXfu3PjP//zPWLFiRUSYj44qZi5effXVuOKKK+JTn/pU9O/fPyIcG6V2oPMR4dgolY7MxU9+8pM499xz45VXXomamppYsWJFHHXUURHh2CilA52LCMdFKe1vPm644YaorKyML37xi+2+79joPgQm8p577rm49NJL47777otevXqVdOwsyyKXy+Vf7/28lG2y//fHie31fasp1Xz8zd/8Tf75yJEj47jjjouTTjopHnvssTjxxBMjwnzsTzFzsWfPnjj33HOjtbU1brrppv2O7dgoXqnmw7Fx4Do6F5MmTYp169bFiy++GLfcckt88pOfjF//+tft/kPvdY6N4pRqLhwXpbG/+Xj00UfjX/7lX+Kxxx4rensdG13PV/LIe/TRR2Pbtm0xZsyYqKysjMrKyvjFL34R//qv/xqVlZXR0tKy3zEGDx4czc3N8dJLLxUs37ZtW/5/KgYPHhx//OMf2/R94YUXCtq8/r8er3vppZdiz549+2yzbdu2iIg2/5PyVlSK+WjPiSeeGIcddlhs2LAhIsxHR3R0Lvbs2ROf/OQn4w9/+EOsWLGi4GyGY6N0SjEf7XFsFK+jc9GnT59497vfHePGjYtbb701Kisr49Zbb40Ix0aplGIu2uO46Jz9zceqVati27ZtMXTo0Pz7GzdujL//+7/Pn+lxbHQfAhN5kydPjieeeCLWrVuXf5x00klx/vnnx7p166KiomK/Y4wZMyYOO+yw/Kn7iIgtW7bEk08+GRMmTIiIiPHjx8fOnTvj4Ycfzrf59a9/HTt37ixo8+STT8aWLVvybe67776oqqqKMWPG5NusXr264LKY9913X9TW1rY5rfxWVIr5aM9TTz0Ve/bsiZqamogwHx3Rkbl4/R/nGzZsiJUrV8Y73/nOgjEcG6VTivloj2OjeJ39OZVlWezevTsiHBulUoq5aI/jonP2Nx+zZs2Kxx9/vOD92tra+Id/+Ie49957I8Kx0a100cUleIt68xVdtm/fnq1duzZbvnx5FhHZHXfcka1duzbbsmVLvs1FF12UHXPMMdnKlSuzxx57LPvQhz7U7iUw3/e+92Vr1qzJ1qxZk40aNardS2BOnjw5e+yxx7KVK1dmxxxzTMElMHfs2JENGjQoO++887InnngiW7ZsWda/f/+39SUwi52P3/72t9k111yTPfLII9kf/vCHbPny5dnxxx+fjR492nwcoL3nYs+ePdnZZ5+dHXPMMdm6desKLse7e/fufB/HxsFT7Hw4Ng6evefi5ZdfzubOnZutWbMme/bZZ7NHH300+8xnPpNVVVVlTz75ZL6PY+PgKHYuHBcH1/6uQPjmq+RlmWOjuxCY2Kc3H9yLFy/OIqLN4+qrr863+fOf/5xdcskl2ZFHHpn17t07+8hHPpI1NjYWjLt9+/bs/PPPz/r165f169cvO//887OXXnqpoM3GjRuzM888M+vdu3d25JFHZpdccknB5S6zLMsef/zx7JRTTsmqqqqywYMHZ/PmzXtbX/6y2PlobGzMTj311OzII4/MevbsmY0YMSL74he/mG3fvr1gXPNRvL3n4vXLurf3uP/++/N9HBsHT7Hz4dg4ePaeiz//+c/Zxz72say2tjbr2bNnVlNTk5199tnZww8/XNDHsXFwFDsXjouDqzOBybHRPeSyzC18AQAA2uNvmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASKgsdwFd7dVXX43m5uZylwEAAJRZz549o1evXvtsc0gFpldffTWqex8RzfFquUsBAADKbPDgwfGHP/xhn6HpkApMzc3N0Ryvxv8X06MyDovIvfGNxFyPXOz1IrF8r+eJ5bkePRLtE8v37rvXelPjd2zMaH95cswOrDeK+xyygjaJegrG70z/N55mHdj+DrVJrCtLfaapGnoklhe0T6wr9l6+1/MeqXo6MGap2r/5S7wdGKtj7Q9keUc+34NQQ3Sgzd7LE+0PpJ4DatPR/lGiNge0DVkH2hRbw15jRkJyzKzdNh1ZV7FjtjmUOrLuSI3V/pbmOrLuvdrkCp7vv7aC9on1Jn/NJdfbft9U+x7RkRr2at+B5QVjptq86TNPvZfrQJvk80i1aU2sK9X3jfYVyfH3HvONmisKPov211s4ZqJNavleY+5df0XBuvaq/43S3rQ8sS2J9b65poL1perYe6zEOIU1pT731Hr3X0NFYo5TbXKJOahI7Ft7Ly9sE288L6jhDRUF+00u0Wbv5ft/Xti+8B8qhe16tFnetKs1jh3zbDQ3NwtMb1YZh0Vl7k2BKREgUss7FHo60rdHou8BBabkb57919aR9XabwFRc+7dMYEr9I+gtGphKF4xSyzvy+R7cGt7WgakjbaIDbQ5oOw9yYEpsy9s6MHVoefvrTQedAwlMxQWgAwpMHWnfxYEpHXpKH5g60r5jgSn1j+aDG5iSQaUDwSi9/OAEpoqCbXtjx+ux10649/LCz2jv5e23L6xh7zap4BXttymosyNt9h+YKg5CYCps3/7n0/HAVNxlHFz0AQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACABIEJAAAgQWACAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEioLHcB5fBa7InIIvbOi7kst1eL1PK9nieW57Ie7S6P1PLWvfrmEm1yied7592CNtH+8uSYHVhvannW/vKsoE2inoLxO9N/7zL2/kw7MGbiMyqcpr37FllDj8Ty5C6017pi7+V7Pe+RqqcDY5aq/Zv/i6UDY3Ws/YEs78jnexBqiA60SezGparngNp0tH+UqM0BbUPWgTbF1rDXmJGQHDNrt01H1lXsmG0OpY6sO1Jjtb+luY6se682uYLn+6+toH1ivalfDVlyve33TbXPov0aWhPte3RgeY/oQJs3feap93IdaJN8Hqk2re0uz0Wq7xvtK5Lj7z3mGzVXFHwW7a+3cMxEm9Tyvcbcu/6KgnXtVf8bpb1peWJbEut9c00F60vVsfdYiXEKa0p97qn17r+GisQcp9rkEnNQkdi39l5e2CbeeF5QwxsqCvabXKLN3sv3/7ywfaHCdm3ra9rVGh1xSAWmnj17xuDBg+OXW+/5y4K9j4mWspQEAACUyeDBg6Nnz577bJPLsiz5n2tvR6+++mo0NzeXuwy6kaamphgyZEg899xz0b9//3KXQzdhv6A99gtS7Bu0x37R/fXs2TN69eq1zzaH1BmmiIhevXrt90Ph0NS/f38/zGjDfkF77Bek2Ddoj/3irc1FHwAAABIEJgAAgASBiUNeVVVVXH311VFVVVXuUuhG7Be0x35Bin2D9tgv3h4OuYs+AAAAdJQzTAAAAAkCEwAAQILABAAAkCAwAQAAJAhMAAAACQITh4Sbbrophg8fHr169YoxY8bEAw88kGy7ZcuW+NSnPhV1dXXRo0ePuOyyy7quULpUMfvFsmXL4owzzogBAwZE//79Y/z48XHvvfd2YbV0lWL2i1/+8pfxwQ9+MN75zndG79694/jjj49//ud/7sJq6UrF7Bt7+9WvfhWVlZXxgQ984OAWSFkUs1+sWrUqcrlcm8czzzzThRVTLIGJt70777wzLrvssrjyyitj7dq1ccopp8S0adOisbGx3fa7d++OAQMGxJVXXhnvf//7u7haukqx+8Xq1avjjDPOiHvuuSceffTRmDRpUpx11lmxdu3aLq6cg6nY/aJPnz5xySWXxOrVq+Ppp5+Oq666Kq666qpYtGhRF1fOwVbsvvG6nTt3xoUXXhiTJ0/uokrpSp3dL9avXx9btmzJP4477rguqpjOcB8m3vbGjh0bJ554Ytx88835Ze9973vjox/9aMyfP3+ffU877bT4wAc+EAsXLjzIVdLVDmS/eF19fX3MmDEjvvzlLx+sMulipdgv/vqv/zr69OkT3//+9w9WmZRBZ/eNc889N4477rioqKiIu+++O9atW9cF1dJVit0vVq1aFZMmTYqXXnopDj/88C6slAPhDBNva83NzfHoo4/GlClTCpZPmTIlHnzwwTJVRbmVYr9obW2NXbt2xZFHHnkwSqQMSrFfrF27Nh588MGYOHHiwSiRMunsvrF48eL43e9+F1dfffXBLpEyOJCfGaNHj46ampqYPHly3H///QezTEqgstwFwMH04osvRktLSwwaNKhg+aBBg2Lr1q1lqopyK8V+8fWvfz3+9Kc/xSc/+cmDUSJlcCD7xTHHHBMvvPBCvPbaazFv3rz47Gc/ezBLpYt1Zt/YsGFDXHHFFfHAAw9EZaV/br0ddWa/qKmpiUWLFsWYMWNi9+7d8f3vfz8mT54cq1atilNPPbUryqYTHMEcEnK5XMHrLMvaLOPQ09n94vbbb4958+bFj370oxg4cODBKo8y6cx+8cADD8TLL78cDz30UFxxxRXx7ne/O84777yDWSZl0NF9o6WlJT71qU/FNddcE+95z3u6qjzKpJifGXV1dVFXV5d/PX78+HjuuediwYIFAlM3JjDxtnbUUUdFRUVFm//p2bZtW5v/EeLQcSD7xZ133hmf+cxn4oc//GGcfvrpB7NMutiB7BfDhw+PiIhRo0bFH//4x5g3b57A9DZS7L6xa9eu+D//5//E2rVr45JLLomIv3yNN8uyqKysjPvuuy8+9KEPdUntHDyl+jfGuHHjYunSpaUujxLyN0y8rfXs2TPGjBkTK1asKFi+YsWKmDBhQpmqotw6u1/cfvvtMWvWrPjBD34QZ5555sEuky5Wqp8XWZbF7t27S10eZVTsvtG/f/944oknYt26dfnHRRddFHV1dbFu3boYO3ZsV5XOQVSqnxlr166NmpqaUpdHCTnDxNve5ZdfHhdccEGcdNJJMX78+Fi0aFE0NjbGRRddFBERc+fOjU2bNsWSJUvyfV6/itHLL78cL7zwQqxbty569uwZJ5xwQjk2gYOg2P3i9ttvjwsvvDD+5V/+JcaNG5f/H8XevXtHdXV12baD0ip2v/jWt74VQ4cOjeOPPz4i/nJfpgULFsQXvvCFsm0DB0cx+0aPHj1i5MiRBf0HDhwYvXr1arOct7Zif2YsXLgwhg0bFvX19dHc3BxLly6NhoaGaGhoKOdmsB8CE297M2bMiO3bt8e1114bW7ZsiZEjR8Y999wTxx57bET85Ua1b75fwujRo/PPH3300fjBD34Qxx57bDz77LNdWToHUbH7xbe//e147bXX4uKLL46LL744v3zmzJnx3e9+t6vL5yApdr9obW2NuXPnxh/+8IeorKyMESNGxPXXXx+f+9znyrUJHCSd+V3C21+x+0Vzc3PMmTMnNm3aFL179476+vpYvnx5TJ8+vVybQAe4DxMAAECCv2ECAABIEJgAAAASBCYAAIAEgQkAACBBYAIAAEgQmAAAABIEJgAAgASBCQAAIEFgAgAASBCYAAAAEgQmAACAhP8fjbH2PCxRUCgAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -408,38 +672,30 @@ ], "source": [ "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Probability\")\n", - "clrbar = ax.imshow(t_pprb_array, cmap='viridis')\n", + "ax.set_title(\"Unique weights - W+\")\n", + "clrbar = ax.imshow(test_gen_un_[\"W+\"], cmap='terrain')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(t_pprb_array, ax = ax, transform = test_ev.transform, cmap='viridis')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting the Standard Deviations of the calculated posterior Probabilities" + "show(test_gen_un_[\"W+\"], ax = ax, transform = test_ev.transform, cmap='terrain')" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 19, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -450,38 +706,30 @@ ], "source": [ "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Standard Deviation of Posterior Probabilities\")\n", - "clrbar = ax.imshow(t_pprb_std, cmap='viridis')\n", + "ax.set_title(\"Ascending weights - Generalized weights (W+)\")\n", + "clrbar = ax.imshow(test_gen_asc_[\"Generalized W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(t_pprb_std, ax = ax, transform = test_ev.transform, cmap='viridis')" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plotting the Confidence in the posterior probability values" + "show(test_gen_asc_[\"Generalized W+\"], ax = ax, transform = test_ev.transform, cmap='viridis')" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 20, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAAK7CAYAAADBfQ+iAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABdM0lEQVR4nO3deXgUVf7+/buzs3USICEEA0RQBGUTv4QgmyxGRERFcEFWAR1xw3Hj52BYVBhBZXQUl5EwM6goDiBuSFgUgciwKiAyIJAoEFwgCWvW8/zBkzJNciAdAh3I+3VdfV3pqlNVn65TlfSd6jrtMsYYAQAAAACK8fN1AQAAAABQURGYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAVApdunRRly5dnOe7d++Wy+XSzJkzfVbT2TJz5ky5XC7t3r27zMuuXbu2/AvDGfnyyy/lcrn05ZdfOtOGDBmihg0bntM6Ksq5c74f5x988IFq1qypw4cP+6yGQk8++aTi4uJ8XQZQYRGYgAtU4RuCwkdISIiio6OVkJCgl19+WYcOHfJ1iTjPvfbaaz5/05yVlaVnn31WV111lUJDQxUcHKwGDRrotttu06effurT2lA5HD16VOPGjfMIsqeTn5+vxMREPfDAA6pevbokqVmzZmrZsmWxtvPmzZPL5VLnzp2LzZsxY4ZcLpcWLVpU5vol6eGHH9a3336rBQsWnNF6gAsVgQm4wE2YMEH//ve/NX36dD3wwAOSTvxxbN68ub777jsfV+c7DRo00LFjxzRw4EBfl1LuBg4cqGPHjqlBgwZndTu+Dkw7duxQ69atlZiYqNjYWE2cOFHTp0/XsGHDtHv3bt1www3697//7bP6zoW33npL27Zt83UZPnGujvPTOXr0qMaPH+9VYPr444+1bds2jRw50pnWoUMHbd68WZmZmR5tV65cqYCAAK1Zs0a5ubnF5vn7+ys+Pv6MXkNUVJT69OmjqVOnntF6gAtVgK8LAHB29ezZU1dddZXzfMyYMVq6dKluuOEG3Xjjjdq6dauqVKniwwp9o/Cq24XI399f/v7+vi7jrMrLy9PNN9+s/fv366uvvtLVV1/tMT8xMVGLFi1Sfn6+jyo8vSNHjqhatWpntI7AwMByqub8cz4f50lJSbr66qtVr149Z1qHDh301ltvadWqVerZs6czfeXKlerfv7/effddrVu3Tu3atXPmrVixQi1atFCNGjWs2+rSpYsaNmx42n9u9O/fX/369dPOnTt18cUXl/3FARcgrjABlVDXrl01duxYpaamatasWR7zfvjhB916662qWbOmQkJCdNVVVxX7mEZubq7Gjx+vSy65RCEhIapVq5Y6dOig5OTkYuvq37+/IiIiVKVKFTVp0kRPPfWUR5s9e/Zo2LBhqlOnjoKDg3X55ZdrxowZHm0K79344IMP9Oyzz+qiiy5SSEiIunXrph07dhR7fW+++aYaNWqkKlWqqG3btvr666+LtSnpPowhQ4aoevXq2rNnj2666SZVr15dERERevTRR4u98f799981cOBAud1uhYWFafDgwfr2229Pe29HRkaG/P399fLLLzvTfvvtN/n5+alWrVoyxjjT//SnPykqKspj+dWrV+u6665TaGioqlatqs6dO2vlypUebUq6t6OgoEDjxo1TdHS0qlatqmuuuUbff/+9GjZsqCFDhhSrMzs7W4888ogiIiJUrVo13Xzzzfr111+d+Q0bNtSWLVv01VdfOR/7LLxHrLTHx5mYM2eONm/erLFjxxYLS4WuvfZajzee0on9//DDDysmJkbBwcFq3Lix/vrXv6qgoMBpU3hsTJ061TmWgoOD9X//939as2ZNse2U5pwp7JOvvvpK9913nyIjI3XRRRdJklJTU3XfffepSZMmqlKlimrVqqV+/fqV6t6ck+9h6tKli8dHcYs+ih6XpdkPhe2GDBmi0NBQ5zjPyMg4bV0XynEuSWvXrlVCQoJq166tKlWqKDY2VsOGDZN04liJiIiQJI0fP97Z1+PGjbPum+PHj2vhwoXq3r27x/QOHTpIksfrPH78uNavX69bbrlFF198sce8X3/9Vf/73/+c5c5UYT0fffRRuawPuJBwhQmopAYOHKj/9//+nxYtWqQRI0ZIkrZs2eL81/PJJ59UtWrV9MEHH+imm27Sf/7zH918882SpHHjxmnSpEkaPny42rZtq6ysLK1du1br169Xjx49JEnfffedOnbsqMDAQI0cOVINGzbUjz/+qI8//ljPPvusJGn//v1q166dXC6X7r//fkVEROjzzz/X3XffraysLD388MMeNU+ePFl+fn569NFHlZmZqeeff14DBgzQ6tWrnTZvv/227rnnHrVv314PP/ywdu7cqRtvvFE1a9ZUTEzMafdLfn6+EhISFBcXp6lTp2rx4sV64YUX1KhRI/3pT3+SdOJNWe/evfXf//5Xf/rTn3TZZZfpo48+0uDBg0+7/rCwMF1xxRVavny5HnzwQUkn/kvscrl04MABff/997r88sslSV9//bU6duzoLLt06VL17NlTbdq0UWJiovz8/JSUlKSuXbvq66+/Vtu2ba3bHTNmjJ5//nn17t1bCQkJ+vbbb5WQkKDjx4+X2P6BBx5QeHi4EhMTtXv3bk2bNk3333+/3n//fUnStGnTnPsvCkNwnTp1JJXu+DhTH3/8sSTprrvuKvUyR48eVefOnbVnzx7dc889ql+/vlatWqUxY8Zo3759mjZtmkf7d999V4cOHdI999wjl8ul559/Xrfccot27tzpXNkp7TlT6L777lNERISefvppHTlyRJK0Zs0arVq1Srfffrsuuugi7d69W9OnT1eXLl30/fffq2rVqqV+jU899ZSGDx/uMW3WrFn64osvFBkZ6dV+MMaoT58+WrFihe699141bdpU8+bNq1TH+S+//KJrr71WERERevLJJxUWFqbdu3dr7ty5kqSIiAhNnz5df/rTn3TzzTfrlltukSS1aNHCWuO6deuUk5OjK6+80mP6xRdfrOjoaK1YscKZtmbNGuXk5Kh9+/Zq3769Vq5cqT//+c+SpFWrVklSuQWm0NBQNWrUSCtXrtTo0aPLZZ3ABcMAuCAlJSUZSWbNmjXWNqGhoaZ169bO827dupnmzZub48ePO9MKCgpM+/btzSWXXOJMa9mypenVq9cpt9+pUydTo0YNk5qa6jG9oKDA+fnuu+82devWNb/99ptHm9tvv92Ehoaao0ePGmOMWbZsmZFkmjZtarKzs512f/vb34wks2nTJmOMMTk5OSYyMtK0atXKo92bb75pJJnOnTs703bt2mUkmaSkJGfa4MGDjSQzYcIEj3pat25t2rRp4zz/z3/+YySZadOmOdPy8/NN165di62zJKNGjTJ16tRxnj/yyCOmU6dOJjIy0kyfPt0YY8zvv/9uXC6X+dvf/ubst0suucQkJCR47MOjR4+a2NhY06NHD2daYd/v2rXLGGNMenq6CQgIMDfddJNHHePGjTOSzODBg4st2717d4/tjB492vj7+5uMjAxn2uWXX+6xTwuV5vg4U61btzZhYWHFph8+fNj8+uuvziMzM9OZN3HiRFOtWjXzv//9z2OZJ5980vj7+5u0tDRjzB/HRq1atcyBAwecdh999JGRZD7++GNnWmnPmcL92qFDB5OXl+ex/cLjvKiUlBQjyfzrX/9yphWeB8uWLXOmDR482DRo0MC2m8zKlStNYGCgGTZsmNf7Yf78+UaSef755502eXl5pmPHjpXmOJ83b95pf4/++uuvRpJJTEw85f4o9I9//MPj91ZR/fr1M1WqVDE5OTnGGGMmTZpkYmNjjTHGvPbaayYyMtJp++ijjxpJZs+ePafcXufOnT1e+6lce+21pmnTpqVqC1QmfCQPqMSqV6/ujJZ34MABLV26VP3799ehQ4f022+/6bffftPvv/+uhIQEbd++XXv27JF04r/HW7Zs0fbt20tc76+//qrly5dr2LBhql+/vsc8l8sl6cR/r//zn/+od+/eMsY42/vtt9+UkJCgzMxMrV+/3mPZoUOHKigoyHle+F/pnTt3Sjrx0ZlffvlF9957r0e7wo8Ulda9997r8bxjx47ONiRp4cKFCgwMdK7MSZKfn59GjRpVqvV37NhR+/fvd27W//rrr9WpUyd17NjR+fjgihUrZIxxXuPGjRu1fft23Xnnnfr999+dfXXkyBF169ZNy5cvL/ZxqkJLlixRXl6e7rvvPo/phYOAlGTkyJFOXxXWnJ+fr9TU1NO+vtMdH+UhKyvLGV2sqKeeekoRERHO484773TmzZkzRx07dlR4eLjH8da9e3fl5+dr+fLlHuu67bbbFB4e7jw/+Xjz5pwpNGLEiGL33RS9hzA3N1e///67GjdurLCwsGLngDfS09N16623qlWrVnrttde83g+fffaZAgICnCur0on7hk513BR1IRznYWFhkqRPPvmk2IALZfX7779LksexVahDhw46duyY1q1bJ+nEx/Pat28vSbr66qv1yy+/OOfVypUrFRsbq+joaGf53Nxcjz797bfflJubq+zs7GLTS9qPhccEAE+VMjAtX75cvXv3VnR0tFwul+bPn+/1Oowxmjp1qi699FIFBwerXr16zseMgPPF4cOHnZuFd+zYIWOMxo4d6/GGMyIiQomJiZJOfDxFOjHyXkZGhi699FI1b95cjz32mMeIe4VvKK+44grrtn/99VdlZGTozTffLLa9oUOHemyv0Mnhq/ANx8GDByXJeZNzySWXeLQLDAws9U3MISEhzj0JRbdTuI3C7dStW7fYR6UaN25cqm0Uvjn8+uuvdeTIEW3YsEEdO3ZUp06dnDeSX3/9tdxutzPMcOGbpMGDBxfbX//4xz+UnZ1dbHStovWWVF/NmjVLfNMmnX5fn8rpjo+S5OfnKz093eORk5NjbV+jRo0Sv7/mvvvuU3JyspKTk52PCBbavn27Fi5cWGz/Fd674e3x5s05Uyg2NrZYzceOHdPTTz/t3E9Uu3ZtRUREKCMjw9qnp5OXl6f+/fsrPz9fc+fOVXBwsNf7ofA4PzmYNmnSpFQ1XAjHeefOndW3b1+NHz9etWvXVp8+fZSUlKTs7OxS7YNTMUXu4ypU9D4mY4xWrVrl3KN3xRVXyO12a+XKlTp+/LjWrVtX7ON4K1euLLbfVq1apdmzZxebnpaWVmJNRQMkgBMq5T1MR44cUcuWLTVs2DDn88beeuihh7Ro0SJNnTpVzZs314EDB3TgwIFyrhQ4e37++WdlZmY6by4K/9v46KOPKiEhocRlCtt26tRJP/74oz766CMtWrRI//jHP/TSSy/p9ddfL3b/hE3h9u666y7rPREn3wdgGxGrpDceZXUuRt2Kjo5WbGysli9froYNG8oYo/j4eEVEROihhx5Samqqvv76a7Vv315+fif+r1W4v6ZMmaJWrVqVuN6SrriU1Zns67IcHz/99FOxMLFs2TKPLxsu6rLLLtPGjRu1Z88ej5HGLr30Ul166aWSVGwUxIKCAvXo0UOPP/54iessXK7Q6faBN+dMoZJGpHzggQeUlJSkhx9+WPHx8QoNDZXL5dLtt99uvZpyOo899phSUlK0ePFiZ3CJQt7uh7K6EI5zl8ulDz/8UN98840+/vhjffHFFxo2bJheeOEFffPNN2WqpVatWpJOhLKT+6Zly5aqUaOGVqxYoeuvv14HDhxwrjD5+fkpLi5OK1asUKNGjZSTk1MsMLVs2bLY4Cp//vOfFRUVpccee8xj+skDbRTWVLt2ba9fE3Chq5SBqWfPnsVGTioqOztbTz31lN577z1lZGToiiuu0F//+lfnD/fWrVs1ffp0bd682flPW0n/NQQqssLvpyl8o1d4BSYwMLDY6E0lqVmzpoYOHaqhQ4fq8OHD6tSpk8aNG6fhw4c769q8ebN1+YiICNWoUUP5+fml2l5pFH4fy/bt29W1a1dnem5urnbt2lXil0KWdTvLli3T0aNHPa4ylTRin03Hjh21fPlyxcbGqlWrVqpRo4Zatmyp0NBQLVy4UOvXr9f48eOd9o0aNZIkud1ur/dX4X7ZsWOHx++q33//vVRXjGxO9Z/oUx0fJYmKiir2Ru9U/XXDDTdo9uzZeuedd6xv/E/WqFEjHT58uNyON2/PGZsPP/xQgwcP1gsvvOBMO378eKlGoyvJ7NmzNW3aNE2bNq3ELzst7X5o0KCBlixZosOHD3sEA2++9+lCOM4lqV27dmrXrp2effZZvfvuuxowYIBmz56t4cOHe31F5rLLLpMk7dq1S82bN/eY5+/vr3bt2mnlypVasWKF3G63R5v27dvr/fffd4L4yYEpPDy82H4LDw9X3bp1S7U/y/P3JHAhqZQfyTud+++/XykpKZo9e7a+++479evXT9ddd53zUYGPP/5YF198sT755BPFxsaqYcOGGj58OFeYcN5YunSpJk6cqNjYWA0YMECSFBkZqS5duuiNN97Qvn37ii1TdKjdws/gF6pevboaN27sfEwlIiJCnTp10owZM4p97KPwP7f+/v7q27ev/vOf/5QYrE4e2rc0rrrqKkVEROj111/3+DjXzJkzy/zmsyQJCQnKzc3VW2+95UwrKCjQq6++Wup1dOzYUbt379b777/vfHTJz89P7du314svvqjc3FyPkcPatGmjRo0aaerUqSV+FO1U+6tbt24KCAjQ9OnTPab//e9/L3W9JalWrVqJ+/V0x0dJQkJC1L17d4+H7WNU0onvjGnWrJkmTpyob775psQ2J18N69+/v1JSUvTFF18Ua5uRkaG8vDzr9krizTlzKv7+/sVqfeWVV8r0HVKbN2/W8OHDddddd+mhhx4qsU1p98P111+vvLw8j+MmPz9fr7zySqnrOd+P84MHDxbrm8IrX4XHc+E/TUr7O6ZNmzYKCgrS2rVrS5zfoUMH/frrr0pKSlJcXJxz9U06EZi2bdumjz76SLVq1VLTpk29fEV2mZmZ+vHHH50rWgD+UCmvMJ1KWlqakpKSlJaW5txI+eijj2rhwoVKSkrSc889p507dyo1NVVz5szRv/71L+Xn52v06NG69dZbtXTpUh+/AsDT559/rh9++EF5eXnav3+/li5dquTkZDVo0EALFizw+NjSq6++qg4dOqh58+YaMWKELr74Yu3fv18pKSn6+eef9e2330qSmjVrpi5duqhNmzaqWbOm1q5dqw8//FD333+/s66XX35ZHTp00JVXXqmRI0cqNjZWu3fv1qeffqqNGzdKOjFM+LJlyxQXF6cRI0aoWbNmOnDggNavX6/Fixd7/U+IwMBAPfPMM7rnnnvUtWtX3Xbbbdq1a5eSkpLK9YsYb7rpJrVt21Z//vOftWPHDl122WVasGCBU29p/uNc+CZx27Zteu6555zpnTp10ueff+58708hPz8//eMf/1DPnj11+eWXa+jQoapXr5727NmjZcuWye12O0Ntn6xOnTp66KGH9MILL+jGG2/Uddddp2+//Vaff/65ateuXeZ7Ftq0aaPp06frmWeeUePGjRUZGamuXbuW6vg4U4GBgZo3b54SEhLUoUMH3XLLLerYsaOqVaumPXv2aMGCBUpLS1OvXr2cZR577DEtWLBAN9xwg4YMGaI2bdroyJEj2rRpkz788EPt3r3b648jlfacOZUbbrhB//73vxUaGqpmzZo5H6Ur/OiWNwrv/+vUqVOx71hr3769Lr744lLvh969e+vqq6/Wk08+qd27d6tZs2aaO3euV/dVne/H+T//+U+99tpruvnmm9WoUSMdOnRIb731ltxut66//npJJz5m2axZM73//vu69NJLVbNmTV1xxRXWezhDQkJ07bXXavHixZowYUKx+YVXjVJSUop9n1Ph1zB888036t27d7neb7R48WJnKHkAJzmnY/JVQJLMvHnznOeffPKJkWSqVavm8QgICDD9+/c3xhgzYsQII8ls27bNWW7dunVGkvnhhx/O9UsASlQ4bG7hIygoyERFRZkePXqYv/3tbyYrK6vE5X788UczaNAgExUVZQIDA029evXMDTfcYD788EOnzTPPPGPatm1rwsLCTJUqVcxll11mnn32WWco3EKbN282N998swkLCzMhISGmSZMmZuzYsR5t9u/fb0aNGmViYmJMYGCgiYqKMt26dTNvvvmm06ZwOOU5c+Z4LFvS0ODGnBh+NzY21gQHB5urrrrKLF++3HTu3LlUw4pXq1at2D5JTEw0J/+6/PXXX82dd95patSoYUJDQ82QIUPMypUrjSQze/bsEvftySIjI40ks3//fmfaihUrjCTTsWPHEpfZsGGDueWWW0ytWrVMcHCwadCggenfv79ZsmSJ0+bk4ZaNOTEc9NixY01UVJSpUqWK6dq1q9m6daupVauWuffee4ste/IwyiUNaZ2enm569eplatSo4TFse2mPj/KQkZFhJkyYYFq3bm2qV69ugoKCTExMjLn11ls9hv8udOjQITNmzBjTuHFjExQUZGrXrm3at29vpk6d6tRXeGxMmTKl2PIqYfjo0pwzpxrm/+DBg2bo0KGmdu3apnr16iYhIcH88MMPpkGDBh7DQZdmWPEGDRp4nPdFH0WP9dLsB2NODPs9cOBA43a7TWhoqBk4cKDZsGFDqYYVL3Q+H+fr1683d9xxh6lfv74JDg42kZGR5oYbbjBr1671WG7VqlWmTZs2JigoqFRDjM+dO9e4XC5nCPeijhw5YgICAowks2jRomLzW7RoYSSZv/71r6fcRqHSDit+2223mQ4dOpRqnUBl4zKmHO+WPg+5XC7NmzdPN910kyTp/fff14ABA7Rly5ZiN4NWr15dUVFRSkxM1HPPPecxxOixY8dUtWpVLVq0qNy+mBHA+WX+/Pm6+eabtWLFCmdkq4osIyND4eHheuaZZ5wvnwUuNBXxOM/Pz1ezZs3Uv39/TZw40dflKD09XbGxsZo9ezZXmIAScA/TSVq3bq38/Hz98ssvaty4scejcESZq6++Wnl5efrxxx+d5f73v/9J+uOmUwAXtmPHjnk8L7y3w+1268orr/RRVXYn1ytJ06ZNkyTrSHTA+eZ8Oc79/f01YcIEvfrqqyXeq3WuTZs2Tc2bNycsARaV8grT4cOHndGsWrdurRdffFHXXHONatasqfr16+uuu+7SypUr9cILL6h169b69ddftWTJErVo0UK9evVSQUGB/u///k/Vq1fXtGnTVFBQoFGjRsntdmvRokU+fnUAzoXhw4fr2LFjio+PV3Z2tubOnatVq1bpueee05gxY3xdXjEzZ87UzJkzdf3116t69epasWKF3nvvPV177bUl3vwPnI84zgGcDZUyMH355Ze65pprik0fPHiwZs6cqdzcXD3zzDP617/+pT179qh27dpq166dxo8f7wzvuXfvXj3wwANatGiRqlWrpp49e+qFF15QzZo1z/XLAeAD7777rl544QXt2LFDx48fV+PGjfWnP/2pXAc2KE/r16/X448/ro0bNyorK0t16tRR37599cwzz5Tr99oAvsRxDuBsqJSBCQAAAABKg3uYAAAAAMCCwAQAAAAAFpXmi2sLCgq0d+9e1ahRo1y/6A0AAADA+cUYo0OHDik6Olp+fqe+hlRpAtPevXsVExPj6zIAAAAAVBA//fSTLrroolO2qTSBqUaNGpJO7BS32+3jagAAAAD4SlZWlmJiYpyMcCqVJjAVfgzP7XYTmAAAAACU6lYdBn0AAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYBHg6wLwhx5+/XxdAlAukgvm+LoEAACAcsEVJgAAAACw8CowNWzYUC6Xq9hj1KhRJbafOXNmsbYhISHO/NzcXD3xxBNq3ry5qlWrpujoaA0aNEh79+497XYnT55chpcLAAAAAKXn1Ufy1qxZo/z8fOf55s2b1aNHD/XrZ/8omdvt1rZt25znLpfL+fno0aNav369xo4dq5YtW+rgwYN66KGHdOONN2rt2rUe65kwYYJGjBjhPK9Ro4Y3pQMAAACA17wKTBERER7PJ0+erEaNGqlz587WZVwul6KiokqcFxoaquTkZI9pf//739W2bVulpaWpfv36zvQaNWpY1wMAAAAAZ0OZ72HKycnRrFmzNGzYMI+rRic7fPiwGjRooJiYGPXp00dbtmw55XozMzPlcrkUFhbmMX3y5MmqVauWWrdurSlTpigvL++U68nOzlZWVpbHAwAAAAC8UeZR8ubPn6+MjAwNGTLE2qZJkyaaMWOGWrRooczMTE2dOlXt27fXli1bdNFFFxVrf/z4cT3xxBO644475Ha7nekPPvigrrzyStWsWVOrVq3SmDFjtG/fPr344ovWbU+aNEnjx48v68sDAAAAALmMMaYsCyYkJCgoKEgff/xxqZfJzc1V06ZNdccdd2jixInF5vXt21c///yzvvzyS4/AdLIZM2bonnvu0eHDhxUcHFxim+zsbGVnZzvPs7KyFBMTo8zMzFOu25cYVhwXCoYVBwAAFVlWVpZCQ0NLlQ3KdIUpNTVVixcv1ty5c71aLjAwUK1bt9aOHTs8pufm5qp///5KTU3V0qVLT1t0XFyc8vLytHv3bjVp0qTENsHBwdYwBQAAAAClUaZ7mJKSkhQZGalevXp5tVx+fr42bdqkunXrOtMKw9L27du1ePFi1apV67Tr2bhxo/z8/BQZGel17QAAAABQWl5fYSooKFBSUpIGDx6sgADPxQcNGqR69epp0qRJkk4MBd6uXTs1btxYGRkZmjJlilJTUzV8+HBJJ8LSrbfeqvXr1+uTTz5Rfn6+0tPTJUk1a9ZUUFCQUlJStHr1al1zzTWqUaOGUlJSNHr0aN11110KDw8/09cPAAAAAFZeB6bFixcrLS1Nw4YNKzYvLS1Nfn5/XLQ6ePCgRowYofT0dIWHh6tNmzZatWqVmjVrJknas2ePFixYIElq1aqVx7qWLVumLl26KDg4WLNnz9a4ceOUnZ2t2NhYjR49Wo888oi3pQMAAACAV8o86MP5xpsbu3yFQR9woWDQBwAAUJF5kw3K/D1MAAAAAHChIzABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMDC6y+uBYDT4TvFUFp8ZxcAoKLjChMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYBvi4AAFB59fDr5+sSzpnkgjm+LgEAUAZcYQIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwCLA1wUAAFAZ9PDr5+sSzqnkgjm+LgEAygVXmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWAb4uAAAAXHh6+PXzdQnnVHLBHF+XAOAs4QoTAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWAb4uAAAA4HzXw6+fr0s4Z5IL5vi6BOCc4goTAAAAAFh4FZgaNmwol8tV7DFq1KgS28+cObNY25CQEGd+bm6unnjiCTVv3lzVqlVTdHS0Bg0apL1793qs58CBAxowYIDcbrfCwsJ099136/Dhw2V4uQAAAABQel59JG/NmjXKz893nm/evFk9evRQv372y9But1vbtm1znrtcLufno0ePav369Ro7dqxatmypgwcP6qGHHtKNN96otWvXOu0GDBigffv2KTk5Wbm5uRo6dKhGjhypd99915vyAQAAAMArXgWmiIgIj+eTJ09Wo0aN1LlzZ+syLpdLUVFRJc4LDQ1VcnKyx7S///3vatu2rdLS0lS/fn1t3bpVCxcu1Jo1a3TVVVdJkl555RVdf/31mjp1qqKjo715CQAAAABQamW+hyknJ0ezZs3SsGHDPK4anezw4cNq0KCBYmJi1KdPH23ZsuWU683MzJTL5VJYWJgkKSUlRWFhYU5YkqTu3bvLz89Pq1evtq4nOztbWVlZHg8AAAAA8EaZA9P8+fOVkZGhIUOGWNs0adJEM2bM0EcffaRZs2apoKBA7du3188//1xi++PHj+uJJ57QHXfcIbfbLUlKT09XZGSkR7uAgADVrFlT6enp1m1PmjRJoaGhziMmJsb7FwkAAACgUitzYHr77bfVs2fPU34kLj4+XoMGDVKrVq3UuXNnzZ07VxEREXrjjTeKtc3NzVX//v1ljNH06dPLWpZjzJgxyszMdB4//fTTGa8TAAAAQOVSpu9hSk1N1eLFizV37lyvlgsMDFTr1q21Y8cOj+mFYSk1NVVLly51ri5JUlRUlH755ReP9nl5eTpw4ID13ihJCg4OVnBwsFf1AQAAAEBRZbrClJSUpMjISPXq1cur5fLz87Vp0ybVrVvXmVYYlrZv367FixerVq1aHsvEx8crIyND69atc6YtXbpUBQUFiouLK0v5AAAAAFAqXl9hKigoUFJSkgYPHqyAAM/FBw0apHr16mnSpEmSpAkTJqhdu3Zq3LixMjIyNGXKFKWmpmr48OGSToSlW2+9VevXr9cnn3yi/Px8576kmjVrKigoSE2bNtV1112nESNG6PXXX1dubq7uv/9+3X777YyQBwAAAOCs8jowLV68WGlpaRo2bFixeWlpafLz++Oi1cGDBzVixAilp6crPDxcbdq00apVq9SsWTNJ0p49e7RgwQJJUqtWrTzWtWzZMnXp0kWS9M477+j+++9Xt27d5Ofnp759++rll1/2tnQAAAAA8IrLGGN8XcS5kJWVpdDQUGVmZnrcI1WR9PCzfwEwAABARZBcMMfXJQBnzJtsUOZR8gAAAADgQkdgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACAhddfXAsAAIDKi++NPDN8j9X5hytMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYBPi6AAAAAKCy6OHXz9clnDPJBXN8XUK54AoTAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWAb4uAKgMvti70dclnFJCdCtflwAAAC4wPfz6lev6kgvmlOv6SosrTAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWAT4ugCgMkiIbuXrEgAAAFAGXGECAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALDwKjA1bNhQLper2GPUqFEltp85c2axtiEhIR5t5s6dq2uvvVa1atWSy+XSxo0bi62nS5cuxdZz7733elM6AAAAAHgtwJvGa9asUX5+vvN88+bN6tGjh/r162ddxu12a9u2bc5zl8vlMf/IkSPq0KGD+vfvrxEjRljXM2LECE2YMMF5XrVqVW9KBwAAAACveRWYIiIiPJ5PnjxZjRo1UufOna3LuFwuRUVFWecPHDhQkrR79+5Tbrtq1aqnXA8AAAAAlLcy38OUk5OjWbNmadiwYcWuGhV1+PBhNWjQQDExMerTp4+2bNlSpu298847ql27tq644gqNGTNGR48ePWX77OxsZWVleTwAAAAAwBteXWEqav78+crIyNCQIUOsbZo0aaIZM2aoRYsWyszM1NSpU9W+fXtt2bJFF110Uam3deedd6pBgwaKjo7Wd999pyeeeELbtm3T3LlzrctMmjRJ48eP9+YlAQAAAIAHlzHGlGXBhIQEBQUF6eOPPy71Mrm5uWratKnuuOMOTZw40WPe7t27FRsbqw0bNqhVq1anXM/SpUvVrVs37dixQ40aNSqxTXZ2trKzs53nWVlZiomJUWZmptxud6lrPpd6+NnvBQMAAAAqs+SCOeW2rqysLIWGhpYqG5TpClNqaqoWL158yis8JQkMDFTr1q21Y8eOsmzWERcXJ0mnDEzBwcEKDg4+o+0AAAAAqNzKdA9TUlKSIiMj1atXL6+Wy8/P16ZNm1S3bt2ybNZROPT4ma4HAAAAAE7F6ytMBQUFSkpK0uDBgxUQ4Ln4oEGDVK9ePU2aNEmSNGHCBLVr106NGzdWRkaGpkyZotTUVA0fPtxZ5sCBA0pLS9PevXslyRmCPCoqSlFRUfrxxx/17rvv6vrrr1etWrX03XffafTo0erUqZNatGhR5hcOAAAAAKfjdWBavHix0tLSNGzYsGLz0tLS5Of3x0WrgwcPasSIEUpPT1d4eLjatGmjVatWqVmzZk6bBQsWaOjQoc7z22+/XZKUmJiocePGKSgoSIsXL9a0adN05MgRxcTEqG/fvvrLX/7ibekAAAAA4JUyD/pwvvHmxi5fYdAHAAAAoGS+GvShzN/DBAAAAAAXOgITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIBFgK8LACqDL/ZuLNf1JUS3Ktf1AQAAoGRcYQIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwCLA1wUAlUFCdCtflwDAx77Yu7Fc18fvFQA4N7jCBAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABg4VVgatiwoVwuV7HHqFGjSmw/c+bMYm1DQkI82sydO1fXXnutatWqJZfLpY0bNxZbz/HjxzVq1CjVqlVL1atXV9++fbV//35vSgcAAAAAr3kVmNasWaN9+/Y5j+TkZElSv379rMu43W6PZVJTUz3mHzlyRB06dNBf//pX6zpGjx6tjz/+WHPmzNFXX32lvXv36pZbbvGmdAAAAADwWoA3jSMiIjyeT548WY0aNVLnzp2ty7hcLkVFRVnnDxw4UJK0e/fuEudnZmbq7bff1rvvvquuXbtKkpKSktS0aVN98803ateunTcvAQAAAABKrcz3MOXk5GjWrFkaNmyYXC6Xtd3hw4fVoEEDxcTEqE+fPtqyZYtX21m3bp1yc3PVvXt3Z9pll12m+vXrKyUlxbpcdna2srKyPB4AAAAA4I0yB6b58+crIyNDQ4YMsbZp0qSJZsyYoY8++kizZs1SQUGB2rdvr59//rnU20lPT1dQUJDCwsI8ptepU0fp6enW5SZNmqTQ0FDnERMTU+ptAgAAAIB0BoHp7bffVs+ePRUdHW1tEx8fr0GDBqlVq1bq3Lmz5s6dq4iICL3xxhtl3WypjRkzRpmZmc7jp59+OuvbBAAAAHBh8eoepkKpqalavHix5s6d69VygYGBat26tXbs2FHqZaKiopSTk6OMjAyPq0z79+8/5b1RwcHBCg4O9qo+AAAAACiqTFeYkpKSFBkZqV69enm1XH5+vjZt2qS6deuWepk2bdooMDBQS5YscaZt27ZNaWlpio+P92r7AAAAAOANr68wFRQUKCkpSYMHD1ZAgOfigwYNUr169TRp0iRJ0oQJE9SuXTs1btxYGRkZmjJlilJTUzV8+HBnmQMHDigtLU179+6VdCIMSSeuLEVFRSk0NFR33323HnnkEdWsWVNut1sPPPCA4uPjGSEPAAAAwFnldWBavHix0tLSNGzYsGLz0tLS5Of3x0WrgwcPasSIEUpPT1d4eLjatGmjVatWqVmzZk6bBQsWaOjQoc7z22+/XZKUmJiocePGSZJeeukl+fn5qW/fvsrOzlZCQoJee+01b0sHAAAAAK+4jDHG10WcC1lZWQoNDVVmZqbcbrevyylRDz/7FwADAM5vX+zdWK7rS4huVa7rA4CKLrlgTrmty5tsUOZR8gAAAADgQkdgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACAhddfXIvzR3l/50d54vtDAAAAcD7gChMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYBvi4Af/hi78ZyXV9CdKtyXR8AoOz4nQwA5yeuMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYBHg6wLwh4ToVuW6vi/2biy3dZV3bQAAAMD5gCtMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYBPi6AJw9CdGtfF0CAAAAcF7jChMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACw8CowNWzYUC6Xq9hj1KhRJbafOXNmsbYhISEebYwxevrpp1W3bl1VqVJF3bt31/bt20+73cmTJ3v5UgEAAADAOwHeNF6zZo3y8/Od55s3b1aPHj3Ur18/6zJut1vbtm1znrtcLo/5zz//vF5++WX985//VGxsrMaOHauEhAR9//33HuFqwoQJGjFihPO8Ro0a3pQOAAAAAF7zKjBFRER4PJ88ebIaNWqkzp07W5dxuVyKiooqcZ4xRtOmTdNf/vIX9enTR5L0r3/9S3Xq1NH8+fN1++23O21r1KhhXQ8AAAAAnA1lvocpJydHs2bN0rBhw4pdNSrq8OHDatCggWJiYtSnTx9t2bLFmbdr1y6lp6ere/fuzrTQ0FDFxcUpJSXFYz2TJ09WrVq11Lp1a02ZMkV5eXmnrC87O1tZWVkeDwAAAADwhldXmIqaP3++MjIyNGTIEGubJk2aaMaMGWrRooUyMzM1depUtW/fXlu2bNFFF12k9PR0SVKdOnU8lqtTp44zT5IefPBBXXnllapZs6ZWrVqlMWPGaN++fXrxxRet2540aZLGjx9f1pcHAAAAAHIZY0xZFkxISFBQUJA+/vjjUi+Tm5urpk2b6o477tDEiRO1atUqXX311dq7d6/q1q3rtOvfv79cLpfef//9EtczY8YM3XPPPTp8+LCCg4NLbJOdna3s7GzneVZWlmJiYpSZmSm3213qms+lHn72e8EAAACAyiy5YE65rSsrK0uhoaGlygZl+kheamqqFi9erOHDh3u1XGBgoFq3bq0dO3ZIknNP0v79+z3a7d+//5T3K8XFxSkvL0+7d++2tgkODpbb7fZ4AAAAAIA3yhSYkpKSFBkZqV69enm1XH5+vjZt2uRcTYqNjVVUVJSWLFnitMnKytLq1asVHx9vXc/GjRvl5+enyMjIspQPAAAAAKXi9T1MBQUFSkpK0uDBgxUQ4Ln4oEGDVK9ePU2aNEnSiaHA27Vrp8aNGysjI0NTpkxRamqqc2XK5XLp4Ycf1jPPPKNLLrnEGVY8OjpaN910kyQpJSVFq1ev1jXXXKMaNWooJSVFo0eP1l133aXw8PAzfPkAAAAAYOd1YFq8eLHS0tI0bNiwYvPS0tLk5/fHRauDBw9qxIgRSk9PV3h4uNq0aaNVq1apWbNmTpvHH39cR44c0ciRI5WRkaEOHTpo4cKFzncwBQcHa/bs2Ro3bpyys7MVGxur0aNH65FHHinL6wUAAACAUivzoA/nG29u7PIVBn0AAAAASnZeDfoAAAAAAJUBgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwCPB1AfhDeX4ZV3njS3UBAABQGXGFCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGAR4OsCcH5ILpjj6xLOqR5+/XxdAs6SL/ZuLNf1JUS3Ktf1AQCAioUrTAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWAT4ugCgIkoumOPrEs6pHn79fF3COZMQ3crXJQAAgPMIV5gAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAI8HUBAHwvuWCOr0s4Z3r49fN1CQDK4Iu9G8t1fQnRrcp1fQAuXFxhAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAIsDXBQDAuZRcMMfXJZzXevj183UJqKQSoluV6/r4XQCgtLjCBAAAAAAWXgWmhg0byuVyFXuMGjWqxPYzZ84s1jYkJMSjjTFGTz/9tOrWrasqVaqoe/fu2r59u0ebAwcOaMCAAXK73QoLC9Pdd9+tw4cPe/lSAQAAAMA7XgWmNWvWaN++fc4jOTlZktSvn/0jGm6322OZ1NRUj/nPP/+8Xn75Zb3++utavXq1qlWrpoSEBB0/ftxpM2DAAG3ZskXJycn65JNPtHz5co0cOdKb0gEAAADAa17dwxQREeHxfPLkyWrUqJE6d+5sXcblcikqKqrEecYYTZs2TX/5y1/Up08fSdK//vUv1alTR/Pnz9ftt9+urVu3auHChVqzZo2uuuoqSdIrr7yi66+/XlOnTlV0dLQ3LwEAAAAASq3M9zDl5ORo1qxZGjZsmFwul7Xd4cOH1aBBA8XExKhPnz7asmWLM2/Xrl1KT09X9+7dnWmhoaGKi4tTSkqKJCklJUVhYWFOWJKk7t27y8/PT6tXr7ZuNzs7W1lZWR4PAAAAAPBGmQPT/PnzlZGRoSFDhljbNGnSRDNmzNBHH32kWbNmqaCgQO3bt9fPP/8sSUpPT5ck1alTx2O5OnXqOPPS09MVGRnpMT8gIEA1a9Z02pRk0qRJCg0NdR4xMTFleZkAAAAAKrEyB6a3335bPXv2POVH4uLj4zVo0CC1atVKnTt31ty5cxUREaE33nijrJsttTFjxigzM9N5/PTTT2d9mwAAAAAuLGX6HqbU1FQtXrxYc+fO9Wq5wMBAtW7dWjt27JAk596m/fv3q27duk67/fv3q1WrVk6bX375xWM9eXl5OnDggPXeKEkKDg5WcHCwV/UBAAAAQFFlusKUlJSkyMhI9erVy6vl8vPztWnTJiccxcbGKioqSkuWLHHaZGVlafXq1YqPj5d04ipVRkaG1q1b57RZunSpCgoKFBcXV5byAQAAAKBUvL7CVFBQoKSkJA0ePFgBAZ6LDxo0SPXq1dOkSZMkSRMmTFC7du3UuHFjZWRkaMqUKUpNTdXw4cMlnRhB7+GHH9YzzzyjSy65RLGxsRo7dqyio6N10003SZKaNm2q6667TiNGjNDrr7+u3Nxc3X///br99tsZIQ8AAADAWeV1YFq8eLHS0tI0bNiwYvPS0tLk5/fHRauDBw9qxIgRSk9PV3h4uNq0aaNVq1apWbNmTpvHH39cR44c0ciRI5WRkaEOHTpo4cKFHl9w+8477+j+++9Xt27d5Ofnp759++rll1/2tnQAAAAA8IrLGGN8XcS5kJWVpdDQUGVmZsrtdvu6HAA4L/Xws39ROXA+SS6Y4+sSAPiQN9mgzKPkAQAAAMCFjsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALr7+4FgBQefHdNQCAyoYrTAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAACLAF8XcK4YYyRJWVlZPq4EAAAAgC8VZoLCjHAqlSYwHTp0SJIUExPj40oAAAAAVASHDh1SaGjoKdu4TGli1QWgoKBAe/fuVY0aNeRyuXxdTqWVlZWlmJgY/fTTT3K73b4up1KjLyoW+qPioC8qDvqiYqE/Kg764swZY3To0CFFR0fLz+/UdylVmitMfn5+uuiii3xdBv5/brebE7yCoC8qFvqj4qAvKg76omKhPyoO+uLMnO7KUiEGfQAAAAAACwITAAAAAFgQmHBOBQcHKzExUcHBwb4updKjLyoW+qPioC8qDvqiYqE/Kg764tyqNIM+AAAAAIC3uMIEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEywmjx5slwulx5++GFn2ptvvqkuXbrI7XbL5XIpIyOj2HIHDhzQgAED5Ha7FRYWprvvvluHDx/2aPPdd9+pY8eOCgkJUUxMjJ5//vli65kzZ44uu+wyhYSEqHnz5vrss8885htj9PTTT6tu3bqqUqWKunfvru3bt5fLa6+IytofDRs2lMvl8nhMnjzZow394Z2T++LAgQN64IEH1KRJE1WpUkX169fXgw8+qMzMTI/l0tLS1KtXL1WtWlWRkZF67LHHlJeX59Hmyy+/1JVXXqng4GA1btxYM2fOLLb9V199VQ0bNlRISIji4uL03//+12P+8ePHNWrUKNWqVUvVq1dX3759tX///nLdBxVJWfvj5PPC5XJp9uzZHm3oD++U9HvqnnvuUaNGjVSlShVFRESoT58++uGHHzyW49wof2XtC86Ls6Ok/ihkjFHPnj3lcrk0f/58j3mcGxWEAUrw3//+1zRs2NC0aNHCPPTQQ870l156yUyaNMlMmjTJSDIHDx4stux1111nWrZsab755hvz9ddfm8aNG5s77rjDmZ+ZmWnq1KljBgwYYDZv3mzee+89U6VKFfPGG284bVauXGn8/f3N888/b77//nvzl7/8xQQGBppNmzY5bSZPnmxCQ0PN/PnzzbfffmtuvPFGExsba44dO3ZW9okvnUl/NGjQwEyYMMHs27fPeRw+fNiZT394p6S+2LRpk7nlllvMggULzI4dO8ySJUvMJZdcYvr27essl5eXZ6644grTvXt3s2HDBvPZZ5+Z2rVrmzFjxjhtdu7caapWrWoeeeQR8/3335tXXnnF+Pv7m4ULFzptZs+ebYKCgsyMGTPMli1bzIgRI0xYWJjZv3+/0+bee+81MTExZsmSJWbt2rWmXbt2pn379md/5/hAWfvDGGMkmaSkJI9zo+jxSn94x/Z76o033jBfffWV2bVrl1m3bp3p3bu3iYmJMXl5ecYYzo2zoax9YQznxdlg649CL774ounZs6eRZObNm+dM59yoOAhMKObQoUPmkksuMcnJyaZz584lntzLli0r8Q36999/bySZNWvWONM+//xz43K5zJ49e4wxxrz22msmPDzcZGdnO22eeOIJ06RJE+d5//79Ta9evTzWHRcXZ+655x5jjDEFBQUmKirKTJkyxZmfkZFhgoODzXvvvVfm114RnUl/GHMiML300kvW9dMfpVeavij0wQcfmKCgIJObm2uMMeazzz4zfn5+Jj093Wkzffp043a7nX3/+OOPm8svv9xjPbfddptJSEhwnrdt29aMGjXKeZ6fn2+io6PNpEmTjDEn9ntgYKCZM2eO02br1q1GkklJSSn7i6+AzqQ/jDHF3pycjP4oPW/64ttvvzWSzI4dO4wxnBvl7Uz6whjOi/J2uv7YsGGDqVevntm3b1+xfc+5UXHwkTwUM2rUKPXq1Uvdu3f3etmUlBSFhYXpqquucqZ1795dfn5+Wr16tdOmU6dOCgoKctokJCRo27ZtOnjwoNPm5O0nJCQoJSVFkrRr1y6lp6d7tAkNDVVcXJzT5kJxJv1RaPLkyapVq5Zat26tKVOmeFzOpz9Kz5u+yMzMlNvtVkBAgKQT+7B58+aqU6eO0yYhIUFZWVnasmWL0+ZU+zknJ0fr1q3zaOPn56fu3bs7bdatW6fc3FyPNpdddpnq169/QfWFdGb9UXQdtWvXVtu2bTVjxgyZIl9NSH+UXmn74siRI0pKSlJsbKxiYmIkcW6UtzPpi6Lr4LwoH6fqj6NHj+rOO+/Uq6++qqioqGLzOTcqjoDTN0FlMnv2bK1fv15r1qwp0/Lp6emKjIz0mBYQEKCaNWsqPT3daRMbG+vRpvCXQXp6usLDw5Wenu7xC6KwTdF1FF2upDYXgjPtD0l68MEHdeWVV6pmzZpatWqVxowZo3379unFF1+URH+Uljd98dtvv2nixIkaOXKkM822DwvnnapNVlaWjh07poMHDyo/P7/ENoX3IaSnpysoKEhhYWHF2lwofSGdeX9I0oQJE9S1a1dVrVpVixYt0n333afDhw/rwQcflER/lFZp+uK1117T448/riNHjqhJkyZKTk52/knDuVF+zrQvJM6L8nS6/hg9erTat2+vPn36lDifc6PiIDDB8dNPP+mhhx5ScnKyQkJCfF1OpVde/fHII484P7do0UJBQUG65557NGnSJAUHB5dHqRc8b/oiKytLvXr1UrNmzTRu3LhzU2AlU179MXbsWOfn1q1b68iRI5oyZYrzxhCnV9q+GDBggHr06KF9+/Zp6tSp6t+/v1auXMnfmnJUXn3BeVE+TtcfCxYs0NKlS7VhwwYfVAdv8ZE8ONatW6dffvlFV155pQICAhQQEKCvvvpKL7/8sgICApSfn3/adURFRemXX37xmJaXl6cDBw44l5ujoqKKjbxS+Px0bYrOL7pcSW3Od+XRHyWJi4tTXl6edu/eLYn+KI3S9sWhQ4d03XXXqUaNGpo3b54CAwOddZzJfna73apSpYpq164tf3//0/ZFTk5OsRETL5S+kMqnP0oSFxenn3/+WdnZ2ZLoj9IobV+EhobqkksuUadOnfThhx/qhx9+0Lx58yRxbpSX8uiLknBelM3p+iM5OVk//vijwsLCnPmS1LdvX3Xp0kUS50ZFQmCCo1u3btq0aZM2btzoPK666ioNGDBAGzdulL+//2nXER8fr4yMDK1bt86ZtnTpUhUUFCguLs5ps3z5cuXm5jptkpOT1aRJE4WHhzttlixZ4rHu5ORkxcfHS5JiY2MVFRXl0SYrK0urV6922pzvyqM/SrJx40b5+fk5H52kP06vNH2RlZWla6+9VkFBQVqwYEGx/yjGx8dr06ZNHv9QSE5OltvtVrNmzZw2p9rPQUFBatOmjUebgoICLVmyxGnTpk0bBQYGerTZtm2b0tLSLoi+kMqnP0qyceNGhYeHO1de6Y/TK8vvKXNiwCnnDTjnRvkoj74oCedF2ZyuP5566il99913HvMl6aWXXlJSUpIkzo0KxZcjTqDiO3lEl3379pkNGzaYt956y0gyy5cvNxs2bDC///670+a6664zrVu3NqtXrzYrVqwwl1xyicew4hkZGaZOnTpm4MCBZvPmzWb27NmmatWqxYaxDggIMFOnTjVbt241iYmJJQ5jHRYWZj766CPz3XffmT59+lyQw1gX5W1/rFq1yrz00ktm48aN5scffzSzZs0yERERZtCgQc466I+yKdoXmZmZJi4uzjRv3tzs2LHDYzjek4dOvvbaa83GjRvNwoULTURERInDwz722GNm69at5tVXXy1xeNjg4GAzc+ZM8/3335uRI0easLAwj1GU7r33XlO/fn2zdOlSs3btWhMfH2/i4+PPzY7xEW/7Y8GCBeatt94ymzZtMtu3bzevvfaaqVq1qnn66aedddIfZVO0L3788Ufz3HPPmbVr15rU1FSzcuVK07t3b1OzZk1nSGPOjbPH277gvDi7TjdqoSzDinNu+B6BCad08smdmJhoJBV7JCUlOW1+//13c8cdd5jq1asbt9tthg4dag4dOuSx3m+//dZ06NDBBAcHm3r16pnJkycX2/YHH3xgLr30UhMUFGQuv/xy8+mnn3rMLygoMGPHjjV16tQxwcHBplu3bmbbtm3l+vorGm/7Y926dSYuLs6EhoaakJAQ07RpU/Pcc8+Z48ePe6yX/vBe0b4oHNa9pMeuXbucZXbv3m169uxpqlSpYmrXrm3+/Oc/ewxzXbiuVq1amaCgIHPxxRd7nFuFXnnlFVO/fn0TFBRk2rZta7755huP+ceOHTP33XefCQ8PN1WrVjU333yz2bdvX3nvggrF2/74/PPPTatWrUz16tVNtWrVTMuWLc3rr79u8vPzPdZLf3ivaF/s2bPH9OzZ00RGRprAwEBz0UUXmTvvvNP88MMPHstwbpwd3vYF58XZ5W1gMoZzo6JwGVNkrEgAAAAAgIN7mAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYBPi6gHPp+PHjysnJ8XUZAAAAAHwsKChIISEhp21XaQLT8ePHFVolXDk67utSAAAAAPhYVFSUdu3addrQVGkCU05OjnJ0XB10vQIUKLn++DSiy8+lIk8s04v8bJnu8vOztD/pk48uy/JFtm3bhnW9Hm0s27KusxTblXf7wni0sdRj+bl0y/7xoynFay9VG9u2JBnbPrXV4WeZ7tHeUkfRDRdt41f09ZTcxrrO8mrvZ5lu2z9FWdufyfRS7NuT5pVbHZb1W5c9C/WUVxvrsiqnNt7WVqydKbndGewLj3XKwrpOU2Kb0mzL23W6vN2ubOsp+VW6vNyuy+NnS22n2Lbnr4qS1+X5J8a27ZKXtbX3U2lqKNK+FNM91mlrU4qfPX/Ne7ke2doUWLZlW/aP9pLkb91G0fUWae+xL0retuc6LW1s04uss+hr8PfY1h8/+xd5LZ7TLa+lFPV4bMtWQ9H1FKnB83UVlDjdtn/s6/c85/xtr9NSq7/l+PWoyXJ8FZ3u2eaPejyOG486i/xc5Oj3bFN0+ul/9mzvZ2lTfHrWoQI1aLNbOTk5BKaTBShQAa6TApMlPNimlyrw2JY9eZ6fZfkzCkzWvzynr680260Qgcm79udVYLK9EToPA1P5BSPb9FLs25PmnY06LtjAVJo2KkUbb2sotvxZDkyW13PBBqZSTS95u/aQc6aBybsAdEaBqTTtz2Fgsoee8g9MpWkvlTYw2d40n93AZA0rpQhG9unlH5j8Pdbzx0HnV+QALDrdc/8UnV5y++KBqWg7W/hSyW08ai1Nm9MHJv+zEJg825e8j0oXmLwfwoFBHwAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgG+LuBcy1OuZKSiWdFlXEVa2KYX+dky3WX8Spwuc3IuLTKvoMjyLsvyLsvPRfOuRxuVPN26zlJs1zbdlDzdeLSx1GP5uXTLFi2h6P4sub0pxf7x7L6ijU7u8lLU4WeZbj2MitRRdMMe3V309ZTcxrrO8mpvO8Stx1xp2p/J9FLs25PmlVsdlvVblz0L9ZRXG+uyKqc23tZWrJ0pud0Z7AuPdcrCuk5TYpvSbMvbdbq83a5s6yn5Vbq83K7L42dLbafYtuevipLX5fknxrbtkpe1tTcquYYCS3u/Ukz3UynalOJnz1/zXq5HtjYFJU53ybZs0T+ekr91G0XXW6S9x74oedue67S0sU0vss6ir8HfY1t//Oxf5LV4Tre8llLU47EtWw1F11OkBs/XVVDidNv+sa/f85zzt71OS63+luPXoybL8VV0umebP+rxOG486izyc5Gj37NN0emn/9mzvSxtiteWdcjzuD+VShOYgoKCFBUVpRXpn52YUPQ4y/dJSQAAAAB8JCoqSkFBQadt5zLGWP+5dqE5fvy4cnJyzuo2srKyFBMTo59++klut/usbgulR79UTPRLxUS/VEz0S8VEv1RM9EvFVNH6JSgoSCEhIadtV2muMElSSEhIqXZKeXC73RXiQIAn+qViol8qJvqlYqJfKib6pWKiXyqm861fGPQBAAAAACwITAAAAABgQWAqZ8HBwUpMTFRwcLCvS0ER9EvFRL9UTPRLxUS/VEz0S8VEv1RM52u/VKpBHwAAAADAG1xhAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMJXBq6++qoYNGyokJERxcXH673//e8r2c+bM0WWXXaaQkBA1b95cn3322TmqtHLxpl/eeustdezYUeHh4QoPD1f37t1P248oG2/Pl0KzZ8+Wy+XSTTfddHYLrKS87ZeMjAyNGjVKdevWVXBwsC699FJ+l50F3vbLtGnT1KRJE1WpUkUxMTEaPXq0jh8/fo6qvfAtX75cvXv3VnR0tFwul+bPn3/aZb788ktdeeWVCg4OVuPGjTVz5syzXmdl422/zJ07Vz169FBERITcbrfi4+P1xRdfnJtiK5GynC+FVq5cqYCAALVq1eqs1XcmCExeev/99/XII48oMTFR69evV8uWLZWQkKBffvmlxParVq3SHXfcobvvvlsbNmzQTTfdpJtuukmbN28+x5Vf2Lztly+//FJ33HGHli1bppSUFMXExOjaa6/Vnj17znHlFzZv+6XQ7t279eijj6pjx47nqNLKxdt+ycnJUY8ePbR79259+OGH2rZtm9566y3Vq1fvHFd+YfO2X9599109+eSTSkxM1NatW/X222/r/fff1//7f//vHFd+4Tpy5IhatmypV199tVTtd+3apV69eumaa67Rxo0b9fDDD2v48OG8OS9n3vbL8uXL1aNHD3322Wdat26drrnmGvXu3VsbNmw4y5VWLt72S6GMjAwNGjRI3bp1O0uVlQMDr7Rt29aMGjXKeZ6fn2+io6PNpEmTSmzfv39/06tXL49pcXFx5p577jmrdVY23vbLyfLy8kyNGjXMP//5z7NVYqVUln7Jy8sz7du3N//4xz/M4MGDTZ8+fc5BpZWLt/0yffp0c/HFF5ucnJxzVWKl5G2/jBo1ynTt2tVj2iOPPGKuvvrqs1pnZSXJzJs375RtHn/8cXP55Zd7TLvttttMQkLCWayscitNv5SkWbNmZvz48eVfEIwx3vXLbbfdZv7yl7+YxMRE07Jly7NaV1lxhckLOTk5Wrdunbp37+5M8/PzU/fu3ZWSklLiMikpKR7tJSkhIcHaHt4rS7+c7OjRo8rNzVXNmjXPVpmVTln7ZcKECYqMjNTdd999LsqsdMrSLwsWLFB8fLxGjRqlOnXq6IorrtBzzz2n/Pz8c1X2Ba8s/dK+fXutW7fO+djezp079dlnn+n6668/JzWjOP7mnx8KCgp06NAh/uZXAElJSdq5c6cSExN9XcopBfi6gPPJb7/9pvz8fNWpU8djep06dfTDDz+UuEx6enqJ7dPT089anZVNWfrlZE888YSio6OL/aFD2ZWlX1asWKG3335bGzduPAcVVk5l6ZedO3dq6dKlGjBggD777DPt2LFD9913n3Jzcyv8H7nzRVn65c4779Rvv/2mDh06yBijvLw83XvvvXwkz4dsf/OzsrJ07NgxValSxUeVoaipU6fq8OHD6t+/v69LqdS2b9+uJ598Ul9//bUCAip2JOEKEyq9yZMna/bs2Zo3b55CQkJ8XU6ldejQIQ0cOFBvvfWWateu7etyUERBQYEiIyP15ptvqk2bNrrtttv01FNP6fXXX/d1aZXal19+qeeee06vvfaa1q9fr7lz5+rTTz/VxIkTfV0aUGG9++67Gj9+vD744ANFRkb6upxKKz8/X3feeafGjx+vSy+91NflnFbFjnMVTO3ateXv76/9+/d7TN+/f7+ioqJKXCYqKsqr9vBeWfql0NSpUzV58mQtXrxYLVq0OJtlVjre9suPP/6o3bt3q3fv3s60goICSVJAQIC2bdumRo0and2iK4GynC9169ZVYGCg/P39nWlNmzZVenq6cnJyFBQUdFZrrgzK0i9jx47VwIEDNXz4cElS8+bNdeTIEY0cOVJPPfWU/Pz4n+i5Zvub73a7ubpUAcyePVvDhw/XnDlz+ESJjx06dEhr167Vhg0bdP/990s68TffGKOAgAAtWrRIXbt29XGVf+C3qReCgoLUpk0bLVmyxJlWUFCgJUuWKD4+vsRl4uPjPdpLUnJysrU9vFeWfpGk559/XhMnTtTChQt11VVXnYtSKxVv++Wyyy7Tpk2btHHjRudx4403OqNNxcTEnMvyL1hlOV+uvvpq7dixwwmwkvS///1PdevWJSyVk7L0y9GjR4uFosJQa4w5e8XCir/5Fdd7772noUOH6r333lOvXr18XU6l53a7i/3Nv/fee9WkSRNt3LhRcXFxvi7Rk48HnTjvzJ492wQHB5uZM2ea77//3owcOdKEhYWZ9PR0Y4wxAwcONE8++aTTfuXKlSYgIMBMnTrVbN261SQmJprAwECzadMmX72EC5K3/TJ58mQTFBRkPvzwQ7Nv3z7ncejQIV+9hAuSt/1yMkbJOzu87Ze0tDRTo0YNc//995tt27aZTz75xERGRppnnnnGVy/hguRtvyQmJpoaNWqY9957z+zcudMsWrTINGrUyPTv399XL+GCc+jQIbNhwwazYcMGI8m8+OKLZsOGDSY1NdUYY8yTTz5pBg4c6LTfuXOnqVq1qnnsscfM1q1bzauvvmr8/f3NwoULffUSLkje9ss777xjAgICzKuvvurxNz8jI8NXL+GC5G2/nKwij5JHYCqDV155xdSvX98EBQWZtm3bmm+++caZ17lzZzN48GCP9h988IG59NJLTVBQkLn88svNp59+eo4rrhy86ZcGDRoYScUeiYmJ577wC5y350tRBKazx9t+WbVqlYmLizPBwcHm4osvNs8++6zJy8s7x1Vf+Lzpl9zcXDNu3DjTqFEjExISYmJiYsx9991nDh48eO4Lv0AtW7asxL8Vhf0wePBg07lz52LLtGrVygQFBZmLL77YJCUlnfO6L3Te9kvnzp1P2R7loyznS1EVOTC5jOG6PQAAAACUhHuYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsPj/AJ5Z+01iEOI2AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -492,68 +740,16 @@ ], "source": [ "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Confidence\")\n", - "clrbar = ax.imshow(t_pprb_conf)\n", + "ax.set_title(\"Descending weights - Generalized weighst (W+)\")\n", + "clrbar = ax.imshow(test_gen_dsc_[\"Generalized W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(t_pprb_conf, ax = ax, transform = test_ev.transform)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Optional: Save the probability arrays to raster files" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "list_pprbs = [t_pprb_array, t_pprb_std, t_pprb_conf]\n", - "arry_tif(out_meta, 'pprb.tif', list_pprbs, 0) #saves the posterior probability raster\n", - "arry_tif(out_meta, 'pprb_std.tif', list_pprbs, 1) #saves the standard deviation of the prosterior probability raster\n", - "arry_tif(out_meta, 'pprb_conf.tif', list_pprbs, 2) #saves the confidence score in the posterior probability calculcations as a raster\n", - "\n" + "show(test_gen_dsc_[\"Generalized W+\"], ax = ax, transform = test_ev.transform, cmap='viridis')" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "eis_toolkit", "language": "python", "name": "python3" }, @@ -567,7 +763,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.13" + "version": "3.10.12" }, "orig_nbformat": 4 }, diff --git a/notebooks/wofe_new.ipynb b/notebooks/wofe_new.ipynb deleted file mode 100644 index 37297743..00000000 --- a/notebooks/wofe_new.ipynb +++ /dev/null @@ -1,772 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import rasterio\n", - "from matplotlib import pyplot as plt\n", - "from rasterio.plot import show\n", - "import geopandas as gpd\n", - "\n", - "import sys\n", - "sys.path.insert(0, \"..\")\n", - "\n", - "from eis_toolkit.prediction.wofe_new import weights_of_evidence" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# with rasterio.open(\"../tests/data/remote/wofe/wofe_ev_nan.tif\") as test_ev:\n", - "# with rasterio.open(\"../tests/data/remote/wofe/wofe_dep_nan_.tif\") as test_dep:\n", - "with rasterio.open(\"../tests/data/local/Int_wofe_ev_nan.tif\") as test_ev:\n", - " # with rasterio.open(\"../tests/data/local/wofe_dep_new.tif\") as test_dep:\n", - " gdf = gpd.read_file(\"../tests/data/local/Dep1s.shp\")\n", - " test_wgt_un_, test_gen_un_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='unique')\n", - " test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='ascending', studentized_contrast_threshold=1)\n", - " test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='descending', studentized_contrast_threshold=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ClassPixel countDeposit countW+S_W+W-S_W-ContrastS_ContrastStudentized contrast
01.027590.48100.3389-0.39940.38060.88040.50961.7275
12.01100.00000.00000.00000.00000.00000.00000.0000
23.03965-0.49200.45010.34090.3059-0.83290.5442-1.5306
35.04310.12961.0118-0.00810.26090.13771.04490.1318
46.0100.00000.00000.00000.00000.00000.00000.0000
58.04300.00000.00000.00000.00000.00000.00000.0000
610.0213.86731.4142-0.06320.26073.93051.43802.7332
713.01000.00000.00000.00000.00000.00000.00000.0000
\n", - "
" - ], - "text/plain": [ - " Class Pixel count Deposit count W+ S_W+ W- S_W- \\\n", - "0 1.0 275 9 0.4810 0.3389 -0.3994 0.3806 \n", - "1 2.0 11 0 0.0000 0.0000 0.0000 0.0000 \n", - "2 3.0 396 5 -0.4920 0.4501 0.3409 0.3059 \n", - "3 5.0 43 1 0.1296 1.0118 -0.0081 0.2609 \n", - "4 6.0 1 0 0.0000 0.0000 0.0000 0.0000 \n", - "5 8.0 43 0 0.0000 0.0000 0.0000 0.0000 \n", - "6 10.0 2 1 3.8673 1.4142 -0.0632 0.2607 \n", - "7 13.0 10 0 0.0000 0.0000 0.0000 0.0000 \n", - "\n", - " Contrast S_Contrast Studentized contrast \n", - "0 0.8804 0.5096 1.7275 \n", - "1 0.0000 0.0000 0.0000 \n", - "2 -0.8329 0.5442 -1.5306 \n", - "3 0.1377 1.0449 0.1318 \n", - "4 0.0000 0.0000 0.0000 \n", - "5 0.0000 0.0000 0.0000 \n", - "6 3.9305 1.4380 2.7332 \n", - "7 0.0000 0.0000 0.0000 " - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# UNIQUE\n", - "test_wgt_un_" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ClassPixel countDeposit countW+S_W+W-S_W-ContrastS_ContrastStudentized contrastGeneralized classGeneralized W+Generalized S_W+
01.027590.48100.3389-0.39940.38060.88040.50961.727520.48100.3389
12.028690.44050.3387-0.37710.38070.81760.50951.60461-0.39940.3806
23.0682140.00210.2700-0.01430.71440.01630.76370.02141-0.39940.3806
35.0725150.01010.2609-0.14001.00900.15011.04220.14401-0.39940.3806
46.0726150.00870.2609-0.12171.00920.13041.04240.12511-0.39940.3806
58.076915-0.05010.26081.46941.0445-1.51941.0765-1.41141-0.39940.3806
610.077116-0.05070.26071.55471.0536-1.60541.0854-1.47911-0.39940.3806
713.078116-0.06260.26063.86731.4213-3.92991.4450-2.71961-0.39940.3806
\n", - "
" - ], - "text/plain": [ - " Class Pixel count Deposit count W+ S_W+ W- S_W- \\\n", - "0 1.0 275 9 0.4810 0.3389 -0.3994 0.3806 \n", - "1 2.0 286 9 0.4405 0.3387 -0.3771 0.3807 \n", - "2 3.0 682 14 0.0021 0.2700 -0.0143 0.7144 \n", - "3 5.0 725 15 0.0101 0.2609 -0.1400 1.0090 \n", - "4 6.0 726 15 0.0087 0.2609 -0.1217 1.0092 \n", - "5 8.0 769 15 -0.0501 0.2608 1.4694 1.0445 \n", - "6 10.0 771 16 -0.0507 0.2607 1.5547 1.0536 \n", - "7 13.0 781 16 -0.0626 0.2606 3.8673 1.4213 \n", - "\n", - " Contrast S_Contrast Studentized contrast Generalized class \\\n", - "0 0.8804 0.5096 1.7275 2 \n", - "1 0.8176 0.5095 1.6046 1 \n", - "2 0.0163 0.7637 0.0214 1 \n", - "3 0.1501 1.0422 0.1440 1 \n", - "4 0.1304 1.0424 0.1251 1 \n", - "5 -1.5194 1.0765 -1.4114 1 \n", - "6 -1.6054 1.0854 -1.4791 1 \n", - "7 -3.9299 1.4450 -2.7196 1 \n", - "\n", - " Generalized W+ Generalized S_W+ \n", - "0 0.4810 0.3389 \n", - "1 -0.3994 0.3806 \n", - "2 -0.3994 0.3806 \n", - "3 -0.3994 0.3806 \n", - "4 -0.3994 0.3806 \n", - "5 -0.3994 0.3806 \n", - "6 -0.3994 0.3806 \n", - "7 -0.3994 0.3806 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# ASCENDING\n", - "test_wgt_asc_" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ClassPixel countDeposit countW+S_W+W-S_W-ContrastS_ContrastStudentized contrastGeneralized classGeneralized W+Generalized S_W+
013.01000.00000.00000.00000.00000.00000.00000.000021.46941.0445
110.01211.46941.0445-0.05010.26081.51941.07651.411421.46941.0445
28.0551-0.12171.00920.00870.2609-0.13041.0424-0.12511-0.05010.2608
36.0561-0.14001.00900.01010.2609-0.15011.0422-0.14401-0.05010.2608
45.0992-0.01430.71440.00210.2700-0.01630.7637-0.02141-0.05010.2608
53.04957-0.37710.38070.44050.3387-0.81760.5095-1.60461-0.05010.2608
62.05067-0.39940.38060.48100.3389-0.88040.5096-1.72751-0.05010.2608
71.078116-0.06260.26063.86731.4213-3.92991.4450-2.71961-0.05010.2608
\n", - "
" - ], - "text/plain": [ - " Class Pixel count Deposit count W+ S_W+ W- S_W- \\\n", - "0 13.0 10 0 0.0000 0.0000 0.0000 0.0000 \n", - "1 10.0 12 1 1.4694 1.0445 -0.0501 0.2608 \n", - "2 8.0 55 1 -0.1217 1.0092 0.0087 0.2609 \n", - "3 6.0 56 1 -0.1400 1.0090 0.0101 0.2609 \n", - "4 5.0 99 2 -0.0143 0.7144 0.0021 0.2700 \n", - "5 3.0 495 7 -0.3771 0.3807 0.4405 0.3387 \n", - "6 2.0 506 7 -0.3994 0.3806 0.4810 0.3389 \n", - "7 1.0 781 16 -0.0626 0.2606 3.8673 1.4213 \n", - "\n", - " Contrast S_Contrast Studentized contrast Generalized class \\\n", - "0 0.0000 0.0000 0.0000 2 \n", - "1 1.5194 1.0765 1.4114 2 \n", - "2 -0.1304 1.0424 -0.1251 1 \n", - "3 -0.1501 1.0422 -0.1440 1 \n", - "4 -0.0163 0.7637 -0.0214 1 \n", - "5 -0.8176 0.5095 -1.6046 1 \n", - "6 -0.8804 0.5096 -1.7275 1 \n", - "7 -3.9299 1.4450 -2.7196 1 \n", - "\n", - " Generalized W+ Generalized S_W+ \n", - "0 1.4694 1.0445 \n", - "1 1.4694 1.0445 \n", - "2 -0.0501 0.2608 \n", - "3 -0.0501 0.2608 \n", - "4 -0.0501 0.2608 \n", - "5 -0.0501 0.2608 \n", - "6 -0.0501 0.2608 \n", - "7 -0.0501 0.2608 " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# DESCENDING\n", - "test_wgt_dsc_" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Unique weights - W+\")\n", - "clrbar = ax.imshow(test_gen_un_[\"W+\"], cmap='terrain')\n", - "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_un_[\"W+\"], ax = ax, transform = test_ev.transform, cmap='terrain')" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Ascending weights - Generalized weights (W+)\")\n", - "clrbar = ax.imshow(test_gen_asc_[\"Generalized W+\"], cmap='viridis')\n", - "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_asc_[\"Generalized W+\"], ax = ax, transform = test_ev.transform, cmap='viridis')" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Descending weights - Generalized weighst (W+)\")\n", - "clrbar = ax.imshow(test_gen_dsc_[\"Generalized W+\"], cmap='viridis')\n", - "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_dsc_[\"Generalized W+\"], ax = ax, transform = test_ev.transform, cmap='viridis')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "eis_toolkit", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/tests/wofe_calculate_responses_test.py b/tests/wofe_calculate_responses_test.py deleted file mode 100644 index 9d3f3cd9..00000000 --- a/tests/wofe_calculate_responses_test.py +++ /dev/null @@ -1,46 +0,0 @@ -import pytest -import numpy as np -from pathlib import Path -import rasterio -import pandas as pd -from pandas.testing import assert_frame_equal - -from eis_toolkit.prediction.weights_of_evidence.calculate_responses import calculate_responses - -parent_dir = Path(__file__).parent -print(parent_dir) - -# Paths of files to be used as inputs to the calculate responses function -wgts_rst_un_path = parent_dir.joinpath("data/remote/wofe/Merged_Unique.tif") -wgts_rst_asc_path = parent_dir.joinpath("data/remote/wofe/Merged_Ascending_.tif") -wgts_rst_dsc_path = parent_dir.joinpath("data/remote/wofe/Merged_Descending_.tif") -dep_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_dep_nan_.tif") - -# Path to the file to compare the results of the calculates responses function -merged_pprb_path = parent_dir.joinpath("data/remote/wofe/Merged_pprbs.tif") - -# Actual testing function -def test_calculate_responses(): - """Tests if calculate_responses function works as intended""" - # expected arrays - pprb_rstrs = rasterio.open(merged_pprb_path) - pprb, std, conf = np.array(pprb_rstrs.read(1)), np.array(pprb_rstrs.read(2)), np.array(pprb_rstrs.read(3)) - exp_pprbs = [pprb, std, conf] - - #input to calculate_responses function - test_dep = rasterio.open(dep_rst_path) - wgts_rstr_paths = [wgts_rst_un_path, wgts_rst_asc_path, wgts_rst_dsc_path] - arrys_list_from_wgts = [] - for path_rst in wgts_rstr_paths: - wgts_rst_o = rasterio.open(path_rst) - pprb_, std_, conf_ = np.array(wgts_rst_o.read(1)), np.array(wgts_rst_o.read(2)), np.array(wgts_rst_o.read(3)) - list_one_block = [pprb_, std_, conf_] - arrys_list_from_wgts.append(list_one_block) - - # Call the calculate_responses function - t_pprb_array, t_pprb_std, t_pprb_conf, array_meta = calculate_responses(test_dep, arrys_list_from_wgts) - result_pprbs = [t_pprb_array, t_pprb_std, t_pprb_conf] - - #compare the results - for res, exp in zip(result_pprbs, exp_pprbs): - assert res.all() == exp.all() \ No newline at end of file diff --git a/tests/wofe_weights_calculations_test.py b/tests/wofe_weights_calculations_test.py deleted file mode 100644 index ec77351a..00000000 --- a/tests/wofe_weights_calculations_test.py +++ /dev/null @@ -1,47 +0,0 @@ -import pytest -import numpy as np -from pathlib import Path -import rasterio -import pandas as pd -from pandas.testing import assert_frame_equal - -from eis_toolkit.prediction.weights_of_evidence.weights_calculations import weights_calculations - -parent_dir = Path(__file__).parent -print(parent_dir) - -# Paths of files to be used as inputs to the weights_calculations function -ev_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_ev_nan.tif") -dep_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_dep_nan_.tif") - -# Paths to the files to compare the results of the weigths_calculations function to -wgts_rst_un_path = parent_dir.joinpath("data/remote/wofe/Merged_Unique.tif") -wgts_rst_asc_path = parent_dir.joinpath("data/remote/wofe/Merged_Ascending_.tif") -wgts_rst_dsc_path = parent_dir.joinpath("data/remote/wofe/Merged_Descending_.tif") - -wgts_un_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_un.csv") -wgts_asc_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_asc.csv") -wgts_dsc_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_dsc.csv") - - -@pytest.mark.parametrize("wgts_type, wgts_df_path, expected", [(0, wgts_un_path, wgts_rst_un_path), (1, wgts_asc_path, wgts_rst_asc_path), (2, wgts_dsc_path, wgts_rst_dsc_path)]) - -def test_weights_calculations( wgts_type, wgts_df_path, expected): - """Tests if weights_calculations function runs as intended; tests for all three weights type""" - #expected results - # weights dataframe - wgts_ = pd.read_csv(wgts_df_path).set_index('Clss') - exp_wgts_df = pd.DataFrame(wgts_) - # weights arrays - wgts_rstr_ = rasterio.open(expected) - clss, wgts, std = np.array(wgts_rstr_.read(1)), np.array(wgts_rstr_.read(2)), np.array(wgts_rstr_.read(3)) - exp_list_arr = [clss, wgts, std] - #inputs to function - ev_rst_ = rasterio.open(ev_rst_path) - dep_rst_ = rasterio.open(dep_rst_path) - #Calling the function - wgts_df, wgts_arr, rst_meta = weights_calculations(ev_rst=ev_rst_, dep_rst= dep_rst_, w_type=wgts_type, stud_cont=2) - assert_frame_equal(wgts_df, exp_wgts_df, check_dtype=False, check_index_type=False) - for res, exp in zip(wgts_arr, exp_list_arr): - assert res.all() == exp.all() - \ No newline at end of file From 390564ff76a0c8d30212b21fc32fea6f41a5147c Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Thu, 28 Sep 2023 11:01:45 +0300 Subject: [PATCH 20/31] Remove old tests, revert unnecessary modifications, add a new exception --- .vscode/settings.json | 7 --- eis_toolkit/exceptions.py | 16 +++---- eis_toolkit/prediction/weights_of_evidence.py | 9 +++- .../wofe/wofe_calculate_responses_test.py | 46 ------------------- .../wofe/wofe_calculate_weights_test.py | 46 ------------------- 5 files changed, 15 insertions(+), 109 deletions(-) delete mode 100644 tests/prediction/wofe/wofe_calculate_responses_test.py delete mode 100644 tests/prediction/wofe/wofe_calculate_weights_test.py diff --git a/.vscode/settings.json b/.vscode/settings.json index 9b388533..e69de29b 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,7 +0,0 @@ -{ - "python.testing.pytestArgs": [ - "tests" - ], - "python.testing.unittestEnabled": false, - "python.testing.pytestEnabled": true -} \ No newline at end of file diff --git a/eis_toolkit/exceptions.py b/eis_toolkit/exceptions.py index 6d1bcd01..6dec2159 100644 --- a/eis_toolkit/exceptions.py +++ b/eis_toolkit/exceptions.py @@ -2,6 +2,10 @@ class CoordinatesOutOfBoundsException(Exception): """Exception error class for out of bound coordinates.""" +class ClassificationFailedException(Exception): + """Exception error class for classification failures.""" + + class EmptyDataFrameException(Exception): """Exception error class raised if the dataframe is empty.""" @@ -46,16 +50,12 @@ class InvalidWktFormatException(Exception): """Exception error for invalid WKT format.""" -class InvalidColumnIndexException(Exception): - """Exception error for index out of range.""" - - -class UnFavorableClassDoesntExistException(Exception): - """Exception error class for failure to generalize classes using the given studentised contrast threshold value. Class 1 (unfavorable class) doesn't exist""" +class MatchingCrsException(Exception): + """Exception error class for CRS matches.""" -class FavorableClassDoesntExistException(Exception): - """Exception error class for failure to generalize classes using the given studentised contrast threshold value. Class 2 (favorable class) doesn't exist""" +class MatchingRasterGridException(Exception): + """Exception error class for raster grid matches.""" class NotApplicableGeometryTypeException(Exception): diff --git a/eis_toolkit/prediction/weights_of_evidence.py b/eis_toolkit/prediction/weights_of_evidence.py index 66a0143a..f965a2b6 100644 --- a/eis_toolkit/prediction/weights_of_evidence.py +++ b/eis_toolkit/prediction/weights_of_evidence.py @@ -7,6 +7,7 @@ from beartype import beartype from beartype.typing import List, Literal, Optional, Sequence, Tuple, Union +from eis_toolkit import exceptions from eis_toolkit.vector_processing.rasterize_vector import rasterize_vector @@ -89,8 +90,12 @@ def _reclassify_by_studentized_contrast(df: pd.DataFrame, studentized_contrast_t """Create generalized classes based on the studentized contrast threhsold value.""" index = df.idxmax()["Contrast"] - if df.loc[index, "Studentized contrast"] < studentized_contrast_threshold: - raise Exception("Failed, studentized contrast is {}".format(df.loc[index, "Studentized contrast"])) + if df.loc[index, "Studentized contrast"] < studentized_contrast_threshold or index == len(df.index) - 1: + raise exceptions.ClassificationFailedException( + "Failed to create generalized classes with given studentized contrast treshold ({})".format( + df.loc[index, "Studentized contrast"] + ) + ) df["Generalized class"] = 1 for i in range(0, index + 1): diff --git a/tests/prediction/wofe/wofe_calculate_responses_test.py b/tests/prediction/wofe/wofe_calculate_responses_test.py deleted file mode 100644 index 50f1d594..00000000 --- a/tests/prediction/wofe/wofe_calculate_responses_test.py +++ /dev/null @@ -1,46 +0,0 @@ -import pytest -import numpy as np -from pathlib import Path -import rasterio -import pandas as pd -from pandas.testing import assert_frame_equal - -from eis_toolkit.prediction.weights_of_evidence.calculate_responses import calculate_responses - -parent_dir = Path(__file__).parent.parent.parent -print(parent_dir) - -# Paths of files to be used as inputs to the calculate responses function -wgts_rst_un_path = parent_dir.joinpath("data/remote/wofe/Merged_Unique.tif") -wgts_rst_asc_path = parent_dir.joinpath("data/remote/wofe/Merged_Ascending_.tif") -wgts_rst_dsc_path = parent_dir.joinpath("data/remote/wofe/Merged_Descending_.tif") -dep_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_dep_nan_.tif") - -# Path to the file to compare the results of the calculates responses function -merged_pprb_path = parent_dir.joinpath("data/remote/wofe/Merged_pprbs.tif") - -# Actual testing function -def test_calculate_responses(): - """Tests if calculate_responses function works as intended""" - # expected arrays - pprb_rstrs = rasterio.open(merged_pprb_path) - pprb, std, conf = np.array(pprb_rstrs.read(1)), np.array(pprb_rstrs.read(2)), np.array(pprb_rstrs.read(3)) - exp_pprbs = [pprb, std, conf] - - #input to calculate_responses function - test_dep = rasterio.open(dep_rst_path) - wgts_rstr_paths = [wgts_rst_un_path, wgts_rst_asc_path, wgts_rst_dsc_path] - arrys_list_from_wgts = [] - for path_rst in wgts_rstr_paths: - wgts_rst_o = rasterio.open(path_rst) - pprb_, std_, conf_ = np.array(wgts_rst_o.read(1)), np.array(wgts_rst_o.read(2)), np.array(wgts_rst_o.read(3)) - list_one_block = [pprb_, std_, conf_] - arrys_list_from_wgts.append(list_one_block) - - # Call the calculate_responses function - t_pprb_array, t_pprb_std, t_pprb_conf, array_meta = calculate_responses(test_dep, arrys_list_from_wgts) - result_pprbs = [t_pprb_array, t_pprb_std, t_pprb_conf] - - #compare the results - for res, exp in zip(result_pprbs, exp_pprbs): - assert res.all() == exp.all() diff --git a/tests/prediction/wofe/wofe_calculate_weights_test.py b/tests/prediction/wofe/wofe_calculate_weights_test.py deleted file mode 100644 index d0066628..00000000 --- a/tests/prediction/wofe/wofe_calculate_weights_test.py +++ /dev/null @@ -1,46 +0,0 @@ -import pytest -import numpy as np -from pathlib import Path -import rasterio -import pandas as pd -from pandas.testing import assert_frame_equal - -from eis_toolkit.prediction.weights_of_evidence.calculate_weights import calculate_weights - -parent_dir = Path(__file__).parent.parent.parent -print(parent_dir) - -# Paths of files to be used as inputs to the weights_calculations function -ev_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_ev_nan.tif") -dep_rst_path = parent_dir.joinpath("data/remote/wofe/wofe_dep_nan_.tif") - -# Paths to the files to compare the results of the weigths_calculations function to -wgts_rst_un_path = parent_dir.joinpath("data/remote/wofe/Merged_Unique.tif") -wgts_rst_asc_path = parent_dir.joinpath("data/remote/wofe/Merged_Ascending_.tif") -wgts_rst_dsc_path = parent_dir.joinpath("data/remote/wofe/Merged_Descending_.tif") - -wgts_un_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_un.csv") -wgts_asc_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_asc.csv") -wgts_dsc_path = parent_dir.joinpath("data/remote/wofe/exp_wgts_dsc.csv") - -@pytest.mark.parametrize("wgts_type, wgts_df_path, expected", [(0, wgts_un_path, wgts_rst_un_path), (1, wgts_asc_path, wgts_rst_asc_path), (2, wgts_dsc_path, wgts_rst_dsc_path)]) - -def test_calculate_weights( wgts_type, wgts_df_path, expected): - """Tests if calculate_weights function runs as intended; tests for all three weights type""" - #expected results - # weights dataframe - wgts_ = pd.read_csv(wgts_df_path).set_index('Clss') - exp_wgts_df = pd.DataFrame(wgts_) - # weights arrays - wgts_rstr_ = rasterio.open(expected) - clss, wgts, std = np.array(wgts_rstr_.read(1)), np.array(wgts_rstr_.read(2)), np.array(wgts_rstr_.read(3)) - exp_list_arr = [clss, wgts, std] - #inputs to function - ev_rst_ = rasterio.open(ev_rst_path) - dep_rst_ = rasterio.open(dep_rst_path) - #Calling the function - wgts_df, wgts_arr, rst_meta = calculate_weights(ev_rst=ev_rst_, dep_rst= dep_rst_, nan_val = -1000000000.0, w_type=wgts_type, stud_cont=2) - assert_frame_equal(wgts_df, exp_wgts_df, check_dtype=False, check_index_type=False) - for res, exp in zip(wgts_arr, exp_list_arr): - assert res.all() == exp.all() - \ No newline at end of file From 5732a30325aa3a14e62c1f3a14f0be6a6cee5af0 Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Thu, 28 Sep 2023 11:03:18 +0300 Subject: [PATCH 21/31] Remove vscode settings file --- .vscode/settings.json | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index e69de29b..00000000 From 3a9a98355589df93e9809bd9439fdc2a49ce2797 Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Thu, 28 Sep 2023 11:51:48 +0300 Subject: [PATCH 22/31] Improve notebook, remove old functions, added a check --- eis_toolkit/prediction/weights_of_evidence.py | 70 +++----- notebooks/weights_of_evidence.ipynb | 153 ++++++++++++------ 2 files changed, 127 insertions(+), 96 deletions(-) diff --git a/eis_toolkit/prediction/weights_of_evidence.py b/eis_toolkit/prediction/weights_of_evidence.py index f965a2b6..0a3c3806 100644 --- a/eis_toolkit/prediction/weights_of_evidence.py +++ b/eis_toolkit/prediction/weights_of_evidence.py @@ -5,7 +5,7 @@ import pandas as pd import rasterio from beartype import beartype -from beartype.typing import List, Literal, Optional, Sequence, Tuple, Union +from beartype.typing import List, Literal, Optional, Sequence, Tuple from eis_toolkit import exceptions from eis_toolkit.vector_processing.rasterize_vector import rasterize_vector @@ -102,18 +102,6 @@ def _reclassify_by_studentized_contrast(df: pd.DataFrame, studentized_contrast_t df.loc[i, "Generalized class"] = 2 -def _reclassify_by_studentized_contrast_alternative(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: - """Create generalized classes based on the studentized contrast threhsold value.""" - df["Generalized class"] = np.where(df["Studentized contrast"] >= studentized_contrast_threshold, 2, 1) - - # Check if both classes are present - unique_classes = df["Generalized class"].unique() - if 1 not in unique_classes: - raise ValueError("Reclassification failed: 'Unfavorable' class (Class 1) doesn't exist.") - elif 2 not in unique_classes: - raise ValueError("Reclassification failed: 'Favorable' class (Class 2) doesn't exist.") - - def _calculate_generalized_weights(df: pd.DataFrame, deposits) -> None: """ Calculate generalized weights. @@ -148,27 +136,6 @@ def _calculate_generalized_weights(df: pd.DataFrame, deposits) -> None: df.loc[df["Generalized class"] == 1, "Generalized S_W+"] = round(clas_1_s_wpls_gen, 4) -def _calculate_generalized_weights_alternative(weights_df: pd.DataFrame) -> None: - """ - Calculate generalized weights. - - Implementation for generalized weights that uses a DIFFERENT logic than the original implementation. - """ - generalized_weights = [] - generalized_s_weights = [] - - for gen_cls in weights_df["Generalized class"].tolist(): - subset_df = weights_df[weights_df["Generalized class"] == gen_cls] - - weighted_w_plus_sum = sum(subset_df["WPlus"] * subset_df["Pixel count"]) - total_count = subset_df["Deposit count"].sum() - - generalized_weights.append(round(weighted_w_plus_sum / total_count, 4) if total_count else 0) - - weights_df["Generalized W+"] = generalized_weights - weights_df["Generalized S_W+"] = generalized_s_weights - - def _generate_rasters_from_metrics( evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str] = ["Class", "W+", "S_W+"] ) -> dict: @@ -190,7 +157,7 @@ def weights_of_evidence( raster_nodata: Optional[Number] = None, weights_type: Literal["unique", "ascending", "descending"] = "unique", studentized_contrast_threshold: Number = 2, - rasters_to_generate: Union[Sequence[str], str, None] = None, + rasters_to_generate: Sequence[str] = ["Class", "W+", "S_W+"], ) -> Tuple[pd.DataFrame, dict, dict]: """ Calculate weights of spatial associations. @@ -206,8 +173,8 @@ def weights_of_evidence( Reclassification is used when creating generalized rasters with cumulative weight type selection. Not needed if weights_type is 'unique'. Defaults to 2. rasters_to_generate: Rasters to generate from the computed weight metrics. All column names - in the produced weights_df are valid choices. If None, defaults to ["Class", "W+", "S_W+] - for "unique" weights_type or ["Class", "W+", "S_W+", "Generalized W+", "Generalized S_W+"] + in the produced weights_df are valid choices. Defaults to ["Class", "W+", "S_W+] + for "unique" weights_type and ["Class", "W+", "S_W+", "Generalized W+", "Generalized S_W+"] for the cumulative weight types. Returns: @@ -215,13 +182,27 @@ def weights_of_evidence( Dictionary of output raster arrays. Raster metadata. """ + out_df_col_names = [ + "Class", + "Pixel count", + "Deposit count", + "W+", + "S_W+", + "W-", + "S_W-", + "Contrast", + "S_Contrast", + "Studentized contrast", + ] + if rasters_to_generate is not None and not all(col_name in rasters_to_generate for col_name in out_df_col_names): + raise exceptions.InvalidColumnException("Rasters to generate list contains metrics / column names.") - # 1. Data preprocessing + metrics_to_rasters = rasters_to_generate + if weights_type != "unique" and rasters_to_generate == ["Class", "W+", "S_W+"]: + metrics_to_rasters += ["Generalized W+", "Generalized S_W+"] - # Read evidence raster + # 1. Data preprocessing evidence_array = _read_and_preprocess_evidence(evidential_raster, raster_nodata) - - # Extract raster metadata raster_meta = evidential_raster.meta # Rasterize deposits @@ -266,15 +247,8 @@ def weights_of_evidence( # 4. If we use cumulative weights type, reclassify and calculate generalized weights if weights_type != "unique": _reclassify_by_studentized_contrast(weights_df, studentized_contrast_threshold) - # calculate_generalized_weights(weights_df) _calculate_generalized_weights(weights_df, masked_deposit_array) - metrics_to_rasters = rasters_to_generate - if metrics_to_rasters is None: - metrics_to_rasters = ["Class", "W+", "S_W+"] - if weights_type != "unique": - metrics_to_rasters += ["Generalized W+", "Generalized S_W+"] - # 5. After the wofe_weights computation in the weights_of_evidence function raster_dict = _generate_rasters_from_metrics(evidence_array, weights_df, metrics_to_rasters) diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb index 37297743..0ea3c1db 100644 --- a/notebooks/weights_of_evidence.ipynb +++ b/notebooks/weights_of_evidence.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -14,28 +14,26 @@ "import sys\n", "sys.path.insert(0, \"..\")\n", "\n", - "from eis_toolkit.prediction.wofe_new import weights_of_evidence" + "from eis_toolkit.prediction.weights_of_evidence import weights_of_evidence" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ - "# with rasterio.open(\"../tests/data/remote/wofe/wofe_ev_nan.tif\") as test_ev:\n", - "# with rasterio.open(\"../tests/data/remote/wofe/wofe_dep_nan_.tif\") as test_dep:\n", "with rasterio.open(\"../tests/data/local/Int_wofe_ev_nan.tif\") as test_ev:\n", - " # with rasterio.open(\"../tests/data/local/wofe_dep_new.tif\") as test_dep:\n", " gdf = gpd.read_file(\"../tests/data/local/Dep1s.shp\")\n", - " test_wgt_un_, test_gen_un_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='unique')\n", - " test_wgt_asc_, test_gen_asc_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='ascending', studentized_contrast_threshold=1)\n", - " test_wgt_dsc_, test_gen_dsc_, test_rst_meta = weights_of_evidence(test_ev, gdf, weights_type='descending', studentized_contrast_threshold=1)" + "\n", + " weights_unique, rasters_unique, _ = weights_of_evidence(test_ev, gdf, weights_type='unique')\n", + " weights_ascending, rasters_ascending, _ = weights_of_evidence(test_ev, gdf, weights_type='ascending', studentized_contrast_threshold=1)\n", + " weights_descending, rasters_descending, _ = weights_of_evidence(test_ev, gdf, weights_type='descending', studentized_contrast_threshold=1)" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -202,19 +200,19 @@ "7 0.0000 0.0000 0.0000 " ] }, - "execution_count": 3, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# UNIQUE\n", - "test_wgt_un_" + "# Unique weights DF\n", + "weights_unique" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -418,19 +416,19 @@ "7 -0.3994 0.3806 " ] }, - "execution_count": 4, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# ASCENDING\n", - "test_wgt_asc_" + "# Ascending weights DF\n", + "weights_ascending" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -634,36 +632,36 @@ "7 -0.0501 0.2608 " ] }, - "execution_count": 5, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# DESCENDING\n", - "test_wgt_dsc_" + "# Descending weights DF\n", + "weights_descending" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 6, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -671,33 +669,46 @@ } ], "source": [ - "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Unique weights - W+\")\n", - "clrbar = ax.imshow(test_gen_un_[\"W+\"], cmap='terrain')\n", + "# Plot unique weights\n", + "\n", + "fig, axs = plt.subplots(2, 2, figsize = (14, 14))\n", + "\n", + "axs[0, 0].set_title(\"Unique weights - Class\")\n", + "clrbar = axs[0, 0].imshow(rasters_unique[\"Class\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(rasters_unique[\"Class\"], ax = axs[0, 0], transform = test_ev.transform, cmap='viridis')\n", + "\n", + "axs[1, 0].set_title(\"Unique weights - W+\")\n", + "clrbar = axs[1, 0].imshow(rasters_unique[\"W+\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(rasters_unique[\"W+\"], ax = axs[1, 0], transform = test_ev.transform, cmap='viridis')\n", + "\n", + "axs[1, 1].set_title(\"Unique weights - S_W+\")\n", + "clrbar = axs[1, 1].imshow(rasters_unique[\"S_W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_un_[\"W+\"], ax = ax, transform = test_ev.transform, cmap='terrain')" + "show(rasters_unique[\"S_W+\"], ax = axs[1, 1], transform = test_ev.transform, cmap='viridis')" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 7, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAAK7CAYAAADBfQ+iAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABec0lEQVR4nO3deXxU1f3/8feEbGxZgIQQCIuACAqCUUMQBCUQkCIoilKUVcCfuGFbLXUB0RoUqtQVtRK00FKxgNQKGBYXIKWIRNmkoJAoIaBCEtZAMuf3h9+MGZITMskkk5DX8/GYxyNz77nnfu45d0Le3Jk7DmOMEQAAAACgGD9fFwAAAAAA1RWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJwAVj+vTpcjgcbstat26tMWPG+KagSrR//345HA7Nnz+/3NvOnj3b+4WhwhwOh6ZPn+56Pn/+fDkcDu3fv79K66gOr52afp5/9913Cg4O1oYNG3xWQ6GVK1eqQYMG+uGHH3xdClDjEJiAWurVV1+Vw+FQXFycr0tBNfbhhx+6/fHuC06nU++884769eunJk2aKCAgQJGRkerfv7/eeOMN5eXl+bQ+1HyVdZ7PmDFDcXFxuuaaayRJ99xzj/z8/HTkyBG3dkeOHJGfn5+CgoJ0+vRpt3XffvutHA6H/vCHP1SolgEDBqhdu3ZKSkqqUD9AbURgAmqphQsXqnXr1vrvf/+rvXv3+rqcSrN79269+eabvi7D61q1aqVTp07pzjvvrNT9fPjhh3ryyScrdR+lOXXqlG644QaNHj1aJ0+e1G9/+1u98cYbeuSRRxQcHKx77rlH99xzj8/qqwp33nmnTp06pVatWvm6lCpXk8/zH374QW+//bbuvvtu17KePXvKGFPsitPGjRvl5+ens2fP6vPPP3dbV9i2Z8+eFa5p0qRJev3113Xs2LEK9wXUJgQmoBbat2+fNm7cqOeff14RERFauHChr0uqNEFBQQoICPB1GV7ncDgUHBysOnXq+LqUSjVlyhStWrVKc+bM0YYNG/T73/9eY8eO1W9+8xstX75cu3btUmxsrK/LtMrPz9eZM2cq1EedOnUUHBxc7O2mtUFNPs8XLFggf39/DR482LWsMPSsX7/ere2GDRvUpUsXdejQodi69evXy8/PTz169LDua/r06WrduvV5axo2bJjy8vK0ePFiD44EAIEJqIUWLlyo8PBwDRo0SLfccos1MC1atEixsbFq2LChQkJC1LlzZ/35z392a5Odna0pU6aodevWCgoKUosWLTRq1Cj9+OOPrjZ5eXmaNm2a2rVrp6CgIMXExOjhhx8u9lYqh8Ohe++9V8uWLdNll12moKAgXXrppVq5cmWx2tavX6+rrrpKwcHBatu2rV5//fUSj+Hcz2EUfh5kw4YNeuihhxQREaH69evrpptuKvbefqfTqenTpys6Olr16tXTddddp507d5bpsx1XXHGFbr75ZrdlnTt3lsPh0FdffeVa9o9//EMOh0O7du1yLTtw4IDGjRunpk2busZg3rx5bn3ZPtuxePFiderUScHBwbrsssu0dOlSjRkzxvrH1BtvvKG2bdsqKChIV111lTZv3uxaN2bMGL3yyiuSfp6bwkehspwfFfHdd9/pL3/5iwYMGKAHHnigxDbt27cvdoXJ6XRqzpw5uvTSSxUcHKymTZtq0qRJOnr0qFu71q1b61e/+pXWr1+vq6++WsHBwbrooov0zjvvFNtPdna2HnzwQcXExCgoKEjt2rXTs88+K6fT6WpT9DMzc+bMcY3rzp07debMGT3xxBOKjY1VaGio6tevr169emndunXnHYdzP8NU+Fm9kh5Fz8uyjoMxRk8//bRatGjhOs937Nhx3rokzvPSLFu2THFxcWrQoIFrWcuWLRUTE1PsCtOGDRt0zTXXqEePHiWuu/TSSxUWFnbefZ5PZGSkunTpovfff7/CfQG1ib+vCwBQ9RYuXKibb75ZgYGBGjFihF577TVt3rxZV111latNSkqKRowYob59++rZZ5+VJO3atUsbNmxw/fF6/Phx9erVS7t27dK4ceN0xRVX6Mcff9Ty5cv1/fffq0mTJnI6nbrxxhu1fv16TZw4UR07dtS2bdv0wgsv6H//+5+WLVvmVtv69eu1ZMkS3XPPPWrYsKFefPFFDRs2TBkZGWrcuLEkadu2berfv78iIiI0ffp05efna9q0aWratGmZx+C+++5TeHi4pk2bpv3792vOnDm699579Y9//MPVZurUqXruuec0ePBgJSYm6ssvv1RiYmKxzxiUpFevXvr73//uen7kyBHt2LFDfn5++uyzz9SlSxdJ0meffaaIiAh17NhRknTo0CF1797dFR4jIiK0YsUKjR8/Xrm5uXrwwQet+/z3v/+t2267TZ07d1ZSUpKOHj2q8ePHq3nz5iW2/9vf/qZjx45p0qRJcjgceu6553TzzTfr22+/VUBAgCZNmqTMzEylpKTor3/9q9u2ZTk/KmrFihUqKCjQHXfc4dF2kyZN0vz58zV27Fjdf//92rdvn15++WVt3bpVGzZscLviuHfvXt1yyy0aP368Ro8erXnz5mnMmDGKjY3VpZdeKkk6efKkevfurQMHDmjSpElq2bKlNm7cqKlTp+rgwYOaM2eO2/6Tk5N1+vRpTZw4UUFBQWrUqJFyc3P1l7/8RSNGjNCECRN07NgxvfXWW0pMTNR///tfde3atczHd/PNN6tdu3Zuy7Zs2aI5c+YoMjLS43F44okn9PTTT+uGG27QDTfcoC+++EL9+/cv05UxzvOSnT17Vps3b9b/+3//r9i6nj17asmSJcrLy1NQUJDOnDnjanvy5Ek9/PDDMsbI4XDo6NGj2rlzp9vb+ioqNja22O9dAOdhANQqn3/+uZFkUlJSjDHGOJ1O06JFC/PAAw+4tXvggQdMSEiIyc/Pt/b1xBNPGElmyZIlxdY5nU5jjDF//etfjZ+fn/nss8/c1s+dO9dIMhs2bHAtk2QCAwPN3r17Xcu+/PJLI8m89NJLrmVDhw41wcHBJj093bVs586dpk6dOubcX2utWrUyo0ePdj1PTk42kkxCQoKrRmOMmTJliqlTp47Jzs42xhiTlZVl/P39zdChQ936mz59upHk1mdJFi9ebCSZnTt3GmOMWb58uQkKCjI33nijue2221ztunTpYm666SbX8/Hjx5tmzZqZH3/80a2/22+/3YSGhpqTJ08aY4zZt2+fkWSSk5NdbTp37mxatGhhjh075lr28ccfG0mmVatWrmWF2zZu3NgcOXLEtfz99983ksy//vUv17LJkycXG1NjynZ+VNSUKVOMJJOWlua2PC8vz/zwww+uR9Gx+uyzz4wks3DhQrdtVq5cWWx5q1atjCTz6aefupYdPnzYBAUFmd/85jeuZU899ZSpX7+++d///ufW5+9//3tTp04dk5GRYYz5ZVxDQkLM4cOH3drm5+ebvLw8t2VHjx41TZs2NePGjXNbLslMmzbN9bzwnN23b1+J4/TDDz+Yli1bms6dO5vjx497NA6HDx82gYGBZtCgQW6vhz/84Q+c56b85/nevXuL/d4q9MorrxhJrt+JqampRpJJT083O3fuNJLMjh07jDHGfPDBByXO47mmTZvmduyleeaZZ4wkc+jQIY+OCajNeEseUMssXLhQTZs21XXXXSfp57eg3HbbbVq0aJEKCgpc7cLCwnTixAmlpKRY+/rnP/+pyy+/XDfddFOxdYVvaVm8eLE6duyoSy65RD/++KPrcf3110tSsbckJSQkqG3btq7nXbp0UUhIiL799ltJUkFBgVatWqWhQ4eqZcuWrnYdO3ZUYmJimcdh4sSJbm+76dWrlwoKCpSeni5JWrNmjfLz84u93eu+++4rU/+9evWSJH366aeSfv4f9quuukr9+vXTZ599Junnt3lt377d1dYYo3/+858aPHiwjDFu45WYmKicnBx98cUXJe4vMzNT27Zt06hRo9zeAtS7d2917ty5xG1uu+02hYeHF6u5cKxLU5bzo6Jyc3Mlye14pJ8/oB8REeF6FL0ZwuLFixUaGqp+/fq5jV9sbKwaNGhQ7Hzr1KmT67glKSIiQh06dHAbg8WLF6tXr14KDw936zMhIUEFBQWuOS40bNgwRUREuC2rU6eOAgMDJf38VrkjR44oPz9fV155pXVOy6KgoEAjRozQsWPHtHTpUtWvX9+jcVi9erXOnDmj++67z+31UNoVnqI4z0v2008/SZLbfgud+zmmDRs2qHnz5mrZsqUuueQSNWrUyPW2PNsNH4qO2Y8//qiTJ0/K6XQWW17SHSQLayr6tmkApauVgenTTz/V4MGDFR0dLYfDUa5L08YYzZ49WxdffLGCgoLUvHlz/fGPf/R+sYAXFRQUaNGiRbruuuu0b98+7d27V3v37lVcXJwOHTqkNWvWuNrec889uvjiizVw4EC1aNFC48aNK/ZZom+++UaXXXZZqfvcs2ePduzY4fYHbkREhC6++GJJ0uHDh93aFw1BhcLDw12fu/jhhx906tQptW/fvli7Dh06lG0gSthP4R8RhfspDE7nvvWpUaNGJf4RdK6mTZuqffv2rj8aP/vsM/Xq1UvXXnutMjMz9e2332rDhg1yOp2uP+B++OEHZWdn64033ig2XmPHjpVUfLwK2eq1LSvLGJSmLOdHSX744QdlZWW5HsePH7e2bdiwoSQVa3PNNdcoJSVFKSkp6t+/v9u6PXv2KCcnR5GRkcXG8Pjx4x6fb4V9rly5slh/CQkJkorPSZs2bUo8nrfffltdunRRcHCwGjdurIiICP373/9WTk6OdQzO57HHHtPatWv1t7/9ze0/Gso6DoXnzbmvp4iICM5zlf88L2SMKbbssssuU1hYmFsoKrztuMPhUHx8vNu6mJiYYsdw7rjNmjVL3333XbHlRd8ueW5NtfEmIkB51crPMJ04cUKXX365xo0bV+zDqmX1wAMP6KOPPtLs2bPVuXNnHTlypNj3KgDVzdq1a3Xw4EEtWrRIixYtKrZ+4cKFrj9AIyMjlZaWplWrVmnFihVasWKFkpOTNWrUKL399ttl3qfT6VTnzp31/PPPl7g+JibG7bntblgl/eFREVWxn549e2rNmjU6deqUtmzZoieeeML1x9Jnn32mXbt2qUGDBurWrZskuW4gcMcdd2j06NEl9ln4mRBvqMgYlPf8uOqqq1x/9ErStGnTrN9/c8kll0iStm/frssvv9y1vGhYWbBggds2TqdTkZGR1huZlHTlpyRFx8DpdKpfv356+OGHS2xbGP4L1a1bt1ibBQsWaMyYMRo6dKh+97vfKTIyUnXq1FFSUpK++eabEvs9n2XLlunZZ5/VU089pQEDBrit83QcKoLzvLjCz1uWFMr8/PwUHx+vjRs3um4xXvQ7lnr06KF58+a5Pts0dOjQYn2ce8XrnXfe0UcffVTs9VD4ObyiCmtq0qSJ/cABuKmVgWngwIEaOHCgdX1eXp4effRR/f3vf1d2drYuu+wyPfvss+rTp4+knz/w+dprr2n79u2u/9G2/Y8iUJ0sXLhQkZGRrjtCFbVkyRItXbpUc+fOdf3BFxgYqMGDB2vw4MFyOp2655579Prrr+vxxx9Xu3bt1LZtW23fvr3UfbZt21Zffvml+vbt65X/0YyIiFDdunW1Z8+eYut2795d4f4LFb7Na+/evW6v759++qlM/zMt/fzWn+TkZNfbHXv06CE/Pz/17NnT9Ydkjx49XH/QRUREqGHDhiooKHAFgvLUe66KfM9WaXN2vvOjJAsXLtSpU6dczy+66CJr/wMHDlSdOnW0cOFCjRw5skz1tm3bVqtXr9Y111xTYnApj7Zt2+r48eMez0lR7733ni666CItWbLEbUynTZtWrv7+97//afTo0Ro6dGiJX2ha1nEoPG/27NnjNhc//PAD5/n/Kc953rJlS9WtW1f79u0rcX3Pnj21YsUKLV++XIcPH3ZdYZJ+DkyPPvqoPvzwQ506darE7186d9zWr1+v4ODgMo3nvn371KRJE6+GZuBCVyvfknc+9957r1JTU7Vo0SJ99dVXuvXWWzVgwADXH2j/+te/dNFFF+mDDz5QmzZt1Lp1a911111cYUK1durUKS1ZskS/+tWvdMsttxR73HvvvTp27JiWL18u6Zf34Bfy8/Nz/a9v4fvihw0bpi+//FJLly4ttr/C/70dPny4Dhw4UOKXx546dUonTpzw6Djq1KmjxMRELVu2TBkZGa7lu3bt0qpVqzzqqzR9+/aVv7+/XnvtNbflL7/8cpn7KHwL0rPPPqsuXbooNDTUtXzNmjX6/PPP3T4/U6dOHQ0bNkz//Oc/Swyi5972vKjo6Ghddtlleuedd9zewvbJJ59o27ZtZa75XIWficnOznZbXpbzoyTXXHONEhISXI/SAlPLli01btw4rVixwjru514lGD58uAoKCvTUU08Va5ufn1/sOMpi+PDhSk1NLfH8ys7OVn5+/nn7KAwLRevdtGmTUlNTPa7n+PHjuummm9S8eXO9/fbbJf6xX9ZxSEhIUEBAgF566SW32s69819pOM+LCwgI0JVXXlnsS2gLFYagZ599VvXq1XO7S+LVV18tf39/Pffcc25tvWXLli2Kj4/3ap/Aha5WXmEqTUZGhpKTk5WRkaHo6GhJ0m9/+1utXLlSycnJeuaZZ/Ttt98qPT1dixcv1jvvvKOCggJNmTJFt9xyi9auXevjIwBKtnz5ch07dkw33nhjieu7d+/u+hLb2267zfWfANdff71atGih9PR0vfTSS+ratavr1sC/+93v9N577+nWW2/VuHHjFBsbqyNHjmj58uWaO3euLr/8ct1555169913dffdd2vdunW65pprVFBQoK+//lrvvvuuVq1apSuvvNKjY3nyySe1cuVK9erVS/fcc4/y8/P10ksv6dJLL3X77peKaNq0qR544AH96U9/0o033qgBAwboyy+/1IoVK9SkSZMyXS1r166doqKitHv3brebRVx77bV65JFHJMntD0lJmjlzptatW6e4uDhNmDBBnTp10pEjR/TFF19o9erVpf7HzDPPPKMhQ4bommuu0dixY3X06FG9/PLLuuyyy0r9rFBpCr8U9v7771diYqLq1Kmj22+/vUznhzfMmTNH+/bt03333adFixZp8ODBioyM1I8//qgNGzboX//6l9tn13r37q1JkyYpKSlJaWlp6t+/vwICArRnzx4tXrxYf/7zn3XLLbd4VMPvfvc7LV++XL/61a9ctxw/ceKEtm3bpvfee0/79+8/79ubfvWrX2nJkiW66aabNGjQIO3bt09z585Vp06dPJ6bJ598Ujt37tRjjz1W7Pt02rZtq/j4+DKPQ0REhH77298qKSlJv/rVr3TDDTdo69atrvO8LDjPSzZkyBA9+uijys3NVUhIiNu6q6++WoGBgUpNTVWfPn3k7//Ln2P16tXT5ZdfrtTUVIWFhZ33c6KeOHz4sL766itNnjzZa30CtUKV35evmpFkli5d6npeeAvP+vXruz38/f3N8OHDjTHGTJgwwUgyu3fvdm23ZcsWI8l8/fXXVX0IQJkMHjzYBAcHmxMnTljbjBkzxgQEBJgff/zRvPfee6Z///4mMjLSBAYGmpYtW5pJkyaZgwcPum3z008/mXvvvdc0b97cBAYGmhYtWpjRo0e73S74zJkz5tlnnzWXXnqpCQoKMuHh4SY2NtY8+eSTJicnx9VOkpk8eXKxus69NbgxxnzyyScmNjbWBAYGmosuusjMnTvXTJs2rcy3Fd+8ebNbu3Xr1hlJZt26da5l+fn55vHHHzdRUVGmbt265vrrrze7du0yjRs3Nnfffbd1HIu69dZbjSTzj3/8w2086tWrZwIDA82pU6eKbXPo0CEzefJkExMTYwICAkxUVJTp27eveeONN1xtSrrdsjHGLFq0yFxyySUmKCjIXHbZZWb58uVm2LBh5pJLLim27axZs4rtW+fc0jo/P9/cd999JiIiwjgcDtf4lvX88Ib8/HyTnJxsrr/+etOoUSPj7+9vmjRpYvr27Wvmzp1b4hi+8cYbJjY21tStW9c0bNjQdO7c2Tz88MMmMzPT1aZVq1Zm0KBBxbbt3bu36d27t9uyY8eOmalTp5p27dqZwMBA06RJE9OjRw8ze/Zsc+bMGWNM6ePqdDrNM888Y1q1amWCgoJMt27dzAcffGBGjx5d7HbQ587BubcVHz16tJFU4uPc10lZxqGgoMA8+eSTplmzZqZu3bqmT58+Zvv27SW+7mw4z4s7dOiQ8ff3N3/9619LXB8fH28kmT/84Q/F1t1///1Gkhk4cOB592NM2W8r/tprr5l69eqZ3NzcMvUL4GcOY7z8SeoaxuFwaOnSpa4PVf7jH//QyJEjtWPHjmIfFG3QoIGioqI0bdo0PfPMMzp79qxr3alTp1SvXj199NFH6tevX1UeAoAqlJ2drfDwcD399NN69NFHfV1OmXTt2lURERGVegtwwNeq43k+fvx4/e9//3PdRdDXunXrpj59+uiFF17wdSlAjcJnmM7RrVs3FRQU6PDhw2rXrp3bIyoqStLP78HPz893u7PR//73P0ly+z4QADVb0ZsTFCr8bEfhTWCqk7Nnzxb7PM3HH3+sL7/8slrWC5RHTTrPp02bps2bN7tuE+5LK1eu1J49ezR16lRflwLUOLXyCtPx48ddd9Pp1q2bnn/+eV133XVq1KiRWrZsqTvuuEMbNmzQn/70J3Xr1k0//PCD1qxZoy5dumjQoEFyOp266qqr1KBBA82ZM0dOp1OTJ09WSEiIPvroIx8fHQBvmT9/vubPn68bbrhBDRo00Pr16/X3v/9d/fv39+oNJrxl//79SkhI0B133KHo6Gh9/fXXmjt3rkJDQ7V9+3bXrY6BmozzHEBVq5WB6eOPP9Z1111XbPno0aM1f/58nT17Vk8//bTeeecdHThwQE2aNFH37t315JNPur5JPDMzU/fdd58++ugj1a9fXwMHDtSf/vQnNWrUqKoPB0Al+eKLL/Twww8rLS1Nubm5atq0qYYNG6ann35aDRo08HV5xeTk5GjixInasGGDfvjhB9WvX199+/bVzJkz3b7UFKjJOM8BVLVaGZgAAAAAoCz4DBMAAAAAWBCYAAAAAMCi1nxxrdPpVGZmpho2bFimL5wEAAAAcGEyxujYsWOKjo6Wn1/p15BqTWDKzMxUTEyMr8sAAAAAUE189913atGiRaltak1gatiwoaSfByUkJMTH1QAAAADwldzcXMXExLgyQmlqTWAqfBteSEgIgQkAAABAmT6qw00fAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFj4+7oA/KKf362+LgH/Z1Vmmq9LKFVidFdfl1CqFOdiX5cAAADgFVxhAgAAAAALjwJT69at5XA4ij0mT55cYvv58+cXaxscHOxaf/bsWT3yyCPq3Lmz6tevr+joaI0aNUqZmZnn3e/MmTPLcbgAAAAAUHYevSVv8+bNKigocD3fvn27+vXrp1tvtb+VLCQkRLt373Y9dzgcrp9PnjypL774Qo8//rguv/xyHT16VA888IBuvPFGff755279zJgxQxMmTHA9b9iwoSelAwAAAIDHPApMERERbs9nzpyptm3bqnfv3tZtHA6HoqKiSlwXGhqqlJQUt2Uvv/yyrr76amVkZKhly5au5Q0bNrT2AwAAAACVodyfYTpz5owWLFigcePGuV01Otfx48fVqlUrxcTEaMiQIdqxY0ep/ebk5MjhcCgsLMxt+cyZM9W4cWN169ZNs2bNUn5+fqn95OXlKTc31+0BAAAAAJ4o913yli1bpuzsbI0ZM8bapkOHDpo3b566dOminJwczZ49Wz169NCOHTvUokWLYu1Pnz6tRx55RCNGjFBISIhr+f33368rrrhCjRo10saNGzV16lQdPHhQzz//vHXfSUlJevLJJ8t7eAAAAAAghzHGlGfDxMREBQYG6l//+leZtzl79qw6duyoESNG6Kmnniq2btiwYfr+++/18ccfuwWmc82bN0+TJk3S8ePHFRQUVGKbvLw85eXluZ7n5uYqJiZGOTk5pfbtS9xWvPrgtuIVw23FAQBAdZabm6vQ0NAyZYNyXWFKT0/X6tWrtWTJEo+2CwgIULdu3bR371635WfPntXw4cOVnp6utWvXnrfouLg45efna//+/erQoUOJbYKCgqxhCgAAAADKolyfYUpOTlZkZKQGDRrk0XYFBQXatm2bmjVr5lpWGJb27Nmj1atXq3HjxuftJy0tTX5+foqMjPS4dgAAAAAoK4+vMDmdTiUnJ2v06NHy93fffNSoUWrevLmSkpIk/Xwr8O7du6tdu3bKzs7WrFmzlJ6errvuukvSz2Hplltu0RdffKEPPvhABQUFysrKkiQ1atRIgYGBSk1N1aZNm3TdddepYcOGSk1N1ZQpU3THHXcoPDy8oscPAAAAAFYeB6bVq1crIyND48aNK7YuIyNDfn6/XLQ6evSoJkyYoKysLIWHhys2NlYbN25Up06dJEkHDhzQ8uXLJUldu3Z162vdunXq06ePgoKCtGjRIk2fPl15eXlq06aNpkyZooceesjT0gEAAADAI+W+6UNN48kHu3yFmz5UH9z0oWK46QMAAKjOPMkG5f4eJgAAAAC40BGYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgwfcwVSPOrPZe7a86f1dPdf+eo9qmOp8ruLDxnV0AAF/ge5gAAAAAwAsITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALhzHG+LqIqpCbm6vQ0FDl5OQoJCTE1+WUqJ/frb4uocZalZnm6xJQRGJ0V1+XAFQ7Kc7Fvi4BAPB/PMkGXGECAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMDCYYwxvi6iKuTm5io0NFQ5OTkKCQnxdTklcma193UJQLWTGN3V1yUAKIcU52JflwAAVp5kA64wAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACz8fV0AfpEY3dWr/a3KTPNqf4AvVPfz2NuvW+BC0c/vVl+XUKVSnIt9XQKASsIVJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALPx9XQAA1GSrMtO82l9idFev9gegavTzu9XXJVSZFOdiX5cAVCmuMAEAAACAhUeBqXXr1nI4HMUekydPLrH9/Pnzi7UNDg52rT979qweeeQRde7cWfXr11d0dLRGjRqlzMxMt36OHDmikSNHKiQkRGFhYRo/fryOHz9ejsMFAAAAgLLz6C15mzdvVkFBgev59u3b1a9fP916q/0ydEhIiHbv3u167nA4XD+fPHlSX3zxhR5//HFdfvnlOnr0qB544AHdeOON+vzzz13tRo4cqYMHDyolJUVnz57V2LFjNXHiRP3tb3/zpHwAAAAA8IhHgSkiIsLt+cyZM9W2bVv17t3buo3D4VBUVFSJ60JDQ5WSkuK27OWXX9bVV1+tjIwMtWzZUrt27dLKlSu1efNmXXnllZKkl156STfccINmz56t6OhoTw4BAAAAAMqs3J9hOnPmjBYsWKBx48a5XTU61/Hjx9WqVSvFxMRoyJAh2rFjR6n95uTkyOFwKCwsTJKUmpqqsLAwV1iSpISEBPn5+WnTpk3WfvLy8pSbm+v2AAAAAABPlDswLVu2TNnZ2RozZoy1TYcOHTRv3jy9//77WrBggZxOp3r06KHvv/++xPanT5/WI488ohEjRigkJESSlJWVpcjISLd2/v7+atSokbKysqz7TkpKUmhoqOsRExPj+UECAAAAqNXKHZjeeustDRw4sNS3xMXHx2vUqFHq2rWrevfurSVLligiIkKvv/56sbZnz57V8OHDZYzRa6+9Vt6yXKZOnaqcnBzX47vvvqtwnwAAAABql3J9D1N6erpWr16tJUuWeLRdQECAunXrpr1797otLwxL6enpWrt2revqkiRFRUXp8OHDbu3z8/N15MgR62ejJCkoKEhBQUEe1QcAAAAARZXrClNycrIiIyM1aNAgj7YrKCjQtm3b1KxZM9eywrC0Z88erV69Wo0bN3bbJj4+XtnZ2dqyZYtr2dq1a+V0OhUXF1ee8gEAAACgTDy+wuR0OpWcnKzRo0fL399981GjRql58+ZKSkqSJM2YMUPdu3dXu3btlJ2drVmzZik9PV133XWXpJ/D0i233KIvvvhCH3zwgQoKClyfS2rUqJECAwPVsWNHDRgwQBMmTNDcuXN19uxZ3Xvvvbr99tu5Qx4AAACASuVxYFq9erUyMjI0bty4YusyMjLk5/fLRaujR49qwoQJysrKUnh4uGJjY7Vx40Z16tRJknTgwAEtX75cktS1a1e3vtatW6c+ffpIkhYuXKh7771Xffv2lZ+fn4YNG6YXX3zR09IBAAAAwCMOY4zxdRFVITc3V6GhocrJyXH7jFR10s/P/gXA5bEqM82r/QGofInRXX1dAgCUKsW52NclABXmSTYo913yAAAAAOBCR2ACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAF38NUjTiz2nu1P29+nwvf6QRf8fb3EtW2c5nvdQKA6oXvsaoe+B4mAAAAAPACAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAwt/XBeAXidFdfV1ClfH2sa7KTPNqf9VddT9Xatt8AABQVv38bvV1CVUmxbnY1yV4BVeYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwcBhjjK+LqAq5ubkKDQ1VTk6OQkJCfF1OiZxZ7b3aX2J0V6/2502rMtO82p+3j7W611ebeHsuUDGcywAAX0lxLvZaX55kA64wAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABg4e/rAlB5VmWm+boEq8Torr4uoUbz9tx6ez6q87kHAADgCa4wAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABg4e/rAvCLxOiuXu1vVWaaV/urTZiLivHm+NW2sQMAANULV5gAAAAAwMKjwNS6dWs5HI5ij8mTJ5fYfv78+cXaBgcHu7VZsmSJ+vfvr8aNG8vhcCgtLa1YP3369CnWz9133+1J6QAAAADgMY/ekrd582YVFBS4nm/fvl39+vXTrbfeat0mJCREu3fvdj13OBxu60+cOKGePXtq+PDhmjBhgrWfCRMmaMaMGa7n9erV86R0AAAAAPCYR4EpIiLC7fnMmTPVtm1b9e7d27qNw+FQVFSUdf2dd94pSdq/f3+p+65Xr16p/QAAAACAt5X7M0xnzpzRggULNG7cuGJXjYo6fvy4WrVqpZiYGA0ZMkQ7duwo1/4WLlyoJk2a6LLLLtPUqVN18uTJUtvn5eUpNzfX7QEAAAAAnij3XfKWLVum7OxsjRkzxtqmQ4cOmjdvnrp06aKcnBzNnj1bPXr00I4dO9SiRYsy7+vXv/61WrVqpejoaH311Vd65JFHtHv3bi1ZssS6TVJSkp588klPDgkAAAAA3JQ7ML311lsaOHCgoqOjrW3i4+MVHx/vet6jRw917NhRr7/+up566qky72vixImunzt37qxmzZqpb9+++uabb9S2bdsSt5k6daoeeugh1/Pc3FzFxMSUeZ8AAAAAUK7AlJ6ertWrV5d6hackAQEB6tatm/bu3Vue3brExcVJkvbu3WsNTEFBQQoKCqrQfgAAAADUbuX6DFNycrIiIyM1aNAgj7YrKCjQtm3b1KxZs/Ls1qXw1uMV7QcAAAAASuPxFSan06nk5GSNHj1a/v7um48aNUrNmzdXUlKSJGnGjBnq3r272rVrp+zsbM2aNUvp6em66667XNscOXJEGRkZyszMlCTXLcijoqIUFRWlb775Rn/72990ww03qHHjxvrqq680ZcoUXXvtterSpUu5DxwAAAAAzsfjwLR69WplZGRo3LhxxdZlZGTIz++Xi1ZHjx7VhAkTlJWVpfDwcMXGxmrjxo3q1KmTq83y5cs1duxY1/Pbb79dkjRt2jRNnz5dgYGBWr16tebMmaMTJ04oJiZGw4YN02OPPeZp6QAAAADgEYcxxvi6iKqQm5ur0NBQ5eTkKCQkxNfllKifn/0LgMtjVWaaV/vzpsTorr4uoUpV57mQqvd8VPexq22q87kCALiwpTgXe60vT7JBub+HCQAAAAAudAQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYePzFtag81fn7ZvjulYph/HChqM6/pyTvvta8faz8HgCAmokrTAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWPj7ugD8IjG6q69LQCVZlZnm6xJK5e1zz5vHW51rQ/VTnc89AEDNxBUmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgIW/rwtA7bQqM83XJVSpxOiuvi6hVNV5Pqpzbbiwefvcq+6/B6q76v67gPkFLlxcYQIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwMLf1wXgF6sy03xdQpVJjO7q1f5q09hJ1f94vTm/1f1YAVQNb/+7AQBlxRUmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAs/H1dAH6RGN3Vq/2tykzzWl/VubaaoLYdb3Xm7XPZ2zhXKsab81vd58Lb9VX31wbKj3MFqBiuMAEAAACAhUeBqXXr1nI4HMUekydPLrH9/Pnzi7UNDg52a7NkyRL1799fjRs3lsPhUFpaWrF+Tp8+rcmTJ6tx48Zq0KCBhg0bpkOHDnlSOgAAAAB4zKPAtHnzZh08eND1SElJkSTdeuut1m1CQkLctklPT3dbf+LECfXs2VPPPvustY8pU6boX//6lxYvXqxPPvlEmZmZuvnmmz0pHQAAAAA85tFnmCIiItyez5w5U23btlXv3r2t2zgcDkVFRVnX33nnnZKk/fv3l7g+JydHb731lv72t7/p+uuvlyQlJyerY8eO+s9//qPu3bt7cggAAAAAUGbl/gzTmTNntGDBAo0bN04Oh8Pa7vjx42rVqpViYmI0ZMgQ7dixw6P9bNmyRWfPnlVCQoJr2SWXXKKWLVsqNTXVul1eXp5yc3PdHgAAAADgiXIHpmXLlik7O1tjxoyxtunQoYPmzZun999/XwsWLJDT6VSPHj30/fffl3k/WVlZCgwMVFhYmNvypk2bKisry7pdUlKSQkNDXY+YmJgy7xMAAAAApAoEprfeeksDBw5UdHS0tU18fLxGjRqlrl27qnfv3lqyZIkiIiL0+uuvl3e3ZTZ16lTl5OS4Ht99912l7xMAAADAhaVc38OUnp6u1atXa8mSJR5tFxAQoG7dumnv3r1l3iYqKkpnzpxRdna221WmQ4cOlfrZqKCgIAUFBXlUHwAAAAAUVa4rTMnJyYqMjNSgQYM82q6goEDbtm1Ts2bNyrxNbGysAgICtGbNGtey3bt3KyMjQ/Hx8R7tHwAAAAA84fEVJqfTqeTkZI0ePVr+/u6bjxo1Ss2bN1dSUpIkacaMGerevbvatWun7OxszZo1S+np6brrrrtc2xw5ckQZGRnKzMyU9HMYkn6+shQVFaXQ0FCNHz9eDz30kBo1aqSQkBDdd999io+P5w55AAAAACqVx4Fp9erVysjI0Lhx44qty8jIkJ/fLxetjh49qgkTJigrK0vh4eGKjY3Vxo0b1alTJ1eb5cuXa+zYsa7nt99+uyRp2rRpmj59uiTphRdekJ+fn4YNG6a8vDwlJibq1Vdf9bR0AAAAAPCIx4Gpf//+MsaUuO7jjz92e/7CCy/ohRdeKLW/MWPGlHqnPUkKDg7WK6+8oldeecWTUgEAAACgQsp9lzwAAAAAuNARmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYOHx9zCh8qzKTPNqf4nRXb3aH+ALnMcXtuo8v9W5Nqn614fqg3MFqBiuMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYOHv6wLwi8Torl7tb1Vmmlf7q02Yi4rx5vF6ey6qu9p2vICvePv3Mq9d4MLFFSYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACz8fV0AfrEqM82r/SVGd/VaX96urbqrbcfrbd489wBAqv6/l6tzffxOBiqGK0wAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFj4+7oA/CIxuquvS7Dydm2rMtO82l9tU53PFeBCUdt+T1X33yv8O1R+3j7W6n6uAN7GFSYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACz8fV0AaqfE6K5e7W9VZppX+/M2bx8vAFR31f33MsrP23PLv5Go7jy6wtS6dWs5HI5ij8mTJ5fYfv78+cXaBgcHu7UxxuiJJ55Qs2bNVLduXSUkJGjPnj3n3e/MmTM9PFQAAAAA8IxHV5g2b96sgoIC1/Pt27erX79+uvXWW63bhISEaPfu3a7nDofDbf1zzz2nF198UW+//bbatGmjxx9/XImJidq5c6dbuJoxY4YmTJjget6wYUNPSgcAAAAAj3kUmCIiItyez5w5U23btlXv3r2t2zgcDkVFRZW4zhijOXPm6LHHHtOQIUMkSe+8846aNm2qZcuW6fbbb3e1bdiwobUfAAAAAKgM5b7pw5kzZ7RgwQKNGzeu2FWjoo4fP65WrVopJiZGQ4YM0Y4dO1zr9u3bp6ysLCUkJLiWhYaGKi4uTqmpqW79zJw5U40bN1a3bt00a9Ys5efnl1pfXl6ecnNz3R4AAAAA4Ily3/Rh2bJlys7O1pgxY6xtOnTooHnz5qlLly7KycnR7Nmz1aNHD+3YsUMtWrRQVlaWJKlp06Zu2zVt2tS1TpLuv/9+XXHFFWrUqJE2btyoqVOn6uDBg3r++eet+05KStKTTz5Z3sMDAAAAgPIHprfeeksDBw5UdHS0tU18fLzi4+Ndz3v06KGOHTvq9ddf11NPPVXmfT300EOun7t06aLAwEBNmjRJSUlJCgoKKnGbqVOnum2Xm5urmJiYMu8TAAAAAMr1lrz09HStXr1ad911l0fbBQQEqFu3btq7d68kuT6TdOjQIbd2hw4dKvXzSnFxccrPz9f+/futbYKCghQSEuL2AAAAAABPlCswJScnKzIyUoMGDfJou4KCAm3btk3NmjWTJLVp00ZRUVFas2aNq01ubq42bdrkdmXqXGlpafLz81NkZGR5ygcAAACAMvH4LXlOp1PJyckaPXq0/P3dNx81apSaN2+upKQkST/fCrx79+5q166dsrOzNWvWLKWnp7uuTDkcDj344IN6+umn1b59e9dtxaOjozV06FBJUmpqqjZt2qTrrrtODRs2VGpqqqZMmaI77rhD4eHhFTx8AAAAALDzODCtXr1aGRkZGjduXLF1GRkZ8vP75aLV0aNHNWHCBGVlZSk8PFyxsbHauHGjOnXq5Grz8MMP68SJE5o4caKys7PVs2dPrVy50vUdTEFBQVq0aJGmT5+uvLw8tWnTRlOmTHH7fBIAAAAAVAaHMcb4uoiqkJubq9DQUOXk5FTbzzP187N/ATBKtyozzdcllCoxuquvSwDgoer+e8XbvP17qraNH8qPfyNRVinOxV7ry5NsUO7vYQIAAACACx2BCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALDw93UB+IU3v4zL26r7l+pW9y9crO5f4MiXBuJCUd1fa9UZYwcAJeMKEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMDC39cFoGZIcS72dQlVqp/frV7tb1Vmmlf7Ay4UvDYAANUdV5gAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALDw93UBQHWU4lzs6xKq2K2+LsBqVWaar0soVWJ0V1+XUKN5e/yq+/kCXAj4vYfahitMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABY+Pu6AAC+l+Jc7OsSqowzq72vSwBQDonRXb3a36rMNK/2V515e+yA2oYrTAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWPj7ugAAqEp+UXu82l+K06vdVXv9/G71dQmopVZlpnm1P2//LqjOatvvKcDbuMIEAAAAABYeBabWrVvL4XAUe0yePLnE9vPnzy/WNjg42K2NMUZPPPGEmjVrprp16yohIUF79rj/r8+RI0c0cuRIhYSEKCwsTOPHj9fx48c9PFQAAAAA8IxHgWnz5s06ePCg65GSkiJJuvVW+1s0QkJC3LZJT093W//cc8/pxRdf1Ny5c7Vp0ybVr19fiYmJOn36tKvNyJEjtWPHDqWkpOiDDz7Qp59+qokTJ3pSOgAAAAB4zKPPMEVERLg9nzlzptq2bavevXtbt3E4HIqKiipxnTFGc+bM0WOPPaYhQ4ZIkt555x01bdpUy5Yt0+23365du3Zp5cqV2rx5s6688kpJ0ksvvaQbbrhBs2fPVnR0tCeHAAAAAABlVu7PMJ05c0YLFizQuHHj5HA4rO2OHz+uVq1aKSYmRkOGDNGOHTtc6/bt26esrCwlJCS4loWGhiouLk6pqamSpNTUVIWFhbnCkiQlJCTIz89PmzZtsu43Ly9Pubm5bg8AAAAA8ES5A9OyZcuUnZ2tMWPGWNt06NBB8+bN0/vvv68FCxbI6XSqR48e+v777yVJWVlZkqSmTZu6bde0aVPXuqysLEVGRrqt9/f3V6NGjVxtSpKUlKTQ0FDXIyYmpjyHCQAAAKAWK3dgeuuttzRw4MBS3xIXHx+vUaNGqWvXrurdu7eWLFmiiIgIvf766+XdbZlNnTpVOTk5rsd3331X6fsEAAAAcGEp1/cwpaena/Xq1VqyZIlH2wUEBKhbt27au3evJLk+23To0CE1a9bM1e7QoUPq2rWrq83hw4fd+snPz9eRI0esn42SpKCgIAUFBXlUHwAAAAAUVa4rTMnJyYqMjNSgQYM82q6goEDbtm1zhaM2bdooKipKa9ascbXJzc3Vpk2bFB8fL+nnq1TZ2dnasmWLq83atWvldDoVFxdXnvIBAAAAoEw8vsLkdDqVnJys0aNHy9/fffNRo0apefPmSkpKkiTNmDFD3bt3V7t27ZSdna1Zs2YpPT1dd911l6Sf76D34IMP6umnn1b79u3Vpk0bPf7444qOjtbQoUMlSR07dtSAAQM0YcIEzZ07V2fPntW9996r22+/nTvkAQAAAKhUHgem1atXKyMjQ+PGjSu2LiMjQ35+v1y0Onr0qCZMmKCsrCyFh4crNjZWGzduVKdOnVxtHn74YZ04cUITJ05Udna2evbsqZUrV7p9we3ChQt17733qm/fvvLz89OwYcP04osvelo6AAAAAHjEYYwxvi6iKuTm5io0NFQ5OTkKCQnxdTkAUCP187N/UXl1sCozzdcloIbwi9rj6xIA+JAn2aDcd8kDAAAAgAsdgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYef3EtAKD2SnEu9nUJAABUKa4wAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACz8fV1AVTHGSJJyc3N9XAkAAAAAXyrMBIUZoTS1JjAdO3ZMkhQTE+PjSgAAAABUB8eOHVNoaGipbRymLLHqAuB0OpWZmamGDRvK4XD4upxaKzc3VzExMfruu+8UEhLi63JqNeaiemE+qg/movpgLqoX5qP6YC4qzhijY8eOKTo6Wn5+pX9KqdZcYfLz81OLFi18XQb+T0hICC/waoK5qF6Yj+qDuag+mIvqhfmoPpiLijnflaVC3PQBAAAAACwITAAAAABgQWBClQoKCtK0adMUFBTk61JqPeaiemE+qg/movpgLqoX5qP6YC6qVq256QMAAAAAeIorTAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABKuZM2fK4XDowQcfdC1744031KdPH4WEhMjhcCg7O7vYdkeOHNHIkSMVEhKisLAwjR8/XsePH3dr89VXX6lXr14KDg5WTEyMnnvuuWL9LF68WJdccomCg4PVuXNnffjhh27rjTF64okn1KxZM9WtW1cJCQnas2ePV469OirvfLRu3VoOh8PtMXPmTLc2zIdnzp2LI0eO6L777lOHDh1Ut25dtWzZUvfff79ycnLctsvIyNCgQYNUr149RUZG6ne/+53y8/Pd2nz88ce64oorFBQUpHbt2mn+/PnF9v/KK6+odevWCg4OVlxcnP773/+6rT99+rQmT56sxo0bq0GDBho2bJgOHTrk1TGoTso7H+e+LhwOhxYtWuTWhvnwTEm/pyZNmqS2bduqbt26ioiI0JAhQ/T111+7bcdrw/vKOxe8LipHSfNRyBijgQMHyuFwaNmyZW7reG1UEwYowX//+1/TunVr06VLF/PAAw+4lr/wwgsmKSnJJCUlGUnm6NGjxbYdMGCAufzyy81//vMf89lnn5l27dqZESNGuNbn5OSYpk2bmpEjR5rt27ebv//976Zu3brm9ddfd7XZsGGDqVOnjnnuuefMzp07zWOPPWYCAgLMtm3bXG1mzpxpQkNDzbJly8yXX35pbrzxRtOmTRtz6tSpShkTX6rIfLRq1crMmDHDHDx40PU4fvy4az3z4ZmS5mLbtm3m5ptvNsuXLzd79+41a9asMe3btzfDhg1zbZefn28uu+wyk5CQYLZu3Wo+/PBD06RJEzN16lRXm2+//dbUq1fPPPTQQ2bnzp3mpZdeMnXq1DErV650tVm0aJEJDAw08+bNMzt27DATJkwwYWFh5tChQ642d999t4mJiTFr1qwxn3/+uenevbvp0aNH5Q+OD5R3PowxRpJJTk52e20UPV+ZD8/Yfk+9/vrr5pNPPjH79u0zW7ZsMYMHDzYxMTEmPz/fGMNrozKUdy6M4XVRGWzzUej55583AwcONJLM0qVLXct5bVQfBCYUc+zYMdO+fXuTkpJievfuXeKLe926dSX+gb5z504jyWzevNm1bMWKFcbhcJgDBw4YY4x59dVXTXh4uMnLy3O1eeSRR0yHDh1cz4cPH24GDRrk1ndcXJyZNGmSMcYYp9NpoqKizKxZs1zrs7OzTVBQkPn73/9e7mOvjioyH8b8HJheeOEFa//MR9mVZS4KvfvuuyYwMNCcPXvWGGPMhx9+aPz8/ExWVparzWuvvWZCQkJcY//www+bSy+91K2f2267zSQmJrqeX3311Wby5Mmu5wUFBSY6OtokJSUZY34e94CAALN48WJXm127dhlJJjU1tfwHXw1VZD6MMcX+ODkX81F2nszFl19+aSSZvXv3GmN4bXhbRebCGF4X3na++di6datp3ry5OXjwYLGx57VRffCWPBQzefJkDRo0SAkJCR5vm5qaqrCwMF155ZWuZQkJCfLz89OmTZtcba699loFBga62iQmJmr37t06evSoq825+09MTFRqaqokad++fcrKynJrExoaqri4OFebC0VF5qPQzJkz1bhxY3Xr1k2zZs1yu5zPfJSdJ3ORk5OjkJAQ+fv7S/p5DDt37qymTZu62iQmJio3N1c7duxwtSltnM+cOaMtW7a4tfHz81NCQoKrzZYtW3T27Fm3Npdccolatmx5Qc2FVLH5KNpHkyZNdPXVV2vevHkyRb6akPkou7LOxYkTJ5ScnKw2bdooJiZGEq8Nb6vIXBTtg9eFd5Q2HydPntSvf/1rvfLKK4qKiiq2ntdG9eF//iaoTRYtWqQvvvhCmzdvLtf2WVlZioyMdFvm7++vRo0aKSsry9WmTZs2bm0KfxlkZWUpPDxcWVlZbr8gCtsU7aPodiW1uRBUdD4k6f7779cVV1yhRo0aaePGjZo6daoOHjyo559/XhLzUVaezMWPP/6op556ShMnTnQts41h4brS2uTm5urUqVM6evSoCgoKSmxT+DmErKwsBQYGKiwsrFibC2UupIrPhyTNmDFD119/verVq6ePPvpI99xzj44fP677779fEvNRVmWZi1dffVUPP/ywTpw4oQ4dOiglJcX1nzS8NrynonMh8brwpvPNx5QpU9SjRw8NGTKkxPW8NqoPAhNcvvvuOz3wwANKSUlRcHCwr8up9bw1Hw899JDr5y5duigwMFCTJk1SUlKSgoKCvFHqBc+TucjNzdWgQYPUqVMnTZ8+vWoKrGW8NR+PP/646+du3brpxIkTmjVrlusPQ5xfWedi5MiR6tevnw4ePKjZs2dr+PDh2rBhA//WeJG35oLXhXecbz6WL1+utWvXauvWrT6oDp7iLXlw2bJliw4fPqwrrrhC/v7+8vf31yeffKIXX3xR/v7+KigoOG8fUVFROnz4sNuy/Px8HTlyxHW5OSoqqtidVwqfn69N0fVFtyupTU3njfkoSVxcnPLz87V//35JzEdZlHUujh07pgEDBqhhw4ZaunSpAgICXH1UZJxDQkJUt25dNWnSRHXq1DnvXJw5c6bYHRMvlLmQvDMfJYmLi9P333+vvLw8ScxHWZR1LkJDQ9W+fXtde+21eu+99/T1119r6dKlknhteIs35qIkvC7K53zzkZKSom+++UZhYWGu9ZI0bNgw9enTRxKvjeqEwASXvn37atu2bUpLS3M9rrzySo0cOVJpaWmqU6fOefuIj49Xdna2tmzZ4lq2du1aOZ1OxcXFudp8+umnOnv2rKtNSkqKOnTooPDwcFebNWvWuPWdkpKi+Ph4SVKbNm0UFRXl1iY3N1ebNm1ytanpvDEfJUlLS5Ofn5/rrZPMx/mVZS5yc3PVv39/BQYGavny5cX+RzE+Pl7btm1z+w+FlJQUhYSEqFOnTq42pY1zYGCgYmNj3do4nU6tWbPG1SY2NlYBAQFubXbv3q2MjIwLYi4k78xHSdLS0hQeHu668sp8nF95fk+Zn2845foDnNeGd3hjLkrC66J8zjcfjz76qL766iu39ZL0wgsvKDk5WRKvjWrFl3ecQPV37h1dDh48aLZu3WrefPNNI8l8+umnZuvWreann35ytRkwYIDp1q2b2bRpk1m/fr1p3769223Fs7OzTdOmTc2dd95ptm/fbhYtWmTq1atX7DbW/v7+Zvbs2WbXrl1m2rRpJd7GOiwszLz//vvmq6++MkOGDLkgb2NdlKfzsXHjRvPCCy+YtLQ0880335gFCxaYiIgIM2rUKFcfzEf5FJ2LnJwcExcXZzp37mz27t3rdjvec2+d3L9/f5OWlmZWrlxpIiIiSrw97O9+9zuza9cu88orr5R4e9igoCAzf/58s3PnTjNx4kQTFhbmdhelu+++27Rs2dKsXbvWfP755yY+Pt7Ex8dXzcD4iKfzsXz5cvPmm2+abdu2mT179phXX33V1KtXzzzxxBOuPpmP8ik6F99884155plnzOeff27S09PNhg0bzODBg02jRo1ctzTmtVF5PJ0LXheV63x3LZTltuK8NnyPwIRSnfvinjZtmpFU7JGcnOxq89NPP5kRI0aYBg0amJCQEDN27Fhz7Ngxt36//PJL07NnTxMUFGSaN29uZs6cWWzf7777rrn44otNYGCgufTSS82///1vt/VOp9M8/vjjpmnTpiYoKMj07dvX7N6926vHX914Oh9btmwxcXFxJjQ01AQHB5uOHTuaZ555xpw+fdqtX+bDc0XnovC27iU99u3b59pm//79ZuDAgaZu3bqmSZMm5je/+Y3bba4L++ratasJDAw0F110kdtrq9BLL71kWrZsaQIDA83VV19t/vOf/7itP3XqlLnnnntMeHi4qVevnrnpppvMwYMHvT0E1Yqn87FixQrTtWtX06BBA1O/fn1z+eWXm7lz55qCggK3fpkPzxWdiwMHDpiBAweayMhIExAQYFq0aGF+/etfm6+//tptG14blcPTueB1Ubk8DUzG8NqoLhzGFLlXJAAAAADAhc8wAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALDw93UBVen06dM6c+aMr8sAAAAA4GOBgYEKDg4+b7taE5hOnz6t0LrhOqPTvi4FAAAAgI9FRUVp37595w1NtSYwnTlzRmd0Wj11g/wVIDl+eTeiw8+hIk8sy4v8bFnu8POztD/nnY8Oy/ZF9m3bh7VftzaWfVn7LMN+5dlYGLc2lnosP5dt219+NGU49jK1se1LkrGNqa0OP8tyt/aWOoruuGgbv6LHU3Iba5/eau9nWW4bn6Ks7SuyvAxje846r9Vh6d+6bSXU46021m3lpTae1lasnSm5XQXGwq1PWVj7NCW2Kcu+PO3T4el+Zeun5KN0eLhfh9vPltpK2bf7r4qS+3L/J8a275K3tbX3U1lqKNK+DMvd+rS1KcPP7r/mPexHtjZOy75s2/7SXpLqWPdRtN8i7d3GouR9u/dpaWNbXqTPosdQx21fv/xcp8ixuC+3HEsZ6nHbl62Gov0UqcH9uJwlLreNj71/99dcHdtxWmqtYzl/3WqynF9Fl7u3+aUet/PGrc4iPxc5+93bFF1+/p/d2/tZ2hRfnnvMqVax+3XmzBkC07n8FSB/xzmByRIebMvLFHhs2567zs+yfYUCk/VfnvPXV5b9VovA5Fn7GhWYbH8I1cDA5L1gZFtehrE9Z11l1HHBBqaytFEZ2nhaQ7HtKzkwWY7ngg1MZVpe8n7tIaeigcmzAFShwFSW9lUYmOyhx/uBqSztpbIGJtsfzZUbmKxhpQzByL7c+4Gpjls/v5x0fkVOwKLL3cen6PKS2xcPTEXb2cKXSm7jVmtZ2pw/MNWphMDk3r7kMSpbYPL8Fg7c9AEAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYEFgAgAAAAALAhMAAAAAWBCYAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsCAwAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmAAAAADAgsAEAAAAABYEJgAAAACwIDABAAAAgAWBCQAAAAAsCEwAAAAAYOHv6wKqWr7OSkYqmhUdxlGkhW15kZ8tyx3Gr8TlMufm0iLrnEW2d1i2d1h+Lpp33dqo5OXWPsuwX9tyU/Jy49bGUo/l57JtW7SEouNZcntThvFxn76ijc6d8jLU4WdZbj2NitRRdMdu0130eEpuY+3TW+1tp7j1nCtL+4osL8PYnrPOa3VY+rduWwn1eKuNdVt5qY2ntRVrZ0puV4GxcOtTFtY+TYltyrIvT/t0eLpf2fop+SgdHu7X4fazpbZS9u3+q6Lkvtz/ibHtu+Rtbe2NSq7BaWnvV4blfipDmzL87P5r3sN+ZGvjLHG5Q7Zti/7jKdWx7qNov0Xau41Fyft279PSxra8SJ9Fj6GO275++blOkWNxX245ljLU47YvWw1F+ylSg/txOUtcbhsfe//ur7k6tuO01FrHcv661WQ5v4oud2/zSz1u541bnUV+LnL2u7cpuvz8P7u3l6VN8dpyj7mf96WpNYEpMDBQUVFRWp/14c8Lip5nBT4pCQAAAICPREVFKTAw8LztHMYY63+uXWhOnz6tM2fO+LqMC1Jubq5iYmL03XffKSQkxNflXHAY38rF+FYuxrdyMb6Vi/GtXIxv5WJ8SxcYGKjg4ODztqs1V5gkKTg4uEyDgvILCQnhBVmJGN/KxfhWLsa3cjG+lYvxrVyMb+VifCuGmz4AAAAAgAWBCQAAAAAsCEzwiqCgIE2bNk1BQUG+LuWCxPhWLsa3cjG+lYvxrVyMb+VifCsX4+sdteqmDwAAAADgCa4wAQAAAIAFgQkAAAAALAhMAAAAAGBBYAIAAAAACwITAAAAAFgQmFAuR44c0ciRIxUSEqKwsDCNHz9ex48fL3WbSZMmqW3btqpbt64iIiI0ZMgQff3111VUcc3i6fgeOXJE9913nzp06KC6deuqZcuWuv/++5WTk1OFVdcc5Tl/33jjDfXp00chISFyOBzKzs6ummJriFdeeUWtW7dWcHCw4uLi9N///rfU9osXL9Yll1yi4OBgde7cWR9++GEVVVozeTK+O3bs0LBhw9S6dWs5HA7NmTOn6gqtoTwZ3zfffFO9evVSeHi4wsPDlZCQcN7zvbbzZHyXLFmiK6+8UmFhYapfv766du2qv/71r1VYbc3j6e/fQosWLZLD4dDQoUMrt8ALAIEJ5TJy5Ejt2LFDKSkp+uCDD/Tpp59q4sSJpW4TGxur5ORk7dq1S6tWrZIxRv3791dBQUEVVV1zeDq+mZmZyszM1OzZs7V9+3bNnz9fK1eu1Pjx46uw6pqjPOfvyZMnNWDAAP3hD3+ooiprjn/84x966KGHNG3aNH3xxRe6/PLLlZiYqMOHD5fYfuPGjRoxYoTGjx+vrVu3aujQoRo6dKi2b99exZXXDJ6O78mTJ3XRRRdp5syZioqKquJqax5Px/fjjz/WiBEjtG7dOqWmpiomJkb9+/fXgQMHqrjymsHT8W3UqJEeffRRpaam6quvvtLYsWM1duxYrVq1qoorrxk8Hd9C+/fv129/+1v16tWriiqt4QzgoZ07dxpJZvPmza5lK1asMA6Hwxw4cKDM/Xz55ZdGktm7d29llFljeWt83333XRMYGGjOnj1bGWXWWBUd33Xr1hlJ5ujRo5VYZc1y9dVXm8mTJ7ueFxQUmOjoaJOUlFRi++HDh5tBgwa5LYuLizOTJk2q1DprKk/Ht6hWrVqZF154oRKrq/kqMr7GGJOfn28aNmxo3n777coqsUar6PgaY0y3bt3MY489Vhnl1XjlGd/8/HzTo0cP85e//MWMHj3aDBkypAoqrdm4wgSPpaamKiwsTFdeeaVrWUJCgvz8/LRp06Yy9XHixAklJyerTZs2iomJqaxSayRvjK8k5eTkKCQkRP7+/pVRZo3lrfHFz86cOaMtW7YoISHBtczPz08JCQlKTU0tcZvU1FS39pKUmJhobV+blWd8UXbeGN+TJ0/q7NmzatSoUWWVWWNVdHyNMVqzZo12796ta6+9tjJLrZHKO74zZsxQZGQk70LxAIEJHsvKylJkZKTbMn9/fzVq1EhZWVmlbvvqq6+qQYMGatCggVasWKGUlBQFBgZWZrk1TkXGt9CPP/6op5566rxvM6uNvDG++MWPP/6ogoICNW3a1G1506ZNreOZlZXlUfvarDzji7Lzxvg+8sgjio6OLvafACj/+Obk5KhBgwYKDAzUoEGD9NJLL6lfv36VXW6NU57xXb9+vd566y29+eabVVHiBYPABJff//73cjgcpT4qepOGkSNHauvWrfrkk0908cUXa/jw4Tp9+rSXjqB6q4rxlaTc3FwNGjRInTp10vTp0yteeA1RVeMLAIVmzpypRYsWaenSpQoODvZ1OReMhg0bKi0tTZs3b9Yf//hHPfTQQ/r44499XVaNd+zYMd15551688031aRJE1+XU6PwXh24/OY3v9GYMWNKbXPRRRcpKiqq2IcJ8/PzdeTIkfN+wDg0NFShoaFq3769unfvrvDwcC1dulQjRoyoaPnVXlWM77FjxzRgwAA1bNhQS5cuVUBAQEXLrjGqYnxRXJMmTVSnTh0dOnTIbfmhQ4es4xkVFeVR+9qsPOOLsqvI+M6ePVszZ87U6tWr1aVLl8oss8Yq7/j6+fmpXbt2kqSuXbtq165dSkpKUp8+fSqz3BrH0/H95ptvtH//fg0ePNi1zOl0Svr5nRa7d+9W27ZtK7foGorABJeIiAhFRESct118fLyys7O1ZcsWxcbGSpLWrl0rp9OpuLi4Mu/PGCNjjPLy8spdc01S2eObm5urxMREBQUFafny5bXufzur+vzFzwIDAxUbG6s1a9a4bk3rdDq1Zs0a3XvvvSVuEx8frzVr1ujBBx90LUtJSVF8fHwVVFyzlGd8UXblHd/nnntOf/zjH7Vq1Sq3z0PCnbfOX6fTWWv+VvCEp+N7ySWXaNu2bW7LHnvsMR07dkx//vOf+Ux5aXx80wnUUAMGDDDdunUzmzZtMuvXrzft27c3I0aMcK3//vvvTYcOHcymTZuMMcZ888035plnnjGff/65SU9PNxs2bDCDBw82jRo1MocOHfLVYVRbno5vTk6OiYuLM507dzZ79+41Bw8edD3y8/N9dRjVlqfja4wxBw8eNFu3bjVvvvmmkWQ+/fRTs3XrVvPTTz/54hCqlUWLFpmgoCAzf/58s3PnTjNx4kQTFhZmsrKyjDHG3Hnnneb3v/+9q/2GDRuMv7+/mT17ttm1a5eZNm2aCQgIMNu2bfPVIVRrno5vXl6e2bp1q9m6datp1qyZ+e1vf2u2bt1q9uzZ46tDqNY8Hd+ZM2eawMBA895777n9rj127JivDqFa83R8n3nmGfPRRx+Zb775xuzcudPMnj3b+Pv7mzfffNNXh1CteTq+5+IueWVDYEK5/PTTT2bEiBGmQYMGJiQkxIwdO9btH4t9+/YZSWbdunXGGGMOHDhgBg4caCIjI01AQIBp0aKF+fWvf22+/vprHx1B9ebp+Bbe6rqkx759+3xzENWYp+NrjDHTpk0rcXyTk5Or/gCqoZdeesm0bNnSBAYGmquvvtr85z//ca3r3bu3GT16tFv7d99911x88cUmMDDQXHrppebf//53FVdcs3gyvoXn77mP3r17V33hNYQn49uqVasSx3fatGlVX3gN4cn4Pvroo6Zdu3YmODjYhIeHm/j4eLNo0SIfVF1zePr7tygCU9k4jDGmyi5nAQAAAEANwl3yAAAAAMCCwAQAAAAAFgQmAAAAALAgMAEAAACABYEJAAAAACwITAAAAABgQWACAAAAAAsCEwAAAABYEJgAAAAAwILABAAAAAAWBCYAAAAAsPj/E8reNDK5qNcAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -705,33 +716,56 @@ } ], "source": [ - "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Ascending weights - Generalized weights (W+)\")\n", - "clrbar = ax.imshow(test_gen_asc_[\"Generalized W+\"], cmap='viridis')\n", + "# Plot ascending weights\n", + "\n", + "fig, axs = plt.subplots(3, 2, figsize = (14, 20))\n", + "\n", + "axs[0, 0].set_title(\"Ascending weights - Class\")\n", + "clrbar = axs[0, 0].imshow(rasters_ascending[\"Class\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(rasters_ascending[\"Class\"], ax = axs[0, 0], transform = test_ev.transform, cmap='viridis')\n", + "\n", + "axs[1, 0].set_title(\"Ascending weights - W+\")\n", + "clrbar = axs[1, 0].imshow(rasters_ascending[\"W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_asc_[\"Generalized W+\"], ax = ax, transform = test_ev.transform, cmap='viridis')" + "show(rasters_ascending[\"W+\"], ax = axs[1, 0], transform = test_ev.transform, cmap='viridis')\n", + "\n", + "axs[1, 1].set_title(\"Ascending weights - S_W+\")\n", + "clrbar = axs[1, 1].imshow(rasters_ascending[\"S_W+\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(rasters_ascending[\"S_W+\"], ax = axs[1, 1], transform = test_ev.transform, cmap='viridis')\n", + "\n", + "axs[2, 0].set_title(\"Ascending weights - Generalized W+\")\n", + "clrbar = axs[2, 0].imshow(rasters_ascending[\"Generalized W+\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(rasters_ascending[\"Generalized W+\"], ax = axs[2, 0], transform = test_ev.transform, cmap='viridis')\n", + "\n", + "axs[2, 1].set_title(\"Ascending weights - Generalized S_W+\")\n", + "clrbar = axs[2, 1].imshow(rasters_ascending[\"Generalized S_W+\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(rasters_ascending[\"Generalized S_W+\"], ax = axs[2, 1], transform = test_ev.transform, cmap='viridis')\n" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 8, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -739,11 +773,34 @@ } ], "source": [ - "fig, ax = plt.subplots(figsize = (10,10))\n", - "ax.set_title(\"Descending weights - Generalized weighst (W+)\")\n", - "clrbar = ax.imshow(test_gen_dsc_[\"Generalized W+\"], cmap='viridis')\n", + "# Plot descending weights\n", + "\n", + "fig, axs = plt.subplots(3, 2, figsize = (14, 20))\n", + "\n", + "axs[0, 0].set_title(\"Descending weights - Class\")\n", + "clrbar = axs[0, 0].imshow(rasters_descending[\"Class\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(rasters_descending[\"Class\"], ax = axs[0, 0], transform = test_ev.transform, cmap='viridis')\n", + "\n", + "axs[1, 0].set_title(\"Descending weights - W+\")\n", + "clrbar = axs[1, 0].imshow(rasters_descending[\"W+\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(rasters_descending[\"W+\"], ax = axs[1, 0], transform = test_ev.transform, cmap='viridis')\n", + "\n", + "axs[1, 1].set_title(\"Descending weights - S_W+\")\n", + "clrbar = axs[1, 1].imshow(rasters_descending[\"S_W+\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(rasters_descending[\"S_W+\"], ax = axs[1, 1], transform = test_ev.transform, cmap='viridis')\n", + "\n", + "axs[2, 0].set_title(\"Descending weights - Generalized W+\")\n", + "clrbar = axs[2, 0].imshow(rasters_descending[\"Generalized W+\"], cmap='viridis')\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(rasters_descending[\"Generalized W+\"], ax = axs[2, 0], transform = test_ev.transform, cmap='viridis')\n", + "\n", + "axs[2, 1].set_title(\"Descending weights - Generalized S_W+\")\n", + "clrbar = axs[2, 1].imshow(rasters_descending[\"Generalized S_W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(test_gen_dsc_[\"Generalized W+\"], ax = ax, transform = test_ev.transform, cmap='viridis')" + "show(rasters_descending[\"Generalized S_W+\"], ax = axs[2, 1], transform = test_ev.transform, cmap='viridis')" ] } ], From 61d5f009f30f00451c538ccb596c8479ca9aba46 Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Fri, 29 Sep 2023 16:08:49 +0300 Subject: [PATCH 23/31] Adjusted wofe based on review, added tests, deleted unncessary test files, adjusted documentation --- eis_toolkit/prediction/weights_of_evidence.py | 186 +++++++++++------- notebooks/weights_of_evidence.ipynb | 64 +++--- tests/data/remote/wofe/Merged_Ascending_.tif | Bin 13496 -> 0 bytes .../remote/wofe/Merged_Ascending_.tif.aux.xml | 59 ------ tests/data/remote/wofe/Merged_Descending_.tif | Bin 13496 -> 0 bytes .../wofe/Merged_Descending_.tif.aux.xml | 59 ------ tests/data/remote/wofe/Merged_Unique.tif | Bin 13496 -> 0 bytes .../remote/wofe/Merged_Unique.tif.aux.xml | 59 ------ tests/data/remote/wofe/Merged_pprbs.tif | Bin 13496 -> 0 bytes tests/data/remote/wofe/exp_wgts_asc.csv | 9 - tests/data/remote/wofe/exp_wgts_dsc.csv | 9 - tests/data/remote/wofe/exp_wgts_un.csv | 9 - tests/data/remote/wofe/wofe_dep_nan_.tif | Bin 3008 -> 0 bytes .../remote/wofe/wofe_dep_nan_.tif.aux.xml | 17 -- tests/data/remote/wofe/wofe_dep_nan_.tif.ovr | Bin 258 -> 0 bytes .../remote/wofe/wofe_dep_nan_.tif.vat.dbf | Bin 158 -> 0 bytes tests/data/remote/wofe/wofe_dep_nan_.tif.xml | 2 - ...dep_nan_.tif.vat.cpg => wofe_deposits.cpg} | 0 tests/data/remote/wofe/wofe_deposits.dbf | Bin 0 -> 738 bytes tests/data/remote/wofe/wofe_deposits.prj | 1 + tests/data/remote/wofe/wofe_deposits.sbn | Bin 0 -> 276 bytes tests/data/remote/wofe/wofe_deposits.sbx | Bin 0 -> 124 bytes tests/data/remote/wofe/wofe_deposits.shp | Bin 0 -> 548 bytes tests/data/remote/wofe/wofe_deposits.shx | Bin 0 -> 228 bytes tests/data/remote/wofe/wofe_deposits.xml | 2 + tests/data/remote/wofe/wofe_ev_nan.tfw | 6 - tests/data/remote/wofe/wofe_ev_nan.tif | Bin 4034 -> 0 bytes .../data/remote/wofe/wofe_ev_nan.tif.aux.xml | 30 --- tests/data/remote/wofe/wofe_ev_nan.tif.ovr | Bin 474 -> 0 bytes tests/data/remote/wofe/wofe_ev_nan.tif.xml | 2 - .../data/remote/wofe/wofe_evidence_raster.tif | Bin 0 -> 2083 bytes tests/prediction/weights_of_evidence_test.py | 39 ++++ 32 files changed, 185 insertions(+), 368 deletions(-) delete mode 100644 tests/data/remote/wofe/Merged_Ascending_.tif delete mode 100644 tests/data/remote/wofe/Merged_Ascending_.tif.aux.xml delete mode 100644 tests/data/remote/wofe/Merged_Descending_.tif delete mode 100644 tests/data/remote/wofe/Merged_Descending_.tif.aux.xml delete mode 100644 tests/data/remote/wofe/Merged_Unique.tif delete mode 100644 tests/data/remote/wofe/Merged_Unique.tif.aux.xml delete mode 100644 tests/data/remote/wofe/Merged_pprbs.tif delete mode 100644 tests/data/remote/wofe/exp_wgts_asc.csv delete mode 100644 tests/data/remote/wofe/exp_wgts_dsc.csv delete mode 100644 tests/data/remote/wofe/exp_wgts_un.csv delete mode 100644 tests/data/remote/wofe/wofe_dep_nan_.tif delete mode 100644 tests/data/remote/wofe/wofe_dep_nan_.tif.aux.xml delete mode 100644 tests/data/remote/wofe/wofe_dep_nan_.tif.ovr delete mode 100644 tests/data/remote/wofe/wofe_dep_nan_.tif.vat.dbf delete mode 100644 tests/data/remote/wofe/wofe_dep_nan_.tif.xml rename tests/data/remote/wofe/{wofe_dep_nan_.tif.vat.cpg => wofe_deposits.cpg} (100%) create mode 100644 tests/data/remote/wofe/wofe_deposits.dbf create mode 100644 tests/data/remote/wofe/wofe_deposits.prj create mode 100644 tests/data/remote/wofe/wofe_deposits.sbn create mode 100644 tests/data/remote/wofe/wofe_deposits.sbx create mode 100644 tests/data/remote/wofe/wofe_deposits.shp create mode 100644 tests/data/remote/wofe/wofe_deposits.shx create mode 100644 tests/data/remote/wofe/wofe_deposits.xml delete mode 100644 tests/data/remote/wofe/wofe_ev_nan.tfw delete mode 100644 tests/data/remote/wofe/wofe_ev_nan.tif delete mode 100644 tests/data/remote/wofe/wofe_ev_nan.tif.aux.xml delete mode 100644 tests/data/remote/wofe/wofe_ev_nan.tif.ovr delete mode 100644 tests/data/remote/wofe/wofe_ev_nan.tif.xml create mode 100644 tests/data/remote/wofe/wofe_evidence_raster.tif create mode 100644 tests/prediction/weights_of_evidence_test.py diff --git a/eis_toolkit/prediction/weights_of_evidence.py b/eis_toolkit/prediction/weights_of_evidence.py index 0a3c3806..3db93db5 100644 --- a/eis_toolkit/prediction/weights_of_evidence.py +++ b/eis_toolkit/prediction/weights_of_evidence.py @@ -10,11 +10,52 @@ from eis_toolkit import exceptions from eis_toolkit.vector_processing.rasterize_vector import rasterize_vector - -def _read_and_preprocess_evidence(raster: rasterio.io.DatasetReader, nodata: Optional[Number] = None) -> np.ndarray: +CLASS_COLUMN = "Class" +PIXEL_COUNT_COLUMN = "Pixel count" +DEPOSIT_COUNT_COLUMN = "Deposit count" +WEIGHT_PLUS_COLUMN = "W+" +WEIGHT_S_PLUS_COLUMN = "S_W+" +WEIGHT_MINUS_COLUMN = "W-" +WEIGHT_S_MINUS_COLUMN = "S_W-" +CONTRAST_COLUMN = "Contrast" +S_CONTRAST_COLUMN = "S_Contrast" +STUDENTIZED_CONTRAST_COLUMN = "Studentized contrast" +GENERALIZED_CLASS_COLUMN = "Generalized class" +GENERALIZED_WEIGHT_PLUS_COLUMN = "Generalized W+" +GENERALIZED_S_WEIGHT_PLUS_COLUMN = "Generalized S_W+" + +VALID_DF_COLUMNS = [ + CLASS_COLUMN, + PIXEL_COUNT_COLUMN, + DEPOSIT_COUNT_COLUMN, + WEIGHT_PLUS_COLUMN, + WEIGHT_S_PLUS_COLUMN, + WEIGHT_MINUS_COLUMN, + WEIGHT_S_MINUS_COLUMN, + CONTRAST_COLUMN, + S_CONTRAST_COLUMN, + STUDENTIZED_CONTRAST_COLUMN, + GENERALIZED_CLASS_COLUMN, + GENERALIZED_WEIGHT_PLUS_COLUMN, + GENERALIZED_S_WEIGHT_PLUS_COLUMN, +] + +DEFAULT_METRICS_UNIQUE = [CLASS_COLUMN, WEIGHT_PLUS_COLUMN, WEIGHT_S_PLUS_COLUMN] +DEFAULT_METRICS_CUMULATIVE = [ + CLASS_COLUMN, + WEIGHT_PLUS_COLUMN, + WEIGHT_S_PLUS_COLUMN, + GENERALIZED_WEIGHT_PLUS_COLUMN, + GENERALIZED_S_WEIGHT_PLUS_COLUMN, +] + + +def _read_and_preprocess_evidence( + raster: rasterio.io.DatasetReader, nodata: Optional[Number] = None, band: int = 1 +) -> np.ndarray: """Read raster data and handle NoData values.""" - array = np.array(raster.read(1), dtype=np.float32) + array = np.array(raster.read(band), dtype=np.float32) if nodata is not None: array[array == nodata] = np.nan @@ -24,19 +65,16 @@ def _read_and_preprocess_evidence(raster: rasterio.io.DatasetReader, nodata: Opt return array -def _calculate_metrics_for_class(deposits: np.ndarray, evidence: np.ndarray) -> tuple: +def _calculate_metrics_for_class( + deposits: np.ndarray, evidence: np.ndarray +) -> Tuple[float, float, float, float, float, float, float, float, float, float, float]: """Calculate weights/metrics for given data.""" A = np.sum(np.logical_and(deposits == 1, evidence == 1)) B = np.sum(np.logical_and(deposits == 1, evidence == 0)) C = np.sum(np.logical_and(deposits == 0, evidence == 1)) D = np.sum(np.logical_and(deposits == 0, evidence == 0)) - if A + B == 0: - raise Exception("No deposits") - if C + D == 0: - raise Exception("All included cells have deposits") - - if A == 0: + if A == 0 or C + D == 0: return A, B, C, D, 0, 0, 0, 0, 0, 0, 0 p_A_nominator = A @@ -86,65 +124,68 @@ def _cumulative_weights(deposits: np.ndarray, evidence: np.ndarray, ascending: b } -def _reclassify_by_studentized_contrast(df: pd.DataFrame, studentized_contrast_threshold: Number) -> None: - """Create generalized classes based on the studentized contrast threhsold value.""" - index = df.idxmax()["Contrast"] +def _generalized_classes(df: pd.DataFrame, studentized_contrast_threshold: Number) -> pd.DataFrame: + """Create generalized classes based on contrast and studentized contrast threhsold value.""" + gen_df = df.copy() + index = gen_df.idxmax()[CONTRAST_COLUMN] - if df.loc[index, "Studentized contrast"] < studentized_contrast_threshold or index == len(df.index) - 1: + if ( + gen_df.loc[index, STUDENTIZED_CONTRAST_COLUMN] < studentized_contrast_threshold + or index == len(gen_df.index) - 1 + ): raise exceptions.ClassificationFailedException( "Failed to create generalized classes with given studentized contrast treshold ({})".format( - df.loc[index, "Studentized contrast"] + gen_df.loc[index, STUDENTIZED_CONTRAST_COLUMN] ) ) - df["Generalized class"] = 1 + gen_df[GENERALIZED_CLASS_COLUMN] = 1 for i in range(0, index + 1): - df.loc[i, "Generalized class"] = 2 + gen_df.loc[i, GENERALIZED_CLASS_COLUMN] = 2 + return gen_df -def _calculate_generalized_weights(df: pd.DataFrame, deposits) -> None: - """ - Calculate generalized weights. - Implementation for generalized weights that uses the SAME logic than the original implementation. - """ +def _calculate_generalized_weights(df: pd.DataFrame, deposits) -> pd.DataFrame: + """Calculate generalized weights.for cumulative methods.""" + gen_df = df.copy() total_deposits = np.sum(deposits == 1) total_no_deposits = deposits.size - total_deposits # Class 2 - class_2_max_index = df.idxmax()["Contrast"] - class_2_count = df.loc[class_2_max_index, "Pixel count"] - class_2_point_count = df.loc[class_2_max_index, "Deposit count"] + class_2_max_index = gen_df.idxmax()[CONTRAST_COLUMN] + class_2_count = gen_df.loc[class_2_max_index, PIXEL_COUNT_COLUMN] + class_2_point_count = gen_df.loc[class_2_max_index, DEPOSIT_COUNT_COLUMN] class_2_w_gen = np.log(class_2_point_count / total_deposits) - np.log( (class_2_count - class_2_point_count) / total_no_deposits ) clas_2_s_wpls_gen = np.sqrt((1 / class_2_point_count) + (1 / (class_2_count - class_2_point_count))) - df["Generalized W+"] = round(class_2_w_gen, 4) - df["Generalized S_W+"] = round(clas_2_s_wpls_gen, 4) + gen_df[GENERALIZED_WEIGHT_PLUS_COLUMN] = round(class_2_w_gen, 4) + gen_df[GENERALIZED_S_WEIGHT_PLUS_COLUMN] = round(clas_2_s_wpls_gen, 4) # Class 1 - class_1_count = df.loc[len(df.index) - 1, "Pixel count"] - class_2_count - class_1_point_count = df.loc[len(df.index) - 1, "Deposit count"] - class_2_point_count + class_1_count = gen_df.loc[len(gen_df.index) - 1, PIXEL_COUNT_COLUMN] - class_2_count + class_1_point_count = gen_df.loc[len(gen_df.index) - 1, DEPOSIT_COUNT_COLUMN] - class_2_point_count class_1_w_gen = np.log(class_1_point_count / total_deposits) - np.log( (class_1_count - class_1_point_count) / total_no_deposits ) clas_1_s_wpls_gen = np.sqrt((1 / class_1_point_count) + (1 / (class_1_count - class_1_point_count))) - df.loc[df["Generalized class"] == 1, "Generalized W+"] = round(class_1_w_gen, 4) - df.loc[df["Generalized class"] == 1, "Generalized S_W+"] = round(clas_1_s_wpls_gen, 4) + gen_df.loc[gen_df[GENERALIZED_CLASS_COLUMN] == 1, GENERALIZED_WEIGHT_PLUS_COLUMN] = round(class_1_w_gen, 4) + gen_df.loc[gen_df[GENERALIZED_CLASS_COLUMN] == 1, GENERALIZED_S_WEIGHT_PLUS_COLUMN] = round(clas_1_s_wpls_gen, 4) + + return gen_df -def _generate_rasters_from_metrics( - evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str] = ["Class", "W+", "S_W+"] -) -> dict: +def _generate_rasters_from_metrics(evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str]) -> dict: """Generate rasters for defined metrics based.""" raster_dict = {} for metric in metrics_to_include: raster = np.full(evidence.shape, np.nan) for _, row in df.iterrows(): - mask = np.isin(evidence, row["Class"]) + mask = np.isin(evidence, row[CLASS_COLUMN]) raster[mask] = row[metric] raster_dict[metric] = raster return raster_dict @@ -156,8 +197,8 @@ def weights_of_evidence( deposits: gpd.GeoDataFrame, raster_nodata: Optional[Number] = None, weights_type: Literal["unique", "ascending", "descending"] = "unique", - studentized_contrast_threshold: Number = 2, - rasters_to_generate: Sequence[str] = ["Class", "W+", "S_W+"], + studentized_contrast_threshold: Number = 1, + rasters_to_generate: Optional[Sequence[str]] = None, ) -> Tuple[pd.DataFrame, dict, dict]: """ Calculate weights of spatial associations. @@ -171,37 +212,32 @@ def weights_of_evidence( 'descending' for cumulative descending weights. Defaults to 'unique'. studentized_contrast_threshold: Studentized contrast threshold value used to reclassify all classes. Reclassification is used when creating generalized rasters with cumulative weight type selection. - Not needed if weights_type is 'unique'. Defaults to 2. + Not needed if weights_type is 'unique'. Defaults to 1. rasters_to_generate: Rasters to generate from the computed weight metrics. All column names in the produced weights_df are valid choices. Defaults to ["Class", "W+", "S_W+] for "unique" weights_type and ["Class", "W+", "S_W+", "Generalized W+", "Generalized S_W+"] for the cumulative weight types. Returns: - Dataframe with weights of spatial association between the input rasters. - Dictionary of output raster arrays. + Dataframe with weights of spatial association between the input data. + Dictionary of rasters for specified metrics. Raster metadata. """ - out_df_col_names = [ - "Class", - "Pixel count", - "Deposit count", - "W+", - "S_W+", - "W-", - "S_W-", - "Contrast", - "S_Contrast", - "Studentized contrast", - ] - if rasters_to_generate is not None and not all(col_name in rasters_to_generate for col_name in out_df_col_names): - raise exceptions.InvalidColumnException("Rasters to generate list contains metrics / column names.") - - metrics_to_rasters = rasters_to_generate - if weights_type != "unique" and rasters_to_generate == ["Class", "W+", "S_W+"]: - metrics_to_rasters += ["Generalized W+", "Generalized S_W+"] - - # 1. Data preprocessing + + if rasters_to_generate is None: + if weights_type == "unique": + metrics_to_rasters = DEFAULT_METRICS_UNIQUE + else: + metrics_to_rasters = DEFAULT_METRICS_CUMULATIVE + else: + for col_name in rasters_to_generate: + if col_name not in VALID_DF_COLUMNS: + raise exceptions.InvalidColumnException( + f"Rasters to generate contains invalid metric / column name: {col_name}." + ) + metrics_to_rasters = rasters_to_generate.copy() + + # 1. Preprocess data evidence_array = _read_and_preprocess_evidence(evidential_raster, raster_nodata) raster_meta = evidential_raster.meta @@ -223,33 +259,33 @@ def weights_of_evidence( elif weights_type == "descending": wofe_weights = _cumulative_weights(masked_deposit_array, masked_evidence_array, ascending=False) - # 3. Create dataframe based on calculated metrics + # 3. Create DataFrame based on calculated metrics df_entries = [] for cls, metrics in wofe_weights.items(): metrics = [round(metric, 4) if isinstance(metric, np.floating) else metric for metric in metrics] A, _, C, _, w_plus, s_w_plus, w_minus, s_w_minus, contrast, s_contrast, studentized_contrast = metrics df_entries.append( { - "Class": cls, - "Pixel count": A + C, - "Deposit count": A, - "W+": w_plus, - "S_W+": s_w_plus, - "W-": w_minus, - "S_W-": s_w_minus, - "Contrast": contrast, - "S_Contrast": s_contrast, - "Studentized contrast": studentized_contrast, + CLASS_COLUMN: cls, + PIXEL_COUNT_COLUMN: A + C, + DEPOSIT_COUNT_COLUMN: A, + WEIGHT_PLUS_COLUMN: w_plus, + WEIGHT_S_PLUS_COLUMN: s_w_plus, + WEIGHT_MINUS_COLUMN: w_minus, + WEIGHT_S_MINUS_COLUMN: s_w_minus, + CONTRAST_COLUMN: contrast, + S_CONTRAST_COLUMN: s_contrast, + STUDENTIZED_CONTRAST_COLUMN: studentized_contrast, } ) weights_df = pd.DataFrame(df_entries) - # 4. If we use cumulative weights type, reclassify and calculate generalized weights + # 4. If we use cumulative weights type, calculate generalized classes and weights if weights_type != "unique": - _reclassify_by_studentized_contrast(weights_df, studentized_contrast_threshold) - _calculate_generalized_weights(weights_df, masked_deposit_array) + weights_df = _generalized_classes(weights_df, studentized_contrast_threshold) + weights_df = _calculate_generalized_weights(weights_df, masked_deposit_array) - # 5. After the wofe_weights computation in the weights_of_evidence function + # 5. Generate rasters for desired metrics raster_dict = _generate_rasters_from_metrics(evidence_array, weights_df, metrics_to_rasters) return weights_df, raster_dict, raster_meta diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb index 0ea3c1db..1e0b1aa2 100644 --- a/notebooks/weights_of_evidence.ipynb +++ b/notebooks/weights_of_evidence.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 30, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -19,21 +19,21 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "with rasterio.open(\"../tests/data/local/Int_wofe_ev_nan.tif\") as test_ev:\n", - " gdf = gpd.read_file(\"../tests/data/local/Dep1s.shp\")\n", + "with rasterio.open(\"../tests/data/remote/wofe/wofe_evidence_raster.tif\") as evidence_raster:\n", + " deposits = gpd.read_file(\"../tests/data/remote/wofe/wofe_deposits.shp\")\n", "\n", - " weights_unique, rasters_unique, _ = weights_of_evidence(test_ev, gdf, weights_type='unique')\n", - " weights_ascending, rasters_ascending, _ = weights_of_evidence(test_ev, gdf, weights_type='ascending', studentized_contrast_threshold=1)\n", - " weights_descending, rasters_descending, _ = weights_of_evidence(test_ev, gdf, weights_type='descending', studentized_contrast_threshold=1)" + " weights_unique, rasters_unique, _ = weights_of_evidence(evidence_raster, deposits, weights_type='unique')\n", + " weights_ascending, rasters_ascending, _ = weights_of_evidence(evidence_raster, deposits, weights_type='ascending', studentized_contrast_threshold=1)\n", + " weights_descending, rasters_descending, _ = weights_of_evidence(evidence_raster, deposits, weights_type='descending', studentized_contrast_threshold=1)" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -200,7 +200,7 @@ "7 0.0000 0.0000 0.0000 " ] }, - "execution_count": 32, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -212,7 +212,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -416,7 +416,7 @@ "7 -0.3994 0.3806 " ] }, - "execution_count": 33, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -428,7 +428,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -632,7 +632,7 @@ "7 -0.0501 0.2608 " ] }, - "execution_count": 34, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -644,7 +644,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -653,7 +653,7 @@ "" ] }, - "execution_count": 35, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, @@ -676,22 +676,22 @@ "axs[0, 0].set_title(\"Unique weights - Class\")\n", "clrbar = axs[0, 0].imshow(rasters_unique[\"Class\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_unique[\"Class\"], ax = axs[0, 0], transform = test_ev.transform, cmap='viridis')\n", + "show(rasters_unique[\"Class\"], ax = axs[0, 0], transform = evidence_raster.transform, cmap='viridis')\n", "\n", "axs[1, 0].set_title(\"Unique weights - W+\")\n", "clrbar = axs[1, 0].imshow(rasters_unique[\"W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_unique[\"W+\"], ax = axs[1, 0], transform = test_ev.transform, cmap='viridis')\n", + "show(rasters_unique[\"W+\"], ax = axs[1, 0], transform = evidence_raster.transform, cmap='viridis')\n", "\n", "axs[1, 1].set_title(\"Unique weights - S_W+\")\n", "clrbar = axs[1, 1].imshow(rasters_unique[\"S_W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_unique[\"S_W+\"], ax = axs[1, 1], transform = test_ev.transform, cmap='viridis')" + "show(rasters_unique[\"S_W+\"], ax = axs[1, 1], transform = evidence_raster.transform, cmap='viridis')" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -700,7 +700,7 @@ "" ] }, - "execution_count": 36, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, @@ -723,32 +723,32 @@ "axs[0, 0].set_title(\"Ascending weights - Class\")\n", "clrbar = axs[0, 0].imshow(rasters_ascending[\"Class\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_ascending[\"Class\"], ax = axs[0, 0], transform = test_ev.transform, cmap='viridis')\n", + "show(rasters_ascending[\"Class\"], ax = axs[0, 0], transform = evidence_raster.transform, cmap='viridis')\n", "\n", "axs[1, 0].set_title(\"Ascending weights - W+\")\n", "clrbar = axs[1, 0].imshow(rasters_ascending[\"W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_ascending[\"W+\"], ax = axs[1, 0], transform = test_ev.transform, cmap='viridis')\n", + "show(rasters_ascending[\"W+\"], ax = axs[1, 0], transform = evidence_raster.transform, cmap='viridis')\n", "\n", "axs[1, 1].set_title(\"Ascending weights - S_W+\")\n", "clrbar = axs[1, 1].imshow(rasters_ascending[\"S_W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_ascending[\"S_W+\"], ax = axs[1, 1], transform = test_ev.transform, cmap='viridis')\n", + "show(rasters_ascending[\"S_W+\"], ax = axs[1, 1], transform = evidence_raster.transform, cmap='viridis')\n", "\n", "axs[2, 0].set_title(\"Ascending weights - Generalized W+\")\n", "clrbar = axs[2, 0].imshow(rasters_ascending[\"Generalized W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_ascending[\"Generalized W+\"], ax = axs[2, 0], transform = test_ev.transform, cmap='viridis')\n", + "show(rasters_ascending[\"Generalized W+\"], ax = axs[2, 0], transform = evidence_raster.transform, cmap='viridis')\n", "\n", "axs[2, 1].set_title(\"Ascending weights - Generalized S_W+\")\n", "clrbar = axs[2, 1].imshow(rasters_ascending[\"Generalized S_W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_ascending[\"Generalized S_W+\"], ax = axs[2, 1], transform = test_ev.transform, cmap='viridis')\n" + "show(rasters_ascending[\"Generalized S_W+\"], ax = axs[2, 1], transform = evidence_raster.transform, cmap='viridis')\n" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -757,7 +757,7 @@ "" ] }, - "execution_count": 37, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, @@ -780,27 +780,27 @@ "axs[0, 0].set_title(\"Descending weights - Class\")\n", "clrbar = axs[0, 0].imshow(rasters_descending[\"Class\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_descending[\"Class\"], ax = axs[0, 0], transform = test_ev.transform, cmap='viridis')\n", + "show(rasters_descending[\"Class\"], ax = axs[0, 0], transform = evidence_raster.transform, cmap='viridis')\n", "\n", "axs[1, 0].set_title(\"Descending weights - W+\")\n", "clrbar = axs[1, 0].imshow(rasters_descending[\"W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_descending[\"W+\"], ax = axs[1, 0], transform = test_ev.transform, cmap='viridis')\n", + "show(rasters_descending[\"W+\"], ax = axs[1, 0], transform = evidence_raster.transform, cmap='viridis')\n", "\n", "axs[1, 1].set_title(\"Descending weights - S_W+\")\n", "clrbar = axs[1, 1].imshow(rasters_descending[\"S_W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_descending[\"S_W+\"], ax = axs[1, 1], transform = test_ev.transform, cmap='viridis')\n", + "show(rasters_descending[\"S_W+\"], ax = axs[1, 1], transform = evidence_raster.transform, cmap='viridis')\n", "\n", "axs[2, 0].set_title(\"Descending weights - Generalized W+\")\n", "clrbar = axs[2, 0].imshow(rasters_descending[\"Generalized W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_descending[\"Generalized W+\"], ax = axs[2, 0], transform = test_ev.transform, cmap='viridis')\n", + "show(rasters_descending[\"Generalized W+\"], ax = axs[2, 0], transform = evidence_raster.transform, cmap='viridis')\n", "\n", "axs[2, 1].set_title(\"Descending weights - Generalized S_W+\")\n", "clrbar = axs[2, 1].imshow(rasters_descending[\"Generalized S_W+\"], cmap='viridis')\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_descending[\"Generalized S_W+\"], ax = axs[2, 1], transform = test_ev.transform, cmap='viridis')" + "show(rasters_descending[\"Generalized S_W+\"], ax = axs[2, 1], transform = evidence_raster.transform, cmap='viridis')" ] } ], diff --git a/tests/data/remote/wofe/Merged_Ascending_.tif b/tests/data/remote/wofe/Merged_Ascending_.tif deleted file mode 100644 index 61bf99905b8eb5ec5f2c627b24c48efb6127907d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 13496 zcmeHO&r4Kc6uoa|7zKw=(y7Ie4_uTIv=~BLq~k(i7P(LtE!x(izdTfLi~a;b zX3@f3e?YZr83b^bG~!Wy+>xH{r(b7645kKQm2H` zU4D`RcNo_g*ZKUxPrayTye8n8q(L>V{p4q^sAqTD1)gDii*d%8o$t(c;O=%&=eKBw zadz()KR4dCa(u%0&AS#g`8?z2Xi%q=&m}f79MtFz#nEwCp)C$JcA$za6fAI6i$$gcv!o;j;G^V}Hy}gKaWJeH$IqyD{$Frzg|> zxZ;e>4SqlC2ZPvl$G{Gee{5J4aU2O@vc-yjt0BZ(e$$6 zpic>#>T7Z})r^6U`-#Di#shjrthtMv*fO=51?NH?#K?&aqff-9KL6KDr9If}O44*y zM{kHt^<&7?#=q&j$j82>76%N2=pp#1dbsmzAmH zr>r{e&>sN-s0)I{uCAA5zwI2U3c9!xWJ`K4NI%Q>A z<(>PUU6ZNA@$GG_fBAQPrk`U{Uasn{axtCDRp0BV<0?BFo$I)_m_6HM5%O+qJB;~r VBV;ZidxiWR2szidSJnSl - - - - 0.9995421245421245 - 2.000457875457875 - 1092 - 0 - 0 - 99|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|682 - - - - 2 - 1.8732394366197 - 1 - 0.33270455805684 - 71.52 - - - - - - 0.3373912605474065 - 0.575108733492129 - 1092 - 0 - 0 - 99|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|682 - - - - 0.57499998807907 - 0.54489435654291 - 0.33750000596046 - 0.079017326589278 - 71.52 - - - - - - 0.1150706922942465 - 0.1791293108528787 - 1092 - 0 - 0 - 99|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|682 - - - - 0.17910000681877 - 0.17098732943266 - 0.11509999632835 - 0.021293095205847 - 71.52 - - - diff --git a/tests/data/remote/wofe/Merged_Descending_.tif b/tests/data/remote/wofe/Merged_Descending_.tif deleted file mode 100644 index ad3df1ae0e08402ff4505fd0aa4520ac3509039b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 13496 zcmeHOJ8KkC7`?N*YyvKlK(et|%s>iF5G+J6g>h3Pu!RAWEi9}p#GerG2^%a-Yhh`V zM%hBdN^1)%OF{5wXyZ5IEF8fD-_3o@>`pRF?%A{Fd)#yC9Skr}SQpZtsdasQt) z|M35R_ZL==?tZ+m{c8Ee?vMBPwkN72cW2I+miUuB#o1_$M_mym^W)K+>6*6KnV6Sr zrjwn&&$aS%eQjsBe{f?ny_ybhU%S3L*t@)QWpDlPFMBBUpC6sQb@9OTS3caiIsWu; zOMxoZ4m{$MR? zG(2i-G0v(R)?|vFFmF-Aux%~VYk0Op9e7Qq%)`+Bu(>Wg?u>nqpLVRt)Yl!+L&Vr$ z!=uIp`){ay5$Of~(hd`GswW@lE5yrvIour>ttl_~Cq`y)n86)^6` zFz(4TE(YRz0vlcyfxi9u{!MKB_59&kXn7PE9#eCEFZ>x!Uud`Wo|E - - - - 0.9995421245421245 - 2.000457875457875 - 1092 - 0 - 0 - 275|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|506 - - - - 2 - 1.6478873239437 - 1 - 0.47762887205107 - 71.52 - - - - - - 0.0510672606074084 - 0.3412327453947793 - 1092 - 0 - 0 - 506|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|275 - - - - 0.34110000729561 - 0.15327746651962 - 0.051199998706579 - 0.13846461410998 - 71.52 - - - - - - 0.2311901961395265 - 0.2526098127534865 - 1092 - 0 - 0 - 506|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|275 - - - - 0.25260001420975 - 0.23873521282639 - 0.23119999468327 - 0.010221267188304 - 71.52 - - - diff --git a/tests/data/remote/wofe/Merged_Unique.tif b/tests/data/remote/wofe/Merged_Unique.tif deleted file mode 100644 index 6d50665050e86444a9aaba0b4298f7ce89756eb7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 13496 zcmeI2%}Z2a6vp5AK!t`-P>YZp5Go~T5mIfOJAs0WB-BNVXwgEVMSp?NCylj8+PMgF z*D6A&MJ;67wWwAtgP=tqv?yp*1f4sM@C!O}UhjMFTuF!Pedf&bp7%M=GhdD~Jw4`n zoO8X-6-urk=%^fpHXagO6kL+?dpSz&dd%wr?kkjCQEDIL7--kyHG^&3C-{KinA1Nz z)IWr^v+cUvpse{|8}K?KMTHfr{cQg{8Nr+jgqU%c}zsCHHz-A;H$A9`Kh)p zOLFZ|Rn)dFtsA1{=&y6@%D;at^bRjwczLkCGH`$D(~FDsEmooBPPcPq@h85t&&Bdu zV^Bzip0!4|8+2V_XTd!fah3S|YhSr_9vzvSpPf5>rh1|}f9~Y?)bz};$>TGli<{L& zS>L?Acl<9NMA7==L+c9*UnZRM#W!jz*Jf*19zK<|#9E*K#nVpD$t+yGHePw{+?%uV zzy>DA7i;;3s(0GIJnqlzEZ8?w@>ipcBi|=Z-Md-ye@;kpAIPKcX=jIRtKB!! z^f>F@oH5HxwY~C|HT}sto1N}Q&6>}hs^>Xh?R9FWIfPutyt2%fo=}5^^Oi65TQI#P z4w>avFHH}s;%LcT1-9g!gA+axB>LSY;p0TXHmPS<6{8zNOAg zi8XC`sB?B=Uu~95H4lCFvhX>Jwr`R;^JO24wzN5%o!EC@OQya(H9kEgrheAhhxJgH z`TAmNO9RsrV#{8kGPU^3_eIocS(`S;H&aay`&j%Zhn^6VW5Je8HT|q}FV=~vlXYTC zAM!(C-rtx@D9pJuOn)?vrEbZTedwW9C&w3SJy|CX)t{NNrRQh%>lU3!I9X61jW@7g3j=XtH>gT;SePM&?()3*J019qQ3 Fe*m|W39 - - - - 0.9945054945054945 - 13.00549450549451 - 1092 - 0 - 0 - 275|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|11|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|396|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|2|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|10 - - - - 13 - 2.8169014084507 - 1 - 2.0983552187565 - 71.52 - - - - - - -8.768938637041783 - 4.213939285540318 - 1092 - 0 - 0 - 43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|11|0|0|0|0|0|0|0|10|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|396|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|275|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|2 - - - - 4.2080001831055 - -0.43703965436329 - -8.7629995346069 - 2.4146011307113 - 71.52 - - - - - - 0.2933653725154234 - 100.0506318675511 - 1092 - 0 - 0 - 275|396|0|0|0|0|0|43|0|0|0|0|2|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|65 - - - - 100.00499725342 - 8.7295441580185 - 0.33899998664856 - 27.500314761149 - 71.52 - - - diff --git a/tests/data/remote/wofe/Merged_pprbs.tif b/tests/data/remote/wofe/Merged_pprbs.tif deleted file mode 100644 index 72d910fa1e69f12a5321d7dd3df7fdd7c7e71deb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 13496 zcmeI1%}Z2K7{;3uoocFxveJ*}ZP4$~5 zV@!)Nv4n|PI&QC6nY%2(uF-be0;8niI zlf^=(HN~2Wg+|k98tgb@W+iQ!gZuCO$HAbI+Cvzclt*g$puDnw+8mlU;k0a-=TJ&~-13pJ$Qw_0gFx>u7q5+QYMxUH4^n61&!v{G1_~{ZnTh>R~bS zb!GMz1#>23&0bQD)HQW9bLP)Q>{GKgYL9ECQa`MtnHxQv37H-ZGdqc;{;6{>>SXpw zovf)te^|`tjk$!yJeS0rkL1zlQjXMFhclFPdR$qmNu3;4eP+s$cpN!dxzYV{p^|wO!|_@zdjT zF4wi3IayOj>X~)OnwmZyW+yRw_Q{uZBo6C)iqA|mYo-1rotcs~d%1d~9I0Bw` zx$eb2!(yMj!dfexMVgP~*XUBsO6rTkLpI<()`SJ)1NeCUgNZ8iIX|$ z+M%G8GA(FgtVq)~jUoo>x*~zrO8aTGPV4~$LLl)l4TM1Bf$e4D6@(B!$8Ovv>!fND zFG#gypYNV~zH`pK*FHWJ^#U4y0-Bglq_x-QyxUy?lm?av84mNuAD4 zW%z_nLkjl*f;b3s0ovc;WJ1`oe>DM2?;-sVIfNC3 z$Mi0O?ed1Og7BE03AB^6pK^h5K02mvF|E}en3VtTVdzT`lwY34;Q7DOfOkeLN6xa2w7d z)PO5_$`3S#bOGy*P1WVc_Hu#wXiMGG$I*d(6;r{6+P7T$4?Q;-b8MSvkJ7dsXT0^N zJ9v5_dM(^^t~171N6Q4uq;GKFO!E&TdoBcq*xfrfo%Bpmmu{britqYod>;)zdolP) z_s7A5UGrCc3z6B52Y0sYJoC-qmA*vq27m3R-rAq) zvG1y_&V6>^P|sq_Qg`ahsMKqp?ru2ybu8Vxcz?w4{J%yhIP>?eb!UZ4mzGkcBLg@D)+u zCxJJ&n2qYwytWIt+y)=&2o#a}z+6=v__GFg|43>J|LjkwVOJ%ZU_ RHQ*MjRn2>K!&vx_{1<=5;?Mv9 diff --git a/tests/data/remote/wofe/wofe_dep_nan_.tif.aux.xml b/tests/data/remote/wofe/wofe_dep_nan_.tif.aux.xml deleted file mode 100644 index 2c0ad0e5..00000000 --- a/tests/data/remote/wofe/wofe_dep_nan_.tif.aux.xml +++ /dev/null @@ -1,17 +0,0 @@ - - - Generic - - - - THEMATIC - - 1 - 0.014652014652015 - 0 - 1 - 1 - 0.12021050801788 - - - diff --git a/tests/data/remote/wofe/wofe_dep_nan_.tif.ovr b/tests/data/remote/wofe/wofe_dep_nan_.tif.ovr deleted file mode 100644 index 127f1c89f434f53ffd1ea64e165285e56a91ea8c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 258 zcmebD)MDUZU|`^9_{YG)zzAf4Faskqm=*ysp=>@Nn+eJW>0m};vq9M)y`o5L86>tX z659#NZUCxxMq;}#Lfmi;DDDbnn*iCtNO~KWFfs4|#SQ^62jOkOPvKAS^MbG!-K32co#plsM;?=9NIi+(48tH>v_&1voHJP%zXp bFgG)Rf>dn-W4NS(AxIW3XJ7!7HIxDX$oCK> diff --git a/tests/data/remote/wofe/wofe_dep_nan_.tif.xml b/tests/data/remote/wofe/wofe_dep_nan_.tif.xml deleted file mode 100644 index 29805cfa..00000000 --- a/tests/data/remote/wofe/wofe_dep_nan_.tif.xml +++ /dev/null @@ -1,2 +0,0 @@ - -20230303105256001.0ISO 19139 Metadata Implementation SpecificationFALSEInt Training_sites.tif E:\EIS2022\Data\TestData_wofe_fns\Training_sites_int.tifClip Training_sites_int.tif "405078.132931 7498269.102178 444078.132931 7526269.102178" E:\EIS2022\Data\TestData_wofe_fns\wofe_dep_nan6.tif wofe_ev_nan.tif -1000000000 NONE NO_MAINTAIN_EXTENTwofe_dep_nan6.tiffile://E:\EIS2022\Data\TestData_wofe_fns\wofe_dep_nan6.tifLocal Area Network002405078.132931444078.1329317498269.1021787526269.1021781ProjectedGCS_EUREF_FINLinear Unit: Meter (1.000000)EUREF_FIN_TM35FIN<ProjectedCoordinateSystem xsi:type='typens:ProjectedCoordinateSystem' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:typens='http://www.esri.com/schemas/ArcGIS/10.6'><WKT>PROJCS[&quot;EUREF_FIN_TM35FIN&quot;,GEOGCS[&quot;GCS_EUREF_FIN&quot;,DATUM[&quot;D_ETRS_1989&quot;,SPHEROID[&quot;GRS_1980&quot;,6378137.0,298.257222101]],PRIMEM[&quot;Greenwich&quot;,0.0],UNIT[&quot;Degree&quot;,0.0174532925199433]],PROJECTION[&quot;Transverse_Mercator&quot;],PARAMETER[&quot;False_Easting&quot;,500000.0],PARAMETER[&quot;False_Northing&quot;,0.0],PARAMETER[&quot;Central_Meridian&quot;,27.0],PARAMETER[&quot;Scale_Factor&quot;,0.9996],PARAMETER[&quot;Latitude_Of_Origin&quot;,0.0],UNIT[&quot;Meter&quot;,1.0],AUTHORITY[&quot;EPSG&quot;,3067]]</WKT><XOrigin>-5120900</XOrigin><YOrigin>-9998100</YOrigin><XYScale>450445547.3910538</XYScale><ZOrigin>-100000</ZOrigin><ZScale>10000</ZScale><MOrigin>-100000</MOrigin><MScale>10000</MScale><XYTolerance>0.001</XYTolerance><ZTolerance>0.001</ZTolerance><MTolerance>0.001</MTolerance><HighPrecision>true</HighPrecision><WKID>102139</WKID><LatestWKID>3067</LatestWKID></ProjectedCoordinateSystem>8FALSELZW1TIFFTRUEdiscreteunsigned integer-1e+0920230303105329002023030310532900 Version 6.2 (Build 9200) ; Esri ArcGIS 10.6.1.9270wofe_dep_nan6.tif124.74497025.68519267.84576367.584674Raster DatasetdatasetEPSG8.1(9.2.0)210405078.132931 7498269.102178405078.132931 7526269.102178444078.132931 7526269.102178444078.132931 7498269.102178424578.132931 7512269.102178391000.000000281000.000000wofe_dep_nan6.tif.vatTable2OIDOIDOID400Internal feature number.EsriSequential unique whole numbers that are automatically generated.ValueValueInteger10100CountCountDouble1900Band_11.0000000.000000820230303 diff --git a/tests/data/remote/wofe/wofe_dep_nan_.tif.vat.cpg b/tests/data/remote/wofe/wofe_deposits.cpg similarity index 100% rename from tests/data/remote/wofe/wofe_dep_nan_.tif.vat.cpg rename to tests/data/remote/wofe/wofe_deposits.cpg diff --git a/tests/data/remote/wofe/wofe_deposits.dbf b/tests/data/remote/wofe/wofe_deposits.dbf new file mode 100644 index 0000000000000000000000000000000000000000..de1da7b1654b19b32df23db863ef0d318f796c58 GIT binary patch literal 738 zcmZ{izY4-I5XJ){h#=_d)WHYHwJ}ZiBDjcydk0%e7hA;5r}0fSSDQchdBbt}?w7mt zqqFB?vlc?U#O{-SW9YlvqpNM>WYf~7AliFZSJ%F7{`4>B!?7HBc)x6h>I-mx9?Z7o zDw#rMQDcA8LSN^E>fJx&yhUYTpFYi;!BG&92&#;-t{Mg5Bgh-NkXVg#butiD)-Xm*z`t{|GjWxneIAk9^u X)sPLOc^JGHy@51ey=a3Nkmd&fd%iVi literal 0 HcmV?d00001 diff --git a/tests/data/remote/wofe/wofe_deposits.sbx b/tests/data/remote/wofe/wofe_deposits.sbx new file mode 100644 index 0000000000000000000000000000000000000000..f0541936f91c0cd4f3e7f3826db171019a0cf12f GIT binary patch literal 124 zcmZQzQ0Myp|6c(ECa?nv2{=kT$moz4NOO#t^TVx6bcUl;*$N1MO9qIKsST@$5m1x| Oh@F5~0EokY*Z=^0co8}P literal 0 HcmV?d00001 diff --git a/tests/data/remote/wofe/wofe_deposits.shp b/tests/data/remote/wofe/wofe_deposits.shp new file mode 100644 index 0000000000000000000000000000000000000000..74cb43a088981d9e34b8b53987f3255aa97807f7 GIT binary patch literal 548 zcmZQzQ0HR63K)f6Ff%YP0_D;K!sXmzupB?K9L&r&^T2Wf$a1jw1;sZ2;u~!| literal 0 HcmV?d00001 diff --git a/tests/data/remote/wofe/wofe_deposits.shx b/tests/data/remote/wofe/wofe_deposits.shx new file mode 100644 index 0000000000000000000000000000000000000000..00f5cc69738547160d9c25076552a162bfe4b435 GIT binary patch literal 228 zcmZQzQ0HR64vJndGcYg$<fEXKaaa#I7Ah)CkA} v+2a7E{h)LVl+J?E6;QejN>72(i=gxdD7_C#pMlc1p!5qU{S87hvVdp+t9ln1 literal 0 HcmV?d00001 diff --git a/tests/data/remote/wofe/wofe_deposits.xml b/tests/data/remote/wofe/wofe_deposits.xml new file mode 100644 index 00000000..2da08739 --- /dev/null +++ b/tests/data/remote/wofe/wofe_deposits.xml @@ -0,0 +1,2 @@ + +20230816144621001.0ISO 19139 Metadata Implementation SpecificationTRUERasterToPoint wofe_dep_rst_int.tif E:\EIS2022\Data\TestData_wofe_fns\wofe_dep.shp ValueAddField wofe_dep1s TPFID LONG # # # # NULLABLE NON_REQUIRED #CalculateField wofe_dep1s TPFID !FID! PYTHON_9.3 #CalculateField wofe_dep1s TPFID !FID! PYTHON_9.3 #CalculateField wofe_dep1s TPFID !FID! PYTHON_9.3 #CalculateField wofe_dep1s TPFID !FID! PYTHON_9.3 #CalculateField wofe_dep1s TPFID !FID! PYTHON_9.3 #CalculateField wofe_dep1s TPFID !FID! PYTHON_9.3 #CalculateField wofe_dep1s TPFID !FID! PYTHON_9.3 #CalculateField wofe_dep1s Dep_ID 1 VB #CalculateField Dep1s TPFID !FID! PYTHON_9.3 #CalculateField Dep1s TPFID !FID! PYTHON_9.3 #CalculateField Dep1s TPFID !FID! PYTHON_9.3 #CalculateField Dep1s TPFID !FID! PYTHON_9.3 #CalculateField Dep1s TPFID !FID! PYTHON_9.3 #CalculateField Dep1s TPFID !FID! PYTHON_9.3 #CalculateField Dep1s TPFID !FID! PYTHON_9.3 # diff --git a/tests/data/remote/wofe/wofe_ev_nan.tfw b/tests/data/remote/wofe/wofe_ev_nan.tfw deleted file mode 100644 index 212f90bc..00000000 --- a/tests/data/remote/wofe/wofe_ev_nan.tfw +++ /dev/null @@ -1,6 +0,0 @@ -1000.0000000000 -0.0000000000 -0.0000000000 --1000.0000000000 -405578.1329310000 -7525769.1021779999 diff --git a/tests/data/remote/wofe/wofe_ev_nan.tif b/tests/data/remote/wofe/wofe_ev_nan.tif deleted file mode 100644 index 52ecf63d22628cc7d75b8d59efaffa79c1aa52ef..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4034 zcmeHKYgAKL7QP{XyaJ*is088_b#w*Dg8)&8T$39Nn0JD4AZ8-DVl)X%5`1EPp;#-T z7Oh%=>WJEQ02zx2K58ADjxER(7&`&%Jd70UiYS zM79S6XwY^C2rA2VfP8`dGq~3uaez*N`4`~c0I&zJ7cGw9ijLzT^Z1xqtx=oREH@G< znrFuJB!gOy#lRdeCtH<{!K^sUfEl$Z(P5U=U%Smw8#DqyfJr8`K3xZh6qse1R8ikf zkYMRX%!C=tYO^-YV9hX+ipb`od_=}$+t|@z_Eo+tJvKMi3T*b}>|1{qj}F?ZsPsqn z`EKL3l_w)MC!F=%M?;olvtV%eR_owcmQA!cxmdu@e**@+Mla)53PGo}z0J&Jl%O<*7$2iE{Y8@bg)q>{-jvfa+bH{m7uj+!ylu(M2EEn)(ATX8+>a|W$ zBf}YV8k5GLGMV9Yx|J%7N7*u-P>=-6jB0~vIc79rDn4dRQJd3@FbIxF5I!nHB}p(> ztpjVQ+GGZMg~<$x<+3Dt!$**2G%v9_{d%1Z{?|se&XPf^(W(tFnFh9G7ebn%)?q5H zI>k}|*a?%#jIeW<2VM+wh6Ym!7psIuZK@VT8L?sTzG8q#1!0w$5EMeS)@k{H*1HiF z-!Z$nI&ZwtL0Kt-iG;0eSakXbYudPN)hX1KR~N+)cgB&{y9V#&Ps@wPB$b*|%CLR& z7E75&n)Hze1*y`?+Xd8M(&*p$ker;e;~>(g?sz%8DQFk>UvjsDTfP*3A)i)W)w%qf z>V!gm{}taOfrJk#rtE26293{bYNl6Q zF@((w@Z7ZK^Y-+W$*kZzb>>#%@(Is#!?ab`4XYQN`)A*(b-Ny|QJ%lMg8%JdW94~P z>fT#*_j*D89^Mj9amQ@CP?RTKQZ+0oW>8IG-1VbOf-3F(BBYY!^IaNA>ZAC*sj5jy|E_(JgN}#b}os!Gf(b&DQ8yV&^PH-J5O(O*DdWW zF73j+s;Q2G>zprTYkek(bvctSyOS4ovqd$U>)(pHQoZAM2NX|A@Sf=%{Qd6xXAee? z(KxqqcGVOSkMFv@F0eMIW>d)AzYKOVuYCBpySp|$JgPgM(o-1y-APT`j096Lfqj|o zajhmodgBnie(aMe)9X!ge9W9Of;&f=cYhMfD-BK~3rlaX9J|8E--Dg@k=%UV{BiIQR}#LOCqCOd*7S#F znNp=`{e)0momfsRTY625e}>9omw@4R_tUP`wGF#ZR(gp6K7-dWWB1GM}~Vlr(91 z$Jb3sd+&WCIulV}@$XM3J6-tW-uYuI9}NciUN#04PW=9HKpms@@xg~Nbv;Bc^oO4O zFn+@mqEO!WBtK2r+)K>GT6^_sLAjj+FA7T^ zJR1tCd-8m!@ZsQ4yCZJB$kQQKLBO?hTsMe9onu>w`1UOCjUs^?q6l$nuO7ciWbi~< zVn%g1PRbJP7&Aw~ckSRz-z+K_H>XAE-jPM!BDykxt{-W|nxHSTF-s6#L$+Uht9F5Q?^(^SkA!-Y(uj<0@*$-{NR< z#3d2jmK*IZF24;01i8IdK>h&R6wq9NZ3?IbV4DK!2iT&3jsYd)NqDV*PI=kBs+O7PNmRnWxv?~j?}!r03ocx!2kdN diff --git a/tests/data/remote/wofe/wofe_ev_nan.tif.aux.xml b/tests/data/remote/wofe/wofe_ev_nan.tif.aux.xml deleted file mode 100644 index 442a04e3..00000000 --- a/tests/data/remote/wofe/wofe_ev_nan.tif.aux.xml +++ /dev/null @@ -1,30 +0,0 @@ - - - Generic - - - Band_1 - - - 1 - 13 - 256 - 1 - 0 - 275|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|11|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|396|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|43|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|2|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|10 - - - - Band_1 - ATHEMATIC - 4.408739617190325 - 13 - 2.8169014084507 - 1 - 1 - 1 - 2.0983552187565 - 71.52 - - - diff --git a/tests/data/remote/wofe/wofe_ev_nan.tif.ovr b/tests/data/remote/wofe/wofe_ev_nan.tif.ovr deleted file mode 100644 index 208510ab39da908a8622df9d0399c23439377833..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 474 zcmebD)MDUZU|`^9_{YG)zzAf4Faskqm=*ysp=>@Nn+eKR0J52(Y>;j?C>x|#6p1Z^ z#I{9ZJ3-kEK=sZ@Y!^m|8_og6U7>6qprOG~HOxTq#wAP)JV5#o5QBiOp#cmqRLpsM z<05a9fe7mb^RD@Mi8l|}`ph{PIOD`j9>rcJRmbEUt>=$hE_?_qijU_$e)?-&%5|l@ zU*5xa<#4@JvF_Cao5X!w!>ixbDF45HZ@%&QC5*_pdE?#Gl;X^wrc}UOG$p`MlQ$wmZI7 z;%haHfA#tE<_Dj0B7VpIQ2Fn%c+TI=^YyC_-`e{p+H7s(rCayE)i3x~{h>F?qt$A{ X|G252*4wH>yhl2@U>|#?)tP<(L2`pq diff --git a/tests/data/remote/wofe/wofe_ev_nan.tif.xml b/tests/data/remote/wofe/wofe_ev_nan.tif.xml deleted file mode 100644 index 36123d17..00000000 --- a/tests/data/remote/wofe/wofe_ev_nan.tif.xml +++ /dev/null @@ -1,2 +0,0 @@ - -20230303100923001.0ISO 19139 Metadata Implementation SpecificationFALSEwofe_ev_nan.tiffile://E:\EIS2022\Data\TestData_wofe_fns\wofe_ev_nan.tifLocal Area Network002405078.132931444078.1329317498269.1021787526269.1021781ProjectedGCS_EUREF_FINLinear Unit: Meter (1.000000)EUREF_FIN_TM35FIN<ProjectedCoordinateSystem xsi:type='typens:ProjectedCoordinateSystem' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:typens='http://www.esri.com/schemas/ArcGIS/10.6'><WKT>PROJCS[&quot;EUREF_FIN_TM35FIN&quot;,GEOGCS[&quot;GCS_EUREF_FIN&quot;,DATUM[&quot;D_ETRS_1989&quot;,SPHEROID[&quot;GRS_1980&quot;,6378137.0,298.257222101]],PRIMEM[&quot;Greenwich&quot;,0.0],UNIT[&quot;Degree&quot;,0.0174532925199433]],PROJECTION[&quot;Transverse_Mercator&quot;],PARAMETER[&quot;False_Easting&quot;,500000.0],PARAMETER[&quot;False_Northing&quot;,0.0],PARAMETER[&quot;Central_Meridian&quot;,27.0],PARAMETER[&quot;Scale_Factor&quot;,0.9996],PARAMETER[&quot;Latitude_Of_Origin&quot;,0.0],UNIT[&quot;Meter&quot;,1.0],AUTHORITY[&quot;EPSG&quot;,3067]]</WKT><XOrigin>-5120900</XOrigin><YOrigin>-9998100</YOrigin><XYScale>450445547.3910538</XYScale><ZOrigin>-100000</ZOrigin><ZScale>10000</ZScale><MOrigin>-100000</MOrigin><MScale>10000</MScale><XYTolerance>0.001</XYTolerance><ZTolerance>0.001</ZTolerance><MTolerance>0.001</MTolerance><HighPrecision>true</HighPrecision><WKID>102139</WKID><LatestWKID>3067</LatestWKID></ProjectedCoordinateSystem>32FALSELZW1TIFFTRUEcontinuousfloating point-1e+09Clip wofe_ev_rst_int.tif "406837.552257628 7499299.44095142 443548.563179649 7525651.99365652" E:\EIS2022\Data\TestData_wofe_fns\wofe_ev_nan.tif Extent_NaN -1000000000 ClippingGeometry NO_MAINTAIN_EXTENT20230303100923002023030310092300 Version 6.2 (Build 9200) ; Esri ArcGIS 10.6.1.9270wofe_ev_nan.tif124.74497025.68519267.84576367.584674Raster DatasetdatasetEPSG8.1(9.2.0)210405078.132931 7498269.102178405078.132931 7526269.102178444078.132931 7526269.102178444078.132931 7498269.102178424578.132931 7512269.102178391000.000000281000.000000Band_113.0000001.0000003220230303 diff --git a/tests/data/remote/wofe/wofe_evidence_raster.tif b/tests/data/remote/wofe/wofe_evidence_raster.tif new file mode 100644 index 0000000000000000000000000000000000000000..03a40bb04c75347cf3e89334e4447dbcc134f3c9 GIT binary patch literal 2083 zcmb7E3rtgI6#m-+qO=2nGBRW|SIvAB=xr(Ob)eMt7B6z!+TM0JZ0eO>rP>E;i_8rp z_(+YBO~*qs=dzh94?froaK*1I1a{*lE9iWO7O@H03OZB_+#^O4qL7;&{F31(&Mm?^!s0odQA|+C2 zEA#&gLTGtLs8rG3atD;CEI6e%SWrxkRpNHLt<2-HS)o7wsZ&&`bK4y77(tJlVVo7V zlG4gb+@L1}I$U7zx^2!?Fs9RM3zUXp&#|gDzB-C6$OVu@uFyEQus2)fV7NiqL9`5z0+FJ!=`ahp~{1yM*?-+z3pr&?`us z!u7?7nzq9jPJ6s?uZU183Os>AFK{$2x3@G%dOog%H;*{5k9r-uTWB#Fx z*!qI~J3EEnn9)sS6NUNrRpfu#-}n%$kKe1^Q+4~%JaUc{Z8ELV9qH0En|2lWrN?H* zFVP<=xYZEddt>VB8<#o_rHOY2Qk&ndk``NU?(%dJ`;-2>9q}5E^;6s09(&7%>eIyW z`rW8=9>>_ z*AEWq)U7|3rL?xV-dVR-7Nb?4=q}mQBA2~CTvLX9HFBk*dCSiae;Yokd0_eYS1XhJ z-Y3Uqaqb!`I##OGrHM^M{53H zV$Doqu&ynA@%h9)DS5tbG*^3p&%>8os81&i7x|>oc(LALert$d!z>-DZ*vq6^ZUxp S!}X) Date: Thu, 5 Oct 2023 08:14:41 +0300 Subject: [PATCH 24/31] Add categorical weights, adjust documentation --- eis_toolkit/prediction/weights_of_evidence.py | 93 ++++++- notebooks/weights_of_evidence.ipynb | 248 +++++++++++++++++- 2 files changed, 317 insertions(+), 24 deletions(-) diff --git a/eis_toolkit/prediction/weights_of_evidence.py b/eis_toolkit/prediction/weights_of_evidence.py index 3db93db5..c53967ec 100644 --- a/eis_toolkit/prediction/weights_of_evidence.py +++ b/eis_toolkit/prediction/weights_of_evidence.py @@ -74,6 +74,7 @@ def _calculate_metrics_for_class( C = np.sum(np.logical_and(deposits == 0, evidence == 1)) D = np.sum(np.logical_and(deposits == 0, evidence == 0)) + # If data has no deposits or every evidence pixel has a deposit if A == 0 or C + D == 0: return A, B, C, D, 0, 0, 0, 0, 0, 0, 0 @@ -124,7 +125,59 @@ def _cumulative_weights(deposits: np.ndarray, evidence: np.ndarray, ascending: b } -def _generalized_classes(df: pd.DataFrame, studentized_contrast_threshold: Number) -> pd.DataFrame: +def _generalized_classes_categorical(df: pd.DataFrame, studentized_contrast_threshold: Number) -> pd.DataFrame: + gen_df = df.copy() + gen_df[GENERALIZED_CLASS_COLUMN] = gen_df[CLASS_COLUMN] + + reclassified = False + for i in range(0, len(gen_df.index)): + if abs(gen_df.loc[i, STUDENTIZED_CONTRAST_COLUMN]) < studentized_contrast_threshold: + gen_df.loc[i, GENERALIZED_CLASS_COLUMN] = 99 + reclassified = True + + if not reclassified: + raise exceptions.ClassificationFailedException( + "Failed to create generalized classes with given studentized contrast treshold ({})".format( + studentized_contrast_threshold + ) + ) + + gen_df = gen_df.sort_values(by=GENERALIZED_CLASS_COLUMN, ascending=True) + + return gen_df + + +def _calculate_generalized_weights_categorical(df: pd.DataFrame, deposits) -> pd.DataFrame: + gen_df = df.copy() + total_deposits = np.sum(deposits == 1) + total_no_deposits = deposits.size - total_deposits + + # Class 99 (gen class) + class_99_count = 0 + class_99_point_count = 0 + + for i in range(0, len(gen_df.index)): + if gen_df.loc[i, GENERALIZED_CLASS_COLUMN] == 99: + # class_99_count = max(gen_df.loc[i, PIXEL_COUNT_COLUMN], class_99_count) + # class_99_point_count = max(gen_df.loc[i, DEPOSIT_COUNT_COLUMN], class_99_point_count) + class_99_count += gen_df.loc[i, PIXEL_COUNT_COLUMN] + class_99_point_count += gen_df.loc[i, DEPOSIT_COUNT_COLUMN] + + class_99_w_gen = np.log(class_99_point_count / total_deposits) - np.log( + (class_99_count - class_99_point_count) / total_no_deposits + ) + clas_99_s_wpls_gen = np.sqrt((1 / class_99_point_count) + (1 / (class_99_count - class_99_point_count))) + + gen_df[GENERALIZED_WEIGHT_PLUS_COLUMN] = gen_df[WEIGHT_PLUS_COLUMN] + gen_df[GENERALIZED_S_WEIGHT_PLUS_COLUMN] = gen_df[WEIGHT_S_PLUS_COLUMN] + + gen_df.loc[gen_df[GENERALIZED_CLASS_COLUMN] == 99, GENERALIZED_WEIGHT_PLUS_COLUMN] = round(class_99_w_gen, 4) + gen_df.loc[gen_df[GENERALIZED_CLASS_COLUMN] == 99, GENERALIZED_S_WEIGHT_PLUS_COLUMN] = round(clas_99_s_wpls_gen, 4) + + return gen_df + + +def _generalized_classes_cumulative(df: pd.DataFrame, studentized_contrast_threshold: Number) -> pd.DataFrame: """Create generalized classes based on contrast and studentized contrast threhsold value.""" gen_df = df.copy() index = gen_df.idxmax()[CONTRAST_COLUMN] @@ -134,8 +187,8 @@ def _generalized_classes(df: pd.DataFrame, studentized_contrast_threshold: Numbe or index == len(gen_df.index) - 1 ): raise exceptions.ClassificationFailedException( - "Failed to create generalized classes with given studentized contrast treshold ({})".format( - gen_df.loc[index, STUDENTIZED_CONTRAST_COLUMN] + "Failed to create generalized classes with given studentized contrast treshold ({} < {})".format( + gen_df.loc[index, STUDENTIZED_CONTRAST_COLUMN], studentized_contrast_threshold ) ) @@ -146,7 +199,7 @@ def _generalized_classes(df: pd.DataFrame, studentized_contrast_threshold: Numbe return gen_df -def _calculate_generalized_weights(df: pd.DataFrame, deposits) -> pd.DataFrame: +def _calculate_generalized_weights_cumulative(df: pd.DataFrame, deposits) -> pd.DataFrame: """Calculate generalized weights.for cumulative methods.""" gen_df = df.copy() total_deposits = np.sum(deposits == 1) @@ -196,7 +249,7 @@ def weights_of_evidence( evidential_raster: rasterio.io.DatasetReader, deposits: gpd.GeoDataFrame, raster_nodata: Optional[Number] = None, - weights_type: Literal["unique", "ascending", "descending"] = "unique", + weights_type: Literal["unique", "categorical", "ascending", "descending"] = "unique", studentized_contrast_threshold: Number = 1, rasters_to_generate: Optional[Sequence[str]] = None, ) -> Tuple[pd.DataFrame, dict, dict]: @@ -208,11 +261,16 @@ def weights_of_evidence( deposits: Vector data representing the mineral deposits or occurences point data. raster_nodata: If nodata value of raster is wanted to specify manually. Optional parameter, defaults to None (nodata from raster metadata is used). - weights_type: Accepted values are 'unique' for unique weights, 'ascending' for cumulative ascending weights, - 'descending' for cumulative descending weights. Defaults to 'unique'. - studentized_contrast_threshold: Studentized contrast threshold value used to reclassify all classes. - Reclassification is used when creating generalized rasters with cumulative weight type selection. - Not needed if weights_type is 'unique'. Defaults to 1. + weights_type: Accepted values are 'unique', 'categorical', 'ascending' and 'descending'. + Unique weights does not create generalized classes and does not use a studentized contrast threshold value + while categorical, cumulative ascending and cumulative descending do. Categorical weights are calculated so + that all classes with studentized contrast below the defined threshold are grouped into one generalized + class. Cumulative ascending and descending weights find the class with max contrast and group classes + above/below into generalized classes. Generalized weights are also calculated for generalized classes. + studentized_contrast_threshold: Studentized contrast threshold value used with 'categorical', 'ascending' and + 'descending' weight types. Used either as reclassification threshold directly (categorical) or to check + that class with max contrast has studentized contrast value at least the defined value (cumulative). + Defaults to 1. rasters_to_generate: Rasters to generate from the computed weight metrics. All column names in the produced weights_df are valid choices. Defaults to ["Class", "W+", "S_W+] for "unique" weights_type and ["Class", "W+", "S_W+", "Generalized W+", "Generalized S_W+"] @@ -252,12 +310,16 @@ def weights_of_evidence( masked_deposit_array = deposit_array[~nodata_mask] # 2. WofE calculations - if weights_type == "unique": + if weights_type == "unique" or weights_type == "categorical": wofe_weights = _unique_weights(masked_deposit_array, masked_evidence_array) elif weights_type == "ascending": wofe_weights = _cumulative_weights(masked_deposit_array, masked_evidence_array, ascending=True) elif weights_type == "descending": wofe_weights = _cumulative_weights(masked_deposit_array, masked_evidence_array, ascending=False) + else: + raise exceptions.InvalidParameterValueException( + "Expected weights_type to be one of unique, categorical, ascending or descending." + ) # 3. Create DataFrame based on calculated metrics df_entries = [] @@ -281,9 +343,12 @@ def weights_of_evidence( weights_df = pd.DataFrame(df_entries) # 4. If we use cumulative weights type, calculate generalized classes and weights - if weights_type != "unique": - weights_df = _generalized_classes(weights_df, studentized_contrast_threshold) - weights_df = _calculate_generalized_weights(weights_df, masked_deposit_array) + if weights_type == "categorical": + weights_df = _generalized_classes_categorical(weights_df, studentized_contrast_threshold) + weights_df = _calculate_generalized_weights_categorical(weights_df, masked_deposit_array) + elif weights_type == "ascending" or weights_type == "descending": + weights_df = _generalized_classes_cumulative(weights_df, studentized_contrast_threshold) + weights_df = _calculate_generalized_weights_cumulative(weights_df, masked_deposit_array) # 5. Generate rasters for desired metrics raster_dict = _generate_rasters_from_metrics(evidence_array, weights_df, metrics_to_rasters) diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb index 1e0b1aa2..e7f8c3f6 100644 --- a/notebooks/weights_of_evidence.ipynb +++ b/notebooks/weights_of_evidence.ipynb @@ -21,12 +21,24 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "108\n", + "1\n", + "16\n", + "765\n" + ] + } + ], "source": [ "with rasterio.open(\"../tests/data/remote/wofe/wofe_evidence_raster.tif\") as evidence_raster:\n", " deposits = gpd.read_file(\"../tests/data/remote/wofe/wofe_deposits.shp\")\n", "\n", " weights_unique, rasters_unique, _ = weights_of_evidence(evidence_raster, deposits, weights_type='unique')\n", + " weights_categorical, _, _ = weights_of_evidence(evidence_raster, deposits, weights_type='categorical', studentized_contrast_threshold=1)\n", " weights_ascending, rasters_ascending, _ = weights_of_evidence(evidence_raster, deposits, weights_type='ascending', studentized_contrast_threshold=1)\n", " weights_descending, rasters_descending, _ = weights_of_evidence(evidence_raster, deposits, weights_type='descending', studentized_contrast_threshold=1)" ] @@ -214,6 +226,222 @@ "cell_type": "code", "execution_count": 4, "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ClassPixel countDeposit countW+S_W+W-S_W-ContrastS_ContrastStudentized contrastGeneralized classGeneralized W+Generalized S_W+
01.027590.48100.3389-0.39940.38060.88040.50961.72751.00.48100.3389
23.03965-0.49200.45010.34090.3059-0.83290.5442-1.53063.0-0.49200.4501
610.0213.86731.4142-0.06320.26073.93051.43802.733210.03.86731.4142
12.01100.00000.00000.00000.00000.00000.00000.000099.0-0.80551.0047
35.04310.12961.0118-0.00810.26090.13771.04490.131899.0-0.80551.0047
46.0100.00000.00000.00000.00000.00000.00000.000099.0-0.80551.0047
58.04300.00000.00000.00000.00000.00000.00000.000099.0-0.80551.0047
713.01000.00000.00000.00000.00000.00000.00000.000099.0-0.80551.0047
\n", + "
" + ], + "text/plain": [ + " Class Pixel count Deposit count W+ S_W+ W- S_W- \\\n", + "0 1.0 275 9 0.4810 0.3389 -0.3994 0.3806 \n", + "2 3.0 396 5 -0.4920 0.4501 0.3409 0.3059 \n", + "6 10.0 2 1 3.8673 1.4142 -0.0632 0.2607 \n", + "1 2.0 11 0 0.0000 0.0000 0.0000 0.0000 \n", + "3 5.0 43 1 0.1296 1.0118 -0.0081 0.2609 \n", + "4 6.0 1 0 0.0000 0.0000 0.0000 0.0000 \n", + "5 8.0 43 0 0.0000 0.0000 0.0000 0.0000 \n", + "7 13.0 10 0 0.0000 0.0000 0.0000 0.0000 \n", + "\n", + " Contrast S_Contrast Studentized contrast Generalized class \\\n", + "0 0.8804 0.5096 1.7275 1.0 \n", + "2 -0.8329 0.5442 -1.5306 3.0 \n", + "6 3.9305 1.4380 2.7332 10.0 \n", + "1 0.0000 0.0000 0.0000 99.0 \n", + "3 0.1377 1.0449 0.1318 99.0 \n", + "4 0.0000 0.0000 0.0000 99.0 \n", + "5 0.0000 0.0000 0.0000 99.0 \n", + "7 0.0000 0.0000 0.0000 99.0 \n", + "\n", + " Generalized W+ Generalized S_W+ \n", + "0 0.4810 0.3389 \n", + "2 -0.4920 0.4501 \n", + "6 3.8673 1.4142 \n", + "1 -0.8055 1.0047 \n", + "3 -0.8055 1.0047 \n", + "4 -0.8055 1.0047 \n", + "5 -0.8055 1.0047 \n", + "7 -0.8055 1.0047 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Categorical weights DF\n", + "weights_categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, "outputs": [ { "data": { @@ -416,7 +644,7 @@ "7 -0.3994 0.3806 " ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -428,7 +656,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -632,7 +860,7 @@ "7 -0.0501 0.2608 " ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -644,7 +872,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -653,7 +881,7 @@ "" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, @@ -691,7 +919,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -700,7 +928,7 @@ "" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, @@ -748,7 +976,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -757,7 +985,7 @@ "" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, From 464a884f68f975a57a6edcc9725b31bcd050acaf Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Tue, 10 Oct 2023 13:36:35 +0300 Subject: [PATCH 25/31] Add posterior probability calculations / calculate responses function --- eis_toolkit/prediction/weights_of_evidence.py | 80 +++++++--- notebooks/weights_of_evidence.ipynb | 148 ++++++++++-------- 2 files changed, 144 insertions(+), 84 deletions(-) diff --git a/eis_toolkit/prediction/weights_of_evidence.py b/eis_toolkit/prediction/weights_of_evidence.py index c53967ec..5dcc2c6a 100644 --- a/eis_toolkit/prediction/weights_of_evidence.py +++ b/eis_toolkit/prediction/weights_of_evidence.py @@ -5,7 +5,7 @@ import pandas as pd import rasterio from beartype import beartype -from beartype.typing import List, Literal, Optional, Sequence, Tuple +from beartype.typing import Dict, List, Literal, Optional, Sequence, Tuple from eis_toolkit import exceptions from eis_toolkit.vector_processing.rasterize_vector import rasterize_vector @@ -199,7 +199,7 @@ def _generalized_classes_cumulative(df: pd.DataFrame, studentized_contrast_thres return gen_df -def _calculate_generalized_weights_cumulative(df: pd.DataFrame, deposits) -> pd.DataFrame: +def _calculate_generalized_weights_cumulative(df: pd.DataFrame, deposits: np.ndarray) -> pd.DataFrame: """Calculate generalized weights.for cumulative methods.""" gen_df = df.copy() total_deposits = np.sum(deposits == 1) @@ -232,26 +232,28 @@ def _calculate_generalized_weights_cumulative(df: pd.DataFrame, deposits) -> pd. return gen_df -def _generate_rasters_from_metrics(evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str]) -> dict: - """Generate rasters for defined metrics based.""" - raster_dict = {} +def _generate_arrays_from_metrics( + evidence: np.ndarray, df: pd.DataFrame, metrics_to_include: List[str] +) -> Dict[str, np.ndarray]: + """Generate arrays for defined metrics.""" + array_dict = {} for metric in metrics_to_include: - raster = np.full(evidence.shape, np.nan) + metric_array = np.full(evidence.shape, np.nan) for _, row in df.iterrows(): mask = np.isin(evidence, row[CLASS_COLUMN]) - raster[mask] = row[metric] - raster_dict[metric] = raster - return raster_dict + metric_array[mask] = row[metric] + array_dict[metric] = metric_array + return array_dict @beartype -def weights_of_evidence( +def weights_of_evidence_calculate_weights( evidential_raster: rasterio.io.DatasetReader, deposits: gpd.GeoDataFrame, raster_nodata: Optional[Number] = None, weights_type: Literal["unique", "categorical", "ascending", "descending"] = "unique", studentized_contrast_threshold: Number = 1, - rasters_to_generate: Optional[Sequence[str]] = None, + arrays_to_generate: Optional[Sequence[str]] = None, ) -> Tuple[pd.DataFrame, dict, dict]: """ Calculate weights of spatial associations. @@ -271,29 +273,29 @@ def weights_of_evidence( 'descending' weight types. Used either as reclassification threshold directly (categorical) or to check that class with max contrast has studentized contrast value at least the defined value (cumulative). Defaults to 1. - rasters_to_generate: Rasters to generate from the computed weight metrics. All column names + arrays_to_generate: Arrays to generate from the computed weight metrics. All column names in the produced weights_df are valid choices. Defaults to ["Class", "W+", "S_W+] for "unique" weights_type and ["Class", "W+", "S_W+", "Generalized W+", "Generalized S_W+"] for the cumulative weight types. Returns: Dataframe with weights of spatial association between the input data. - Dictionary of rasters for specified metrics. + Dictionary of arrays for specified metrics. Raster metadata. """ - if rasters_to_generate is None: + if arrays_to_generate is None: if weights_type == "unique": - metrics_to_rasters = DEFAULT_METRICS_UNIQUE + metrics_to_arrays = DEFAULT_METRICS_UNIQUE else: - metrics_to_rasters = DEFAULT_METRICS_CUMULATIVE + metrics_to_arrays = DEFAULT_METRICS_CUMULATIVE else: - for col_name in rasters_to_generate: + for col_name in arrays_to_generate: if col_name not in VALID_DF_COLUMNS: raise exceptions.InvalidColumnException( - f"Rasters to generate contains invalid metric / column name: {col_name}." + f"Arrays to generate contains invalid metric / column name: {col_name}." ) - metrics_to_rasters = rasters_to_generate.copy() + metrics_to_arrays = arrays_to_generate.copy() # 1. Preprocess data evidence_array = _read_and_preprocess_evidence(evidential_raster, raster_nodata) @@ -350,7 +352,41 @@ def weights_of_evidence( weights_df = _generalized_classes_cumulative(weights_df, studentized_contrast_threshold) weights_df = _calculate_generalized_weights_cumulative(weights_df, masked_deposit_array) - # 5. Generate rasters for desired metrics - raster_dict = _generate_rasters_from_metrics(evidence_array, weights_df, metrics_to_rasters) + # 5. Generate arrays for desired metrics + arrays_dict = _generate_arrays_from_metrics(evidence_array, weights_df, metrics_to_arrays) - return weights_df, raster_dict, raster_meta + return weights_df, arrays_dict, raster_meta + + +def weights_of_evidence_calculate_responses( + weights_df: pd.DataFrame, output_arrays: Sequence[Dict[str, np.ndarray]] +) -> Tuple[np.ndarray, float, np.ndarray]: + """Calculate the posterior probabilities for the given generalized weight arrays. + + Args: + weights_df: Output Dataframe from weights of evidence calculations including deposit count and pixel count. + output_arrays: List of output array dictionaries returned by weights of evidence calculations. + For each dictionary, generalized weight and generalized standard deviation arrays are fetched and summed + together pixel-wise to calculate the posterior probabilities. + + Returns: + Array of posterior probabilites. + Array of standard deviations in the posterior probability calculations. + Confidence of the prospectivity values obtained in the posterior probability array. + """ + generalized_weight_arrays_sum = sum([item[GENERALIZED_WEIGHT_PLUS_COLUMN] for item in output_arrays]) + generalized_weight_std_arrays_sum = sum([item[GENERALIZED_S_WEIGHT_PLUS_COLUMN] for item in output_arrays]) + + prior_probabilities = weights_df[DEPOSIT_COUNT_COLUMN] / weights_df[PIXEL_COUNT_COLUMN] + prior_odds = np.log(prior_probabilities / (1 - prior_probabilities)) + posterior_probabilities = np.exp(generalized_weight_arrays_sum + prior_odds) / ( + 1 + np.exp(generalized_weight_arrays_sum + prior_odds) + ) + + probabilities_squared = np.square(posterior_probabilities) + probabilities_probabilities_std = np.sqrt( + (weights_df[DEPOSIT_COUNT_COLUMN] + generalized_weight_std_arrays_sum) * probabilities_squared + ) + + confidence_array = posterior_probabilities / probabilities_probabilities_std + return posterior_probabilities, probabilities_probabilities_std, confidence_array diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb index e7f8c3f6..897a73b2 100644 --- a/notebooks/weights_of_evidence.ipynb +++ b/notebooks/weights_of_evidence.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 53, "metadata": {}, "outputs": [], "source": [ @@ -14,38 +14,27 @@ "import sys\n", "sys.path.insert(0, \"..\")\n", "\n", - "from eis_toolkit.prediction.weights_of_evidence import weights_of_evidence" + "from eis_toolkit.prediction.weights_of_evidence import weights_of_evidence_calculate_weights, weights_of_evidence_calculate_responses" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 54, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "108\n", - "1\n", - "16\n", - "765\n" - ] - } - ], + "outputs": [], "source": [ "with rasterio.open(\"../tests/data/remote/wofe/wofe_evidence_raster.tif\") as evidence_raster:\n", " deposits = gpd.read_file(\"../tests/data/remote/wofe/wofe_deposits.shp\")\n", "\n", - " weights_unique, rasters_unique, _ = weights_of_evidence(evidence_raster, deposits, weights_type='unique')\n", - " weights_categorical, _, _ = weights_of_evidence(evidence_raster, deposits, weights_type='categorical', studentized_contrast_threshold=1)\n", - " weights_ascending, rasters_ascending, _ = weights_of_evidence(evidence_raster, deposits, weights_type='ascending', studentized_contrast_threshold=1)\n", - " weights_descending, rasters_descending, _ = weights_of_evidence(evidence_raster, deposits, weights_type='descending', studentized_contrast_threshold=1)" + " weights_unique, arrays_unique, raster_meta = weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='unique')\n", + " weights_categorical, _, _ = weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='categorical', studentized_contrast_threshold=1)\n", + " weights_ascending, arrays_ascending, _ = weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='ascending', studentized_contrast_threshold=1)\n", + " weights_descending, arrays_descending, _ = weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='descending', studentized_contrast_threshold=1)" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 55, "metadata": {}, "outputs": [ { @@ -212,7 +201,7 @@ "7 0.0000 0.0000 0.0000 " ] }, - "execution_count": 3, + "execution_count": 55, "metadata": {}, "output_type": "execute_result" } @@ -224,7 +213,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 56, "metadata": {}, "outputs": [ { @@ -428,7 +417,7 @@ "7 -0.8055 1.0047 " ] }, - "execution_count": 4, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" } @@ -440,7 +429,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 57, "metadata": {}, "outputs": [ { @@ -644,7 +633,7 @@ "7 -0.3994 0.3806 " ] }, - "execution_count": 5, + "execution_count": 57, "metadata": {}, "output_type": "execute_result" } @@ -656,7 +645,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 58, "metadata": {}, "outputs": [ { @@ -860,7 +849,7 @@ "7 -0.0501 0.2608 " ] }, - "execution_count": 6, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } @@ -872,7 +861,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "colormap_name = \"jet\"" + ] + }, + { + "cell_type": "code", + "execution_count": 60, "metadata": {}, "outputs": [ { @@ -881,13 +879,13 @@ "" ] }, - "execution_count": 7, + "execution_count": 60, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAAQ2CAYAAAC+xU2CAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADMiklEQVR4nOzdeVyVZf7/8fcB5OAG4gKIopKa+24S7k2Y4zimM5lajmvappXapjMpaBmmVraYlr/U+Y6VZaOOU2a5lgtj5paamqaCmbikgEsCHq7fH+mpww3IQeCwvJ6Px3kc7+u+rvv+XPeNnsPb+9zHZowxAgAAAAAAAH7Hy9MFAAAAAAAAoOghNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAEAx8NVXX6lXr14KDQ2VzWbT8uXLbzhmw4YNat26tex2u+rVq6eFCxcWeJ0AAKDkIDQCAAAoBi5duqQWLVpo9uzZuep/9OhR9ezZU3fccYd27dqlMWPGaMSIEfr8888LuFIAAFBS2IwxxtNFAAAAIPdsNpuWLVumPn36ZNvn2Wef1aeffqq9e/c62wYMGKCkpCStWrWqEKoEAADFnY+nCwAAAED+i4uLU1RUlEtb9+7dNWbMmGzHpKamKjU11bmckZGhc+fOqUqVKrLZbAVVKgAAuEnGGF24cEGhoaHy8sq/D5URGgEAAJRAiYmJCg4OdmkLDg5WSkqKfvnlF5UtW9YyJjY2VpMnTy6sEgEAQD47fvy4atasmW/bIzQCAACAJGnChAkaN26cczk5OVm1atXS8ePH5e/v78HKAABATlJSUhQWFqaKFSvm63YJjQAAAEqgkJAQnTp1yqXt1KlT8vf3z/IqI0my2+2y2+2Wdn9/f0IjAACKgfz+ODnfngYAAFACRUZGau3atS5tq1evVmRkpIcqAgAAxQ2hEQAAQDFw8eJF7dq1S7t27ZIkHT16VLt27VJCQoKkXz9aNnjwYGf/hx9+WEeOHNEzzzyjAwcO6K233tJHH32ksWPHeqJ8AABQDBEaAQAAFAPffPONWrVqpVatWkmSxo0bp1atWmnSpEmSpJMnTzoDJEkKDw/Xp59+qtWrV6tFixZ6+eWX9f/+3/9T9+7dPVI/AAAofmzGGOPpIgAAAFD0pKSkKCAgQMnJydzTCACAIqygXrO50ggAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEZAMTF06FDVqVPH02V41M0cg6FDh6pChQr5W1ARUKdOHQ0dOtTTZQAAAAAogQiNgHwUExMjm82ms2fPZrm+adOm6tq1a+EWBbdcvnxZMTEx2rBhg0fr+OGHH/TQQw/plltukZ+fn/z9/dWhQwe99tpr+uWXXzxaGwAAAIDSwcfTBQDInXnz5ikjI8PTZXhUYRyDy5cva/LkyZLksYDv008/1b333iu73a7BgweradOmSktL06ZNm/T0009r3759eueddzxSGwAAAIDSg9AIKCbKlCnj6RI8rjQcg6NHj2rAgAGqXbu21q1bp+rVqzvXjRo1SocPH9ann37qwQoBAAAAlBZ8PA3woA0bNshms+mjjz7S1KlTVbNmTfn5+enOO+/U4cOHXfpmdT+fpKQkDR06VAEBAapUqZKGDBmiXbt2yWazaeHChc5+Xbt2zfKqmay2mZGRoVmzZqlJkyby8/NTcHCwHnroIZ0/fz7HuaxYsUI2m03ffvuts+3f//63bDab/vrXv7r0bdSokfr37+/StmjRIrVp00Zly5ZV5cqVNWDAAB0/fvyG9f78888aNGiQ/P39ncdg9+7dlmNw3YkTJ9SnTx9VqFBB1apV01NPPSWHwyFJOnbsmKpVqyZJmjx5smw2m2w2m2JiYiRJiYmJGjZsmGrWrCm73a7q1aurd+/eOnbsWI7Hxh3Tp0/XxYsX9e6777oERtfVq1dPTzzxRLbjz507p6eeekrNmjVThQoV5O/vrx49emj37t2Wvm+88YaaNGmicuXKKTAwUG3bttX777/vXH/hwgWNGTNGderUkd1uV1BQkLp166YdO3bkz2QBAAAAFGlcaQQUAdOmTZOXl5eeeuopJScna/r06Ro4cKC2bt2a7RhjjHr37q1Nmzbp4YcfVqNGjbRs2TINGTLkpmp56KGHtHDhQg0bNkyPP/64jh49qjfffFM7d+7U5s2bs73ap2PHjrLZbPrqq6/UvHlzSdLGjRvl5eWlTZs2OfudOXNGBw4c0OjRo51tU6dO1cSJE9WvXz+NGDFCZ86c0RtvvKHOnTtr586dqlSpUpb7zMjIUK9evfT111/rkUceUcOGDfWf//wn22PgcDjUvXt3RUREaObMmVqzZo1efvll1a1bV4888oiqVaumOXPm6JFHHtFf/vIXZ9h1fT733HOP9u3bp8cee0x16tTR6dOntXr1aiUkJOTbTcr/+9//6pZbblH79u3zNP7IkSNavny57r33XoWHh+vUqVN6++231aVLF3333XcKDQ2V9OtH/R5//HH17dtXTzzxhK5cuaJvv/1WW7du1f333y9Jevjhh/Xxxx9r9OjRaty4sX7++Wdt2rRJ+/fvV+vWrfNlvgAAAACKMAMg30RHRxtJ5syZM1mub9KkienSpYtzef369UaSadSokUlNTXW2v/baa0aS2bNnj7NtyJAhpnbt2s7l5cuXG0lm+vTpzrarV6+aTp06GUlmwYIFzvYuXbq47De7bW7cuNFIMu+9955Lv1WrVmXZntX8+vXr51xu3bq1uffee40ks3//fmOMMUuXLjWSzO7du40xxhw7dsx4e3ubqVOnumxrz549xsfHx6U9c73//ve/jSQza9YsZ5vD4TB/+MMfLMdgyJAhRpKZMmWKy35atWpl2rRp41w+c+aMkWSio6Nd+p0/f95IMjNmzMjxGNyM5ORkI8n07t0712Nq165thgwZ4ly+cuWKcTgcLn2OHj1q7Ha7y9x79+5tmjRpkuO2AwICzKhRo3JdC4CS5/q/S8nJyZ4uBQAA5KCgXrP5eBpQBAwbNky+vr7O5U6dOkn69aqR7KxcuVI+Pj565JFHnG3e3t567LHH8lzHkiVLFBAQoG7duuns2bPOR5s2bVShQgWtX78+x/GdOnXSxo0bJf360abdu3frwQcfVNWqVZ3tGzduVKVKldS0aVNJ0tKlS5WRkaF+/fq57DMkJET169fPcZ+rVq1SmTJlNHLkSGebl5eXRo0ale2Yhx9+2FJzTsf5urJly8rX11cbNmy44Uf18iolJUWSVLFixTxvw263y8vr13/aHQ6Hfv75Z1WoUEENGjRw+VhZpUqV9OOPP2rbtm3ZbqtSpUraunWrfvrppzzXAwAAAKD4KpWh0VdffaVevXopNDRUNptNy5cvd3sbxhjNnDlTt956q+x2u2rUqKGpU6fmf7EocWw2m6WtVq1aLsuBgYGSlGM4ER8fr+rVq6tChQou7Q0aNMhzbYcOHVJycrKCgoJUrVo1l8fFixd1+vTpHMd36tRJJ0+e1OHDh7VlyxbZbDZFRka6hEkbN25Uhw4dnMHGoUOHZIxR/fr1Lfvcv39/jvu8fgzKlSvn0l6vXr0s+/v5+TnvWXRdYGBgrkIgu92ul156SZ999pmCg4PVuXNnTZ8+XYmJiTmO++WXX5SYmOjyyI6/v7+kXwO3vMrIyNCrr76q+vXry263q2rVqqpWrZq+/fZbJScnO/s9++yzqlChgtq1a6f69etr1KhR2rx5s8u2pk+frr179yosLEzt2rVTTExMrgI2AAAAACVDqbyn0aVLl9SiRQsNHz7ccoPe3HriiSf0xRdfaObMmWrWrJnOnTunc+fO5XOlKG78/Pwk/RoUZOXy5cvOPr/n7e2dZX9jTL7UZbPZstzW9RtAX5eRkaGgoCC99957WW4nc+CSWceOHSX9GsweOXJErVu3Vvny5dWpUye9/vrrunjxonbu3OkSsGZkZMhms+mzzz7L8jhkDsVuRnbHObfGjBmjXr16afny5fr88881ceJExcbGat26dWrVqlWWYz788EMNGzbMpS278+rv76/Q0FDt3bs3zzW++OKLmjhxooYPH67nn39elStXlpeXl8aMGaOMjAxnv0aNGungwYP65JNPtGrVKv373//WW2+9pUmTJmny5MmSpH79+qlTp05atmyZvvjiC82YMUMvvfSSli5dqh49euS5RgAAAADFQ6kMjXr06JHjLzypqan6xz/+oQ8++EBJSUlq2rSpXnrpJee3T+3fv19z5szR3r17nVd1hIeHF0bpKOJq164tSTp48KDCwsJc1l2+fFnHjx/XXXfdlW/7Wrt2rS5evOgSrBw8eNDSNzAwMMsrROLj412W69atqzVr1qhDhw4qW7as2zXVqlVLtWrV0saNG3XkyBHnx+w6d+6scePGacmSJXI4HOrcubPLPo0xCg8P16233urW/mrXrq3169fr8uXLLlcbZf7mOXdkdSXY79WtW1dPPvmknnzySR06dEgtW7bUyy+/rEWLFmXZv3v37lq9enWu9//nP/9Z77zzjuLi4hQZGelW7ZL08ccf64477tC7777r0p6UlKSqVau6tJUvX179+/dX//79lZaWpr/+9a+aOnWqJkyY4Aw3q1evrkcffVSPPvqoTp8+rdatW2vq1KmERgAAAEApUCo/nnYjo0ePVlxcnBYvXqxvv/1W9957r/74xz/q0KFDkn77dqNPPvlE4eHhqlOnjkaMGMGVRtCdd94pX19fzZkzx+WqDkl65513dPXq1Xz7ZftPf/qTrl69qjlz5jjbHA6H3njjDUvfunXr6sCBAzpz5oyzbffu3ZaPI/Xr108Oh0PPP/+8ZRtXr15VUlLSDevq1KmT1q1bp6+//toZGrVs2VIVK1bUtGnTVLZsWbVp08bZ/69//au8vb01efJkyxU4xhj9/PPP2e6re/fuSk9P17x585xtGRkZmj179g3rzM718CnzXC9fvqwrV664tNWtW1cVK1ZUampqtturXr26oqKiXB45eeaZZ1S+fHmNGDFCp06dsqz/4Ycf9Nprr2U73tvb23IclyxZohMnTri0ZT6uvr6+aty4sYwxSk9Pl8PhcPk4myQFBQUpNDQ0x/kCAAAAKDlK5ZVGOUlISNCCBQuUkJDg/Grqp556SqtWrdKCBQv04osv6siRI4qPj9eSJUv0f//3f3I4HBo7dqz69u2rdevWeXgG8KSgoCBNmjRJzz33nDp37qy7775b5cqV05YtW/TBBx/orrvuUq9evfJlX7169VKHDh00fvx4HTt2TI0bN9bSpUstv+hL0vDhw/XKK6+oe/fueuCBB3T69GnNnTtXTZo0cd58WZK6dOmihx56SLGxsdq1a5fuuusulSlTRocOHdKSJUv02muvqW/fvjnW1alTJ7333nuy2WzOj6t5e3urffv2+vzzz9W1a1eXm37XrVtXL7zwgiZMmKBjx46pT58+qlixoo4ePaply5bpwQcf1FNPPZXlvvr06aN27drpySef1OHDh9WwYUOtWLHCGeDe6KqhrJQtW1aNGzfWhx9+qFtvvVWVK1dW06ZNdfXqVd15553q16+fGjduLB8fHy1btkynTp3SgAED3N5PdurWrav3339f/fv3V6NGjTR48GA1bdpUaWlp2rJli5YsWaKhQ4dmO/7Pf/6zpkyZomHDhql9+/bas2eP3nvvPd1yyy0u/e666y6FhISoQ4cOCg4O1v79+/Xmm2+qZ8+eqlixopKSklSzZk317dtXLVq0UIUKFbRmzRpt27ZNL7/8cr7NFwAAAEARlq/fxVYMSTLLli1zLn/yySdGkilfvrzLw8fHx/lV4iNHjjSSzMGDB53jtm/fbiSZAwcOFPYUUAQtWrTI3H777aZ8+fLGbrebhg0bmsmTJ5srV6649Fu/fr2RZJYsWeLSfvTo0Sy/Mv73XzdvjDE///yzGTRokPH39zcBAQFm0KBBZufOnZax12u65ZZbjK+vr2nZsqX5/PPPs9ymMca88847pk2bNqZs2bKmYsWKplmzZuaZZ54xP/300w3nvm/fPiPJNGrUyKX9hRdeMJLMxIkTsxz373//23Ts2NH5d65hw4Zm1KhRLn/Psqr3zJkz5v777zcVK1Y0AQEBZujQoWbz5s1Gklm8eLHL2PLly1v2Gx0dbTL/U7hlyxbTpk0b4+vraySZ6Ohoc/bsWTNq1CjTsGFDU758eRMQEGAiIiLMRx99dMNjkhfff/+9GTlypKlTp47x9fU1FStWNB06dDBvvPGGy89R7dq1zZAhQ5zLV65cMU8++aSpXr26KVu2rOnQoYOJi4szXbp0MV26dHH2e/vtt03nzp1NlSpVjN1uN3Xr1jVPP/208ys6U1NTzdNPP21atGhhKlasaMqXL29atGhh3nrrrQKZL4CiqaC+vhcAAOSvgnrNthmTT3faLaZsNpuWLVumPn36SPr1prUDBw7Uvn37LDfNrVChgkJCQhQdHa0XX3xR6enpznW//PKLypUrpy+++ELdunUrzCkALo4dO6bw8HAtWLAgxytSSrLly5frL3/5izZt2qQOHTp4uhwAKLZSUlIUEBCg5ORk5zc8AgCAoqegXrP5eFomrVq1ksPh0OnTp533Y8msQ4cOunr1qn744QfVrVtXkvT9999L+u1GyAAKxy+//OJy0+7r93Xy9/dX69atPVgZAAAAABRvpTI0unjxosu3Kx09elS7du1S5cqVdeutt2rgwIEaPHiwXn75ZbVq1UpnzpzR2rVr1bx5c/Xs2VNRUVFq3bq1hg8frlmzZikjI0OjRo1St27d3P72JwA357HHHtMvv/yiyMhIpaamaunSpdqyZYtefPHFPH0DHAAAAADgV6UyNPrmm290xx13OJfHjRsnSRoyZIgWLlyoBQsW6IUXXtCTTz6pEydOqGrVqrr99tv15z//WZLk5eWl//73v3rsscfUuXNnlS9fXj169ODmsIAH/OEPf9DLL7+sTz75RFeuXFG9evX0xhtvaPTo0Z4uDQAAAACKtVJ/TyMAAABkjXsaAQBQPBTUa7ZXvm0JAAAAAAAAJQahEQAAAAAAACxKzT2NMjIy9NNPP6lixYqy2WyeLgcAAGTDGKMLFy4oNDRUXl78/xYAAICnlJrQ6KefflJYWJinywAAALl0/Phx1axZ09NlAAAAlFqlJjSqWLGipF/fgHIjRwAAiq6UlBSFhYU5X7sBAADgGaUmNLr+kTR/f39CIwAAigE+Tg4AAOBZ3CgAAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFj7udK5Tp47i4+Mt7Y8++qhmz55taV+4cKGGDRvm0ma323XlyhVJUnp6up577jmtXLlSR44cUUBAgKKiojRt2jSFhobmuN/Y2FiNHz/enfILha2RpyvwsAMxBb+PhgW/D7O/wHcBAAAAAECR5lZotG3bNjkcDufy3r171a1bN917773ZjvH399fBgwedyzabzfnny5cva8eOHZo4caJatGih8+fP64knntDdd9+tb775xmU7U6ZM0ciRI53LFStWdKd0AAAAAAAAuMGt0KhatWouy9OmTVPdunXVpUuXbMfYbDaFhIRkuS4gIECrV692aXvzzTfVrl07JSQkqFatWs72ihUrZrsdAAAAAAAA5K8839MoLS1NixYt0vDhw12uHsrs4sWLql27tsLCwtS7d2/t27cvx+0mJyfLZrOpUqVKLu3Tpk1TlSpV1KpVK82YMUNXr17NcTupqalKSUlxeQAAAAAAACB33LrS6PeWL1+upKQkDR06NNs+DRo00Pz589W8eXMlJydr5syZat++vfbt26eaNWta+l+5ckXPPvus7rvvPvn7+zvbH3/8cbVu3VqVK1fWli1bNGHCBJ08eVKvvPJKtvuOjY3V5MmT8zo9AAAAAACAUs1mjDF5Gdi9e3f5+vrqv//9b67HpKenq1GjRrrvvvv0/PPPW9bdc889+vHHH7VhwwaX0Ciz+fPn66GHHtLFixdlt9uz7JOamqrU1FTnckpKisLCwpScnJzjtm8WN8KOKfh9cCNsACjRUlJSFBAQUOCv2bgxzgUAAMVDQb1m5+lKo/j4eK1Zs0ZLly51a1yZMmXUqlUrHT582KU9PT1d/fr1U3x8vNatW3fDCUZEROjq1as6duyYGjRokGUfu92ebaAEAAAAAACAnOXpnkYLFixQUFCQevbs6dY4h8OhPXv2qHr16s6264HRoUOHtGbNGlWpUuWG29m1a5e8vLwUFBTkdu0AAAAAAAC4MbevNMrIyNCCBQs0ZMgQ+fi4Dh88eLBq1Kih2NhYSdKUKVN0++23q169ekpKStKMGTMUHx+vESNGSPo1MOrbt6927NihTz75RA6HQ4mJiZKkypUry9fXV3Fxcdq6davuuOMOVaxYUXFxcRo7dqz+9re/KTAw8GbnDwAAAAAAgCy4HRqtWbNGCQkJGj58uGVdQkKCvLx+u3jp/PnzGjlypBITExUYGKg2bdpoy5Ytaty4sSTpxIkTWrFihSSpZcuWLttav369unbtKrvdrsWLFysmJkapqakKDw/X2LFjNW7cOHdLBwAAAAAAQC7l+UbYxU1h3ciRG2HHFPw+uBE2AJRo3Hy56OBcAABQPBTUa3ae7mkEAAAAAACAki1P356GHOThSpsN5rP8ryOTrrYeBb6PQpOXq5ncvDqp1F8xVgi4mgsAAAAAijauNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAACx9PF1DSbDCfebqELOWlrq62HgVQiYcciHGv/143+0tSX/eHlGa2Rp6uIGtmv6crAAAAAICigSuNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMDCx9MFlDRdbT08XQLyQ9MY98fszcOYvu4PQcGyNfJ0BVkz+z1dAQAAAIDShiuNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAADFxOzZs1WnTh35+fkpIiJCX3/9dY79Z82apQYNGqhs2bIKCwvT2LFjdeXKlUKqFgAAFHeERgAAAMXAhx9+qHHjxik6Olo7duxQixYt1L17d50+fTrL/u+//77Gjx+v6Oho7d+/X++++64+/PBD/f3vfy/kygEAQHFFaAQAAFAMvPLKKxo5cqSGDRumxo0ba+7cuSpXrpzmz5+fZf8tW7aoQ4cOuv/++1WnTh3ddddduu+++254dRIAAMB1hEYAAABFXFpamrZv366oqChnm5eXl6KiohQXF5flmPbt22v79u3OkOjIkSNauXKl/vSnP2W7n9TUVKWkpLg8AABA6eXj6QIAAACQs7Nnz8rhcCg4ONilPTg4WAcOHMhyzP3336+zZ8+qY8eOMsbo6tWrevjhh3P8eFpsbKwmT56cr7UDAIDiiyuNAAAASqANGzboxRdf1FtvvaUdO3Zo6dKl+vTTT/X8889nO2bChAlKTk52Po4fP16IFQMAgKKGK43yW8MY98ccyMMYFD1NYwp+H3vzsI+++V4FPMDWyNMVZM3s93QFQOlQtWpVeXt769SpUy7tp06dUkhISJZjJk6cqEGDBmnEiBGSpGbNmunSpUt68MEH9Y9//ENeXtb/O7Tb7bLb7fk/AQAAUCxxpREAAEAR5+vrqzZt2mjt2rXOtoyMDK1du1aRkZFZjrl8+bIlGPL29pYkGWMKrlgAAFBicKURAABAMTBu3DgNGTJEbdu2Vbt27TRr1ixdunRJw4YNkyQNHjxYNWrUUGxsrCSpV69eeuWVV9SqVStFRETo8OHDmjhxonr16uUMjwAAAHJCaAQAAFAM9O/fX2fOnNGkSZOUmJioli1batWqVc6bYyckJLhcWfTcc8/JZrPpueee04kTJ1StWjX16tVLU6dO9dQUAABAMWMzpeT65JSUFAUEBCg5OVn+/v4Ftp883XeEexoht7inEYoY7mmEglBYr9m4Mc4FAADFQ0G9ZnNPIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAsfdzrXqVNH8fHxlvZHH31Us2fPtrQvXLhQw4YNc2mz2+26cuWKJCk9PV3PPfecVq5cqSNHjiggIEBRUVGaNm2aQkNDnWPOnTunxx57TP/973/l5eWle+65R6+99poqVKjgTvlA8dc0xv0xe/Mwpq/7Q1A62Rq5P2bD/oj8LySTLtpa4PsAAAAASjq3QqNt27bJ4XA4l/fu3atu3brp3nvvzXaMv7+/Dh486Fy22WzOP1++fFk7duzQxIkT1aJFC50/f15PPPGE7r77bn3zzTfOfgMHDtTJkye1evVqpaena9iwYXrwwQf1/vvvu1M+AAAAAAAAcsmt0KhatWouy9OmTVPdunXVpUuXbMfYbDaFhIRkuS4gIECrV692aXvzzTfVrl07JSQkqFatWtq/f79WrVqlbdu2qW3btpKkN954Q3/60580c+ZMlyuSAAAAAAAAkD/yfE+jtLQ0LVq0SMOHD3e5eiizixcvqnbt2goLC1Pv3r21b9++HLebnJwsm82mSpUqSZLi4uJUqVIlZ2AkSVFRUfLy8tLWrdl//CA1NVUpKSkuDwAAAAAAAOROnkOj5cuXKykpSUOHDs22T4MGDTR//nz95z//0aJFi5SRkaH27dvrxx9/zLL/lStX9Oyzz+q+++6Tv7+/JCkxMVFBQUEu/Xx8fFS5cmUlJiZmu+/Y2FgFBAQ4H2FhYe5PEgAAAAAAoJTKc2j07rvvqkePHjl+PCwyMlKDBw9Wy5Yt1aVLFy1dulTVqlXT22+/bembnp6ufv36yRijOXPm5LUspwkTJig5Odn5OH78+E1vEwAAAAAAoLRw655G18XHx2vNmjVaunSpW+PKlCmjVq1a6fDhwy7t1wOj+Ph4rVu3znmVkSSFhITo9OnTLv2vXr2qc+fOZXuvJOnXb2mz2+1u1QcAAAAAAIBf5elKowULFigoKEg9e/Z0a5zD4dCePXtUvXp1Z9v1wOjQoUNas2aNqlSp4jImMjJSSUlJ2r59u7Nt3bp1ysjIUEREwX9tMwAAAAAAQGnk9pVGGRkZWrBggYYMGSIfH9fhgwcPVo0aNRQbGytJmjJlim6//XbVq1dPSUlJmjFjhuLj4zVixAhJvwZGffv21Y4dO/TJJ5/I4XA471NUuXJl+fr6qlGjRvrjH/+okSNHau7cuUpPT9fo0aM1YMAAvjkNAAAAAACggLgdGq1Zs0YJCQkaPny4ZV1CQoK8vH67eOn8+fMaOXKkEhMTFRgYqDZt2mjLli1q3LixJOnEiRNasWKFJKlly5Yu21q/fr26du0qSXrvvfc0evRo3XnnnfLy8tI999yj119/3d3SAQAAAAAAkEs2Y4zxdBGFISUlRQEBAUpOTna5Z1J+szXKw6ADMfldBvCbvTHuj+mb71UAThv2F/xHi7toa4HvAwWnsF6zcWOcCwAAioeCes3O87enAQAAAAAAoOQiNAIAAAAAAICF2/c0wg3k5aNmDfMwho+0FTkbzGduj+lq61EAlWTSNMb9Me5+pI2Ps6GI+VIF/xG4ro0K5yNwZn+h7AYAAACw4EojAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABY+ni6gpNlgPsvDKPfHdLX1cG9Awxi396EDeRhTGPIyF3cV1bkDJUDXRlsLfB8b9kcUyX3kZe62Rm4PKRRmv6crAAAAQEHjSiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsPDxdAElTVdbD7fHbDCfub+jhjHu9T/gZv+87CMP+4nW5Dzsw/0xkxsat/rn5Zzk5dwXWU1j3Ou/183+ktTX/SFAbnVttNXtMRv2RxRAJTe/j7zMpTDYGrnX3+wvmDoAAABQcLjSCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsfDxdAKSuth55GBXjXveGbvYvJJMbGvcHHYjJ9zoyy9s5AVCcdW201a3+G/ZHFFAlAAAAQNHAlUYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALHzc6VynTh3Fx8db2h999FHNnj3b0r5w4UINGzbMpc1ut+vKlSvO5aVLl2ru3Lnavn27zp07p507d6ply5YuY7p27aovv/zSpe2hhx7S3Llz3Sm/cDSMcX/MgTyMKarcnX8RnfsG85nbY7raehRAJSXYx3kY0zffqwAAAAAAZMOt0Gjbtm1yOBzO5b1796pbt2669957sx3j7++vgwcPOpdtNpvL+kuXLqljx47q16+fRo4cme12Ro4cqSlTpjiXy5Ur507pAAAAAAAAcINboVG1atVclqdNm6a6deuqS5cu2Y6x2WwKCQnJdv2gQYMkSceOHctx3+XKlctxOwAAAAAAAMg/eb6nUVpamhYtWqThw4dbrh76vYsXL6p27doKCwtT7969tW/fvjzt77333lPVqlXVtGlTTZgwQZcvX85r6QAAAAAAALgBt640+r3ly5crKSlJQ4cOzbZPgwYNNH/+fDVv3lzJycmaOXOm2rdvr3379qlmzZq53tf999+v2rVrKzQ0VN9++62effZZHTx4UEuXLs12TGpqqlJTU53LKSkpud4fAAAAAABAaZfn0Ojdd99Vjx49FBoamm2fyMhIRUZGOpfbt2+vRo0a6e2339bzzz+f6309+OCDzj83a9ZM1atX15133qkffvhBdevWzXJMbGysJk+enOt9AAAAAAAA4Dd5+nhafHy81qxZoxEjRrg1rkyZMmrVqpUOHz6cl906RURESFKO25kwYYKSk5Odj+PHj9/UPgEAAAAAAEqTPIVGCxYsUFBQkHr27OnWOIfDoT179qh69ep52a3Trl27JCnH7djtdvn7+7s8AAAAAAAAkDtufzwtIyNDCxYs0JAhQ+Tj4zp88ODBqlGjhmJjYyVJU6ZM0e2336569eopKSlJM2bMUHx8vMsVSufOnVNCQoJ++uknSdLBgwclSSEhIQoJCdEPP/yg999/X3/6059UpUoVffvttxo7dqw6d+6s5s2b53niAAAAAAAAyJ7bodGaNWuUkJCg4cOHW9YlJCTIy+u3i5fOnz+vkSNHKjExUYGBgWrTpo22bNmixo0bO/usWLFCw4YNcy4PGDBAkhQdHa2YmBj5+vpqzZo1mjVrli5duqSwsDDdc889eu6559wtHQAAAAAAALnkdmh01113yRiT5boNGza4LL/66qt69dVXc9ze0KFDc/wGtrCwMH355ZfulgkAAAAAAICbkKd7GgEAAAAAAKBkIzQCAAAAAACAhdsfT8MNHIgpnP00LKT9FLSSMo/SrmlM4exnr5v7yUtd/EwCAAAAgCSuNAIAAAAAAEAWCI0AAAAAAABgQWgEAABQTMyePVt16tSRn5+fIiIi9PXXX+fYPykpSaNGjVL16tVlt9t16623auXKlYVULQAAKO64pxEAAEAx8OGHH2rcuHGaO3euIiIiNGvWLHXv3l0HDx5UUFCQpX9aWpq6deumoKAgffzxx6pRo4bi4+NVqVKlwi8eAAAUS4RGAAAAxcArr7yikSNHatiwYZKkuXPn6tNPP9X8+fM1fvx4S//58+fr3Llz2rJli8qUKSNJqlOnTmGWDAAAijk+ngYAAFDEpaWlafv27YqKinK2eXl5KSoqSnFxcVmOWbFihSIjIzVq1CgFBweradOmevHFF+VwOLLdT2pqqlJSUlweAACg9CI0AgAAKOLOnj0rh8Oh4OBgl/bg4GAlJiZmOebIkSP6+OOP5XA4tHLlSk2cOFEvv/yyXnjhhWz3Exsbq4CAAOcjLCwsX+cBAACKF0IjAACAEigjI0NBQUF655131KZNG/Xv31//+Mc/NHfu3GzHTJgwQcnJyc7H8ePHC7FiAABQ1HBPIwAAgCKuatWq8vb21qlTp1zaT506pZCQkCzHVK9eXWXKlJG3t7ezrVGjRkpMTFRaWpp8fX0tY+x2u+x2e/4WDwAAii2uNAIAACjifH191aZNG61du9bZlpGRobVr1yoyMjLLMR06dNDhw4eVkZHhbPv+++9VvXr1LAMjAACAzAiNAAAAioFx48Zp3rx5+uc//6n9+/frkUce0aVLl5zfpjZ48GBNmDDB2f+RRx7RuXPn9MQTT+j777/Xp59+qhdffFGjRo3y1BQAAEAxw8fTAAAAioH+/fvrzJkzmjRpkhITE9WyZUutWrXKeXPshIQEeXn99v+BYWFh+vzzzzV27Fg1b95cNWrU0BNPPKFnn33WU1MAAADFjM0YYzxdRGFISUlRQECAkpOT5e/vX2D7sTUqsE2XTAdiCmU3G8xnbvXvauvh/k4axrg/ppDmX2rtjfF0BZ7V19MFILMN+yMKfB9dG20t8H3khdmf+76F9ZqNG+NcAABQPBTUazYfTwMAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABg4ePpAlBIDsR4uoIsRWuy22PuMO3cHtPV1sPtMW4rose4VGsa4/6YvXkYU1QVxs9kXo5X33yvwiM27I8olP10bbS1UPYDAAAAZMaVRgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABg4ePpAkqcAzGeriBrDWPcH1MIc7nDtHN7TFdbjwKoJJMierxQ8KKb2tweM3mvKYBK8sHeGE9XkLWP3ezft0Cq8IiujbZ6ugQAAAAg17jSCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsfNzpXKdOHcXHx1vaH330Uc2ePdvSvnDhQg0bNsylzW6368qVK87lpUuXau7cudq+fbvOnTunnTt3qmXLli5jrly5oieffFKLFy9WamqqunfvrrfeekvBwcHulF84Gsa4P+ZAHsa4u5+87KMQdLX18HQJnpWXnxd3FdFznydF9ee+qZv72etm/7zqWwj7+LgQ9lEY/0bmQddGWwt8HwAAAIAnuXWl0bZt23Ty5EnnY/Xq1ZKke++9N9sx/v7+LmMyh06XLl1Sx44d9dJLL2W7jbFjx+q///2vlixZoi+//FI//fST/vrXv7pTOgAAAAAAANzg1pVG1apVc1meNm2a6tatqy5dumQ7xmazKSQkJNv1gwYNkiQdO3Ysy/XJycl699139f777+sPf/iDJGnBggVq1KiR/ve//+n22293ZwoAAAAAAADIhTzf0ygtLU2LFi3S8OHDZbPZsu138eJF1a5dW2FhYerdu7f27dvn1n62b9+u9PR0RUVFOdsaNmyoWrVqKS4uLttxqampSklJcXkAAAAAAAAgd/IcGi1fvlxJSUkaOnRotn0aNGig+fPn6z//+Y8WLVqkjIwMtW/fXj/++GOu95OYmChfX19VqlTJpT04OFiJiYnZjouNjVVAQIDzERYWlut9AgAAAAAAlHZ5Do3effdd9ejRQ6Ghodn2iYyM1ODBg9WyZUt16dJFS5cuVbVq1fT222/ndbe5NmHCBCUnJzsfx48fL/B9AgAAAAAAlBRu3dPouvj4eK1Zs0ZLly51a1yZMmXUqlUrHT58ONdjQkJClJaWpqSkJJerjU6dOpXjvZLsdrvsdrtb9QEAAAAAAOBXebrSaMGCBQoKClLPnj3dGudwOLRnzx5Vr14912PatGmjMmXKaO3atc62gwcPKiEhQZGRkW7tHwAAAAAAALnj9pVGGRkZWrBggYYMGSIfH9fhgwcPVo0aNRQbGytJmjJlim6//XbVq1dPSUlJmjFjhuLj4zVixAjnmHPnzikhIUE//fSTpF8DIenXK4xCQkIUEBCgBx54QOPGjVPlypXl7++vxx57TJGRkXxzGgAAAAAAQAFxOzRas2aNEhISNHz4cMu6hIQEeXn9dvHS+fPnNXLkSCUmJiowMFBt2rTRli1b1LhxY2efFStWaNiwYc7lAQMGSJKio6MVExMjSXr11Vfl5eWle+65R6mpqerevbveeustd0sHAAAAAABALrkdGt11110yxmS5bsOGDS7Lr776ql599dUctzd06NAcv4FNkvz8/DR79mzNnj3bnVIBAAAAAACQR3n+9jQAAAAAAACUXIRGAAAAAAAAsHD742m4gQMxbg+J1uQ87Me9MZMV7f4+4J6GMZ6uoHgpjOOVl324+XdLkrQ3D/txV9+C30WRlZfjW5qPFwAAAJBPuNIIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgIWPpwsoacybk90eYxsdXQCVeEjDGPf6H3Czf2HJS13uzr2wFNW6iqjJe03B76Rvwe8iT/Lyc983D2M+dn8IAAAAgMLHlUYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYOHj6QJKGtvoaLfHmDcnF8p+CsWBGE9XkC82mM/cHtO1UUz+F4LC19fTBeSjwvj7mJd9NHWz/9487ONj94eUqHMPAAAA5AOuNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAABQTMyePVt16tSRn5+fIiIi9PXXX+dq3OLFi2Wz2dSnT5+CLRAAAJQoPp4uoOQZ4vYI22j3x7jvn4Wwj8KxwXxW4Pvo2mhrge8DheBAjKcryFrDmKK5n6J6vJrGuD+msI4xUIg+/PBDjRs3TnPnzlVERIRmzZql7t276+DBgwoKCsp23LFjx/TUU0+pU6dOhVgtAAAoCbjSCAAAoBh45ZVXNHLkSA0bNkyNGzfW3LlzVa5cOc2fPz/bMQ6HQwMHDtTkyZN1yy23FGK1AACgJCA0AgAAKOLS0tK0fft2RUVFOdu8vLwUFRWluLi4bMdNmTJFQUFBeuCBB3K1n9TUVKWkpLg8AABA6UVoBAAAUMSdPXtWDodDwcHBLu3BwcFKTEzMcsymTZv07rvvat68ebneT2xsrAICApyPsLCwm6obAAAUb4RGAAAAJcyFCxc0aNAgzZs3T1WrVs31uAkTJig5Odn5OH78eAFWCQAAijpuhA0AAFDEVa1aVd7e3jp16pRL+6lTpxQSEmLp/8MPP+jYsWPq1auXsy0jI0OS5OPjo4MHD6pu3bqWcXa7XXa7PZ+rBwAAxRVXGgEAABRxvr6+atOmjdauXetsy8jI0Nq1axUZGWnp37BhQ+3Zs0e7du1yPu6++27dcccd2rVrFx87AwAAucKVRgAAAMXAuHHjNGTIELVt21bt2rXTrFmzdOnSJQ0bNkySNHjwYNWoUUOxsbHy8/NT06ZNXcZXqlRJkiztAAAA2SE0AgAAKAb69++vM2fOaNKkSUpMTFTLli21atUq582xExIS5OXFReQAACD/EBoBAAAUE6NHj9bo0aOzXLdhw4Ycxy5cuDD/CwIAACUa/x0FAAAAAAAAC0IjAAAAAAAAWLj18bQ6deooPj7e0v7oo49q9uzZlvaFCxc6b854nd1u15UrV5zLxhhFR0dr3rx5SkpKUocOHTRnzhzVr18/x/3GxsZq/Pjx7pRfyg3Jw5h/5nsVFg1j3B7StZH7Y4Bi70CMpysoXvJyvPLw7xEAAABQkrkVGm3btk0Oh8O5vHfvXnXr1k333ntvtmP8/f118OBB57LNZnNZP336dL3++uv65z//qfDwcE2cOFHdu3fXd999Jz8/P2e/KVOmaOTIkc7lihUrulM6AAAAAAAA3OBWaFStWjWX5WnTpqlu3brq0qVLtmNsNptCQkKyXGeM0axZs/Tcc8+pd+/ekqT/+7//U3BwsJYvX64BAwY4+1asWDHb7QAAAAAAACB/5fmeRmlpaVq0aJGGDx9uuXro9y5evKjatWsrLCxMvXv31r59+5zrjh49qsTEREVFRTnbAgICFBERobi4OJftTJs2TVWqVFGrVq00Y8YMXb16Ncf6UlNTlZKS4vIAAAAAAABA7rh1pdHvLV++XElJSRo6dGi2fRo0aKD58+erefPmSk5O1syZM9W+fXvt27dPNWvWVGJioiQpODjYZVxwcLBznSQ9/vjjat26tSpXrqwtW7ZowoQJOnnypF555ZVs9x0bG6vJkyfndXoAAAAAAAClWp5Do3fffVc9evRQaGhotn0iIyMVGRnpXG7fvr0aNWqkt99+W88//3yu9zVu3Djnn5s3by5fX1899NBDio2Nld1uz3LMhAkTXMalpKQoLCws1/sEAAAAAAAozfL08bT4+HitWbNGI0aMcGtcmTJl1KpVKx0+fFiSnPcoOnXqlEu/U6dO5Xj/ooiICF29elXHjh3Lto/dbpe/v7/LAwAAAAAAALmTp9BowYIFCgoKUs+ePd0a53A4tGfPHlWvXl2SFB4erpCQEK1du9bZJyUlRVu3bnW5QimzXbt2ycvLS0FBQXkpHwAAAAAAADfg9sfTMjIytGDBAg0ZMkQ+Pq7DBw8erBo1aig2NlaSNGXKFN1+++2qV6+ekpKSNGPGDMXHxzuvULLZbBozZoxeeOEF1a9fX+Hh4Zo4caJCQ0PVp08fSVJcXJy2bt2qO+64QxUrVlRcXJzGjh2rv/3tbwoMDLzJ6QMAAAAAACArbodGa9asUUJCgoYPH25Zl5CQIC+v3y5eOn/+vEaOHKnExEQFBgaqTZs22rJlixo3buzs88wzz+jSpUt68MEHlZSUpI4dO2rVqlXy8/OT9OvHzBYvXqyYmBilpqYqPDxcY8eOdblfEQAAAAAAAPKXzRhjPF1EYUhJSVFAQICSk5ML9P5GNtvRAtt24ftnwe+iYUzB7wOl14EYT1eQtbz83BfVuZQk/HtUoMz+3PctrNds3BjnAgCA4qGgXrPzdE8jAAAAAAAAlGyERgAAAAAAALBw+55GyJkx4YWyn8L5GNyQPIxx8yNthfWRGz52UjKUlI9olZR5oFC02/+lW/2/btSlgCoBAABAacOVRgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABg4ePpApA3xoR7uoQs2WxD3BzxzwKpo7iIPmBzq//khqaAKvGAAzGergAoFr5u1MXTJQAAAKCU4kojAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABY+ni4AJYsx4W6OiCmIMixsjQphJwdi3B4yWdH5X0dx0TDG/TF5OMYopfLy8wUAAADABVcaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAICFj6cLAAqD2V8Ye4lxe4TN5v4YILeiNdmt/pMVXUCV3KSGMZ6uAAAAACiVuNIIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgIVboVGdOnVks9ksj1GjRmXZf+HChZa+fn5+Ln2MMZo0aZKqV6+usmXLKioqSocOHXLpc+7cOQ0cOFD+/v6qVKmSHnjgAV28eNHNqQIAAAAAACC3fNzpvG3bNjkcDufy3r171a1bN917773ZjvH399fBgwedyzabzWX99OnT9frrr+uf//ynwsPDNXHiRHXv3l3fffedM2AaOHCgTp48qdWrVys9PV3Dhg3Tgw8+qPfff9+d8oEix5gYT5eQL2yNPF0BsjJZ0W71Lyk/jwAAAADyh1uhUbVq1VyWp02bprp166pLly7ZjrHZbAoJCclynTFGs2bN0nPPPafevXtLkv7v//5PwcHBWr58uQYMGKD9+/dr1apV2rZtm9q2bStJeuONN/SnP/1JM2fOVGhoqDtTAAAAAAAAQC7k+Z5GaWlpWrRokYYPH265euj3Ll68qNq1ayssLEy9e/fWvn37nOuOHj2qxMRERUVFOdsCAgIUERGhuLg4SVJcXJwqVarkDIwkKSoqSl5eXtq6dWu2+01NTVVKSorLAwAAAAAAALmT59Bo+fLlSkpK0tChQ7Pt06BBA82fP1//+c9/tGjRImVkZKh9+/b68ccfJUmJiYmSpODgYJdxwcHBznWJiYkKCgpyWe/j46PKlSs7+2QlNjZWAQEBzkdYWFhepgkAAAAAAFAq5Tk0evfdd9WjR48cPx4WGRmpwYMHq2XLlurSpYuWLl2qatWq6e23387rbnNtwoQJSk5Odj6OHz9e4PsEAAAAAAAoKdy6p9F18fHxWrNmjZYuXerWuDJlyqhVq1Y6fPiwJDnvdXTq1ClVr17d2e/UqVNq2bKls8/p06ddtnP16lWdO3cu23slSZLdbpfdbnerPgAAAAAAAPwqT1caLViwQEFBQerZs6db4xwOh/bs2eMMiMLDwxUSEqK1a9c6+6SkpGjr1q2KjIyU9OvVSklJSdq+fbuzz7p165SRkaGIiIi8lA8AAAAAAIAbcPtKo4yMDC1YsEBDhgyRj4/r8MGDB6tGjRqKjY2VJE2ZMkW333676tWrp6SkJM2YMUPx8fEaMWKEpF+/WW3MmDF64YUXVL9+fYWHh2vixIkKDQ1Vnz59JEmNGjXSH//4R40cOVJz585Venq6Ro8erQEDBvDNaQAAAAAAAAXE7dBozZo1SkhI0PDhwy3rEhIS5OX128VL58+f18iRI5WYmKjAwEC1adNGW7ZsUePGjZ19nnnmGV26dEkPPvigkpKS1LFjR61atUp+fn7OPu+9955Gjx6tO++8U15eXrrnnnv0+uuvu1s6AAAAAAAAcslmjDGeLqIwpKSkKCAgQMnJyfL39/d0OUCJYmtUSDs6EFNIOyqdjInxdAmAJF6zixLOBQAAxUNBvWbn+dvTAAAAAAAAUHIRGgEAAAAAAMDC7XsaAUBmZn9h7SmmsHYEAAAAAKUeVxoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAUE7Nnz1adOnXk5+eniIgIff3119n2nTdvnjp16qTAwEAFBgYqKioqx/4AAACZERoBAAAUAx9++KHGjRun6Oho7dixQy1atFD37t11+vTpLPtv2LBB9913n9avX6+4uDiFhYXprrvu0okTJwq5cgAAUFzZjDHG00UUhpSUFAUEBCg5OVn+/v6eLgcAAGSD1+ysRURE6LbbbtObb74pScrIyFBYWJgee+wxjR8//objHQ6HAgMD9eabb2rw4MG52ifnAgCA4qGgXrN98m1LRdz1bCwlJcXDlQAAgJxcf60uJf+vlStpaWnavn27JkyY4Gzz8vJSVFSU4uLicrWNy5cvKz09XZUrV862T2pqqlJTU53LvG8CAKB0KzWh0YULFyRJYWFhHq4EAADkxoULFxQQEODpMoqEs2fPyuFwKDg42KU9ODhYBw4cyNU2nn32WYWGhioqKirbPrGxsZo8efJN1QoAAEqOUhMahYaG6vjx46pYsaJsNpunyyk0KSkpCgsL0/Hjx0vlZeWlef7MnbmXtrlLpXv+JWnuxhhduHBBoaGhni6lxJg2bZoWL16sDRs2yM/PL9t+EyZM0Lhx45zL13+uAABA6VRqQiMvLy/VrFnT02V4jL+/f7H/JeJmlOb5M3fmXhqV5vmXlLlzhZGrqlWrytvbW6dOnXJpP3XqlEJCQnIcO3PmTE2bNk1r1qxR8+bNc+xrt9tlt9tvul4AAFAy8O1pAAAARZyvr6/atGmjtWvXOtsyMjK0du1aRUZGZjtu+vTpev7557Vq1Sq1bdu2MEoFAAAlSKm50ggAAKA4GzdunIYMGaK2bduqXbt2mjVrli5duqRhw4ZJkgYPHqwaNWooNjZWkvTSSy9p0qRJev/991WnTh0lJiZKkipUqKAKFSp4bB4AAKD4IDQq4ex2u6Kjo0vtpealef7MnbmXRqV5/qV57qVF//79debMGU2aNEmJiYlq2bKlVq1a5bw5dkJCgry8fruIfM6cOUpLS1Pfvn1dthMdHa2YmJjCLB0AABRTNsP32QIAACALKSkpCggIUHJycom4VxYAACVVQb1mc08jAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNCpipk2bJpvNpjFjxjjb3nnnHXXt2lX+/v6y2WxKSkqyjDt37pwGDhwof39/VapUSQ888IAuXrzo0ufbb79Vp06d5Ofnp7CwME2fPt2ynSVLlqhhw4by8/NTs2bNtHLlSpf1xhhNmjRJ1atXV9myZRUVFaVDhw55dO516tSRzWZzeUybNq1Yz/3cuXN67LHH1KBBA5UtW1a1atXS448/ruTkZJdxCQkJ6tmzp8qVK6egoCA9/fTTunr1qkufDRs2qHXr1rLb7apXr54WLlxo2f/s2bNVp04d+fn5KSIiQl9//bXL+itXrmjUqFGqUqWKKlSooHvuuUenTp3Kl7nfzPwzn3ebzabFixcXq/ln9XP/0EMPqW7duipbtqyqVaum3r1768CBAy7jSsK5z+vcS+p5v84Yox49eshms2n58uUu60rCeQcAAEAxYlBkfP3116ZOnTqmefPm5oknnnC2v/rqqyY2NtbExsYaSeb8+fOWsX/84x9NixYtzP/+9z+zceNGU69ePXPfffc51ycnJ5vg4GAzcOBAs3fvXvPBBx+YsmXLmrffftvZZ/Pmzcbb29tMnz7dfPfdd+a5554zZcqUMXv27HH2mTZtmgkICDDLly83u3fvNnfffbcJDw83v/zyi8fmXrt2bTNlyhRz8uRJ5+PixYvFeu579uwxf/3rX82KFSvM4cOHzdq1a039+vXNPffc4xx39epV07RpUxMVFWV27txpVq5caapWrWomTJjg7HPkyBFTrlw5M27cOPPdd9+ZN954w3h7e5tVq1Y5+yxevNj4+vqa+fPnm3379pmRI0eaSpUqmVOnTjn7PPzwwyYsLMysXbvWfPPNN+b222837du3v6l53+z8jTFGklmwYIHLuf/9+Sjq88/u5/7tt982X375pTl69KjZvn276dWrlwkLCzNXr141xpSMc5/XuRtTcs/7da+88orp0aOHkWSWLVvmbC8J5x3FT3JyspFkkpOTPV0KAADIQUG9ZhMaFREXLlww9evXN6tXrzZdunTJ8heJ9evXZxmcfPfdd0aS2bZtm7Pts88+MzabzZw4ccIYY8xbb71lAgMDTWpqqrPPs88+axo0aOBc7tevn+nZs6fLtiMiIsxDDz1kjDEmIyPDhISEmBkzZjjXJyUlGbvdbj744AOPzN2YX0OjV199NdvtF/e5X/fRRx8ZX19fk56ebowxZuXKlcbLy8skJiY6+8yZM8f4+/s75/rMM8+YJk2auGynf//+pnv37s7ldu3amVGjRjmXHQ6HCQ0NNbGxsc55lilTxixZssTZZ//+/UaSiYuLy/Pcjbm5+RtjLL9UZ1aU5+/O3Hfv3m0kmcOHDxtjiv+5v5m5G1Oyz/vOnTtNjRo1zMmTJy3zLO7nHcUToREAAMVDQb1m8/G0ImLUqFHq2bOnoqKi3B4bFxenSpUqqW3bts62qKgoeXl5aevWrc4+nTt3lq+vr7NP9+7ddfDgQZ0/f97ZJ/P+u3fvrri4OEnS0aNHlZiY6NInICBAERERzj55cTNzv27atGmqUqWKWrVqpRkzZrh8XKOkzD05OVn+/v7y8fFx1tysWTMFBwe71JySkqJ9+/blal5paWnavn27Sx8vLy9FRUU5+2zfvl3p6ekufRo2bKhatWrd1Nylm5v/77dRtWpVtWvXTvPnz5cxxrmuKM8/t3O/dOmSFixYoPDwcIWFhTnnVZzP/c3M/ffbKGnn/fLly7r//vs1e/ZshYSEWNYX9/MOAACA4sfnxl1Q0BYvXqwdO3Zo27ZteRqfmJiooKAglzYfHx9VrlxZiYmJzj7h4eEufa7/4pGYmKjAwEAlJia6/DJyvc/vt/H7cVn1cdfNzl2SHn/8cbVu3VqVK1fWli1bNGHCBJ08eVKvvPKKs+7iPvezZ8/q+eef14MPPuhsy67m39ebXZ+UlBT98ssvOn/+vBwOR5Z9rt9HJjExUb6+vqpUqZKlT17nLt38/CVpypQp+sMf/qBy5crpiy++0KOPPqqLFy/q8ccfd9ZeFOefm7m/9dZbeuaZZ3Tp0iU1aNBAq1evdgafxfnc3+zcpZJ73seOHav27durd+/eWa4vzucdAAAAxROhkYcdP35cTzzxhFavXi0/Pz9Pl1Oo8mvu48aNc/65efPm8vX11UMPPaTY2FjZ7fb8KDXfuTP3lJQU9ezZU40bN1ZMTEzhFFjA8mv+EydOdP65VatWunTpkmbMmOEMD4qi3M594MCB6tatm06ePKmZM2eqX79+2rx5c7H+dyK/5l4Sz/uKFSu0bt067dy50wPVAQAAAFnj42ketn37dp0+fVqtW7eWj4+PfHx89OWXX+r111+Xj4+PHA7HDbcREhKi06dPu7RdvXpV586dc37EISQkxPLNN9eXb9Tn9+t/Py6rPu7Ij7lnJSIiQlevXtWxY8ecdRfXuV+4cEF//OMfVbFiRS1btkxlypRxbuNm5uXv76+yZcuqatWq8vb2vuHc09LSLN9cl9e559f8sxIREaEff/xRqampRXb+uZ17QECA6tevr86dO+vjjz/WgQMHtGzZshzndX1dSZ57VkrCeV+9erV++OEHVapUybleku655x517do1x3ldX1dU5w4AAIDii9DIw+68807t2bNHu3btcj7atm2rgQMHateuXfL29r7hNiIjI5WUlKTt27c729atW6eMjAxFREQ4+3z11VdKT0939lm9erUaNGigwMBAZ5+1a9e6bHv16tWKjIyUJIWHhyskJMSlT0pKirZu3ersU9hzz8quXbvk5eXl/MhecZ17SkqK7rrrLvn6+mrFihWWqxMiIyO1Z88el8Bw9erV8vf3V+PGjXM1L19fX7Vp08alT0ZGhtauXevs06ZNG5UpU8alz8GDB5WQkJCnuefX/LOya9cuBQYGOq8wK4rzz8vPvfn1SwucoUhxPff5MfeslITz/o9//EPffvuty3pJevXVV7VgwQLnvIrjeQcAAEAxlq+31Ua+yPyNOidPnjQ7d+408+bNM5LMV199ZXbu3Gl+/vlnZ58//vGPplWrVmbr1q1m06ZNpn79+ua+++5zrk9KSjLBwcFm0KBBZu/evWbx4sWmXLlylq+d9/HxMTNnzjT79+830dHRWX7tfKVKlcx//vMf8+2335revXvny9fO53XuW7ZsMa+++qrZtWuX+eGHH8yiRYtMtWrVzODBg4v13JOTk01ERIRp1qyZOXz4sMtXi2f+2vW77rrL7Nq1y6xatcpUq1Yty6/ffvrpp83+/fvN7Nmzs/z6bbvdbhYuXGi+++478+CDD5pKlSq5fEPTww8/bGrVqmXWrVtnvvnmGxMZGWkiIyPzZd55nf+KFSvMvHnzzJ49e8yhQ4fMW2+9ZcqVK2cmTZpU7Ob/+7n/8MMP5sUXXzTffPONiY+PN5s3bza9evUylStXdn4lekk69+7OvaSe96wo07enlaTzjuKDb08DAKB4KKjXbEKjIijzLxLR0dFGkuWxYMECZ5+ff/7Z3HfffaZChQrG39/fDBs2zFy4cMFlu7t37zYdO3Y0drvd1KhRw0ybNs2y748++sjceuutxtfX1zRp0sR8+umnLuszMjLMxIkTTXBwsLHb7ebOO+80Bw8e9Njct2/fbiIiIkxAQIDx8/MzjRo1Mi+++KK5cuVKsZ77+vXrs5y3JHP06FHnmGPHjpkePXqYsmXLmqpVq5onn3zS5Svpr2+rZcuWxtfX19xyyy0uPzfXvfHGG6ZWrVrG19fXtGvXzvzvf/9zWf/LL7+YRx991AQGBppy5cqZv/zlL+bkyZP5Nve8zP+zzz4zLVu2NBUqVDDly5c3LVq0MHPnzjUOh6PYzf/3cz9x4oTp0aOHCQoKMmXKlDE1a9Y0999/vzlw4IDLmJJy7t2de0k971nJHBoZU3LOO4oPQiMAAIqHgnrNthnzu+8pBgAAAK5JSUlRQECAkpOT5e/v7+lyAABANgrqNZt7GgEAAAAAAMCC0AgAAAAAAAAWPp4uoDBduXJFaWlpni4DAADcgK+vb66+NREAAAAFp9SERleuXFHZstUkXfR0KQAA4AZCQkJ09OhRgiMAAAAPKjWh0a9XGF2UNFZS+WutZa49+2TznNP6Mrnok1/rbzTm+vINeN9gl145rPPOpj0v67NbVyaLvjnV7Z2L9bndxo3qzunY3eyxcfa7dk96H4fLs8376q+LPg55X2vz9sm49nz12vO1dq9rz8r62efas5dl/bV9KMPZ7m3pe9VlG96/6/trv8zrb1zDjfq4X0P2/TLPNbt9/7bNG/WzHrPc1nnjY3bjGm54bh3Xnq9e24fDXFuWy7Pt113p2q6sz45rj8xt7ixff85uX4583taNlnO7rczbcKe2/NzWDWpLvzb22qm2LF91uA5Jz2ZT2bX/fn1O63K7jdzsI1XSq4mJSktLIzQCAADwoFITGv3GLun6G9DswpfcLGcXGhXEcm7HZMOWy2cv/XaXq+yeM4comZ9vFJxklYHdKMy6mfW53cYNA51c7CMvY12ecw6NbGUcsl1vcz7/us7r2rKXl2tw4JUpnLCGRdkHKdmHJDcKUXK/Pv/3cf3ZO4d9eeVyG7Zr/bxcxv32bMu0HZuz7be/DrZM21SmZ3OtX+b268/XazUu/b1lfvfnjEz7uvbsuPZ89Vqd2YVG2YUVOYUsuRnjbnt+biurdu/frc98oK+Pye7fvczbtGVan/nf0uv9s2LLtJz5+0tNNu3Z1Wak9GvB0rVTrXRbpuVrXW8U8ORm+UZ9b7QNnxus9/7dnwEAAOB53AgbAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACx8PF1A4UvVb9N2XHu+vnz1Bsvpv1suc+3PZTL1yfycH+tvNOb6cjZMLp8zrj2UxbPt2rMj0/L1Z2WznLmG7Pb7e5n37Z1Nf0em9Znbr+q3Q+SdaV3m9uwOv3em56xOV263kd16Z79rE/RxuDwb719/Do2PQ+Z6m0/Gtedf12Vca7d5XXtW1s8ZzgOQ+fnqtX6/P4jX9uV8vuoyxlzra5zbvpppOevn6+sdcsj72p8zP2dkWvZyLl91jv11OSPHfj6/6+edaV12+/5tmzfqd30fv9WQ0/6z2sb1/j7Z1pD9829/Nte2Ya5t89dnb8e156vX1l871dd+nJzPtuun/Go2z7/9KCjTj0Dul68/Z7cvRz5v60bLud1W5m24U1tut3Wj5+z+Tf7dc/q1fzqunWrLcuYS0uVe++/X57Qut9vIzT5SBQAAgKKg1IRGvr6+CgkJUWLiq54uxXMy/zKCYuF6Vpau337hAoCSLiQkRL6+vp4uAwAAoFQrNaGRn5+fjh49qrS0NE+Xkq2UlBSFhYXp+PHj8vf393Q5xRrHMn9wHPMHxzF/cBzzR3E5jr6+vvLz8/N0GQAAAKVaqQmNpF+Do+LwBtTf379Iv5EvTjiW+YPjmD84jvmD45g/OI4AAAC4EW6EDQAAAAAAAAtCIwAAAAAAAFgQGhUhdrtd0dHRstvtni6l2ONY5g+OY/7gOOYPjmP+4DgCAAAgt2zGGHPjbgAAAChtUlJSFBAQoOTkZO6BBQBAEVZQr9lcaQQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGRUBsbKxuu+02VaxYUUFBQerTp48OHjzo6bKKvWnTpslms2nMmDGeLqXYOXHihP72t7+pSpUqKlu2rJo1a6ZvvvnG02UVKw6HQxMnTlR4eLjKli2runXr6vnnnxffPXBjX331lXr16qXQ0FDZbDYtX77cZb0xRpMmTVL16tVVtmxZRUVF6dChQ54ptgjL6Timp6fr2WefVbNmzVS+fHmFhoZq8ODB+umnnzxXMAAAAIocQqMi4Msvv9SoUaP0v//9T6tXr1Z6erruuusuXbp0ydOlFVvbtm3T22+/rebNm3u6lGLn/Pnz6tChg8qUKaPPPvtM3333nV5++WUFBgZ6urRi5aWXXtKcOXP05ptvav/+/XrppZc0ffp0vfHGG54urci7dOmSWrRoodmzZ2e5fvr06Xr99dc1d+5cbd26VeXLl1f37t115cqVQq60aMvpOF6+fFk7duzQxIkTtWPHDi1dulQHDx7U3Xff7YFKAQAAUFTZDP/tXeScOXNGQUFB+vLLL9W5c2dPl1PsXLx4Ua1bt9Zbb72lF154QS1bttSsWbM8XVaxMX78eG3evFkbN270dCnF2p///GcFBwfr3Xffdbbdc889Klu2rBYtWuTByooXm82mZcuWqU+fPpJ+vcooNDRUTz75pJ566ilJUnJysoKDg7Vw4UINGDDAg9UWXZmPY1a2bdumdu3aKT4+XrVq1Sq84lCkFdTX9wIAgPxVUK/ZXGlUBCUnJ0uSKleu7OFKiqdRo0apZ8+eioqK8nQpxdKKFSvUtm1b3XvvvQoKClKrVq00b948T5dV7LRv315r167V999/L0navXu3Nm3apB49eni4suLt6NGjSkxMdPn7HRAQoIiICMXFxXmwsuIvOTlZNptNlSpV8nQpAAAAKCJ8PF0AXGVkZGjMmDHq0KGDmjZt6ulyip3Fixdrx44d2rZtm6dLKbaOHDmiOXPmaNy4cfr73/+ubdu26fHHH5evr6+GDBni6fKKjfHjxyslJUUNGzaUt7e3HA6Hpk6dqoEDB3q6tGItMTFRkhQcHOzSHhwc7FwH9125ckXPPvus7rvvPq4mAQAAgBOhUREzatQo7d27V5s2bfJ0KcXO8ePH9cQTT2j16tXy8/PzdDnFVkZGhtq2basXX3xRktSqVSvt3btXc+fOJTRyw0cffaT33ntP77//vpo0aaJdu3ZpzJgxCg0N5TiiSElPT1e/fv1kjNGcOXM8XQ4AAACKED6eVoSMHj1an3zyidavX6+aNWt6upxiZ/v27Tp9+rRat24tHx8f+fj46Msvv9Trr78uHx8fORwOT5dYLFSvXl2NGzd2aWvUqJESEhI8VFHx9PTTT2v8+PEaMGCAmjVrpkGDBmns2LGKjY31dGnFWkhIiCTp1KlTLu2nTp1yrkPuXQ+M4uPjtXr1aq4yAgAAgAtCoyLAGKPRo0dr2bJlWrduncLDwz1dUrF05513as+ePdq1a5fz0bZtWw0cOFC7du2St7e3p0ssFjp06KCDBw+6tH3//feqXbu2hyoqni5fviwvL9d/Yr29vZWRkeGhikqG8PBwhYSEaO3atc62lJQUbd26VZGRkR6srPi5HhgdOnRIa9asUZUqVTxdEgAAAIoYPp5WBIwaNUrvv/++/vOf/6hixYrO+3IEBASobNmyHq6u+KhYsaLlPlDly5dXlSpVuD+UG8aOHav27dvrxRdfVL9+/fT111/rnXfe0TvvvOPp0oqVXr16aerUqapVq5aaNGminTt36pVXXtHw4cM9XVqRd/HiRR0+fNi5fPToUe3atUuVK1dWrVq1NGbMGL3wwguqX7++wsPDNXHiRIWGhub4zWClUU7HsXr16urbt6927NihTz75RA6Hw/naU7lyZfn6+nqqbAAAABQhNmOM8XQRpZ3NZsuyfcGCBRo6dGjhFlPCdO3aVS1bttSsWbM8XUqx8sknn2jChAk6dOiQwsPDNW7cOI0cOdLTZRUrFy5c0MSJE7Vs2TKdPn1aoaGhuu+++zRp0iR+Ib+BDRs26I477rC0DxkyRAsXLpQxRtHR0XrnnXeUlJSkjh076q233tKtt97qgWqLrpyOY0xMTLZXta5fv15du3Yt4OpQXBTU1/cCAID8VVCv2YRGAAAAyBKhEQAAxUNBvWZzTyMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAFBMzJ49W3Xq1JGfn58iIiL09ddf59h/yZIlatiwofz8/NSsWTOtXLmykCoFAAAlAaERAABAMfDhhx9q3Lhxio6O1o4dO9SiRQt1795dp0+fzrL/li1bdN999+mBBx7Qzp071adPH/Xp00d79+4t5MoBAEBxZTPGGE8XAQAAgJxFRETotttu05tvvilJysjIUFhYmB577DGNHz/e0r9///66dOmSPvnkE2fb7bffrpYtW2ru3Lm52mdKSooCAgKUnJwsf3///JkIAADIdwX1mu2Tb1sCAABAgUhLS9P27ds1YcIEZ5uXl5eioqIUFxeX5Zi4uDiNGzfOpa179+5avnx5tvtJTU1Vamqqczk5OVnSr29EAQBA0XX9tTq/rwsiNAIAACjizp49K4fDoeDgYJf24OBgHThwIMsxiYmJWfZPTEzMdj+xsbGaPHmypT0sLCwPVQMAgML2888/KyAgIN+2R2gEAAAASdKECRNcrk5KSkpS7dq1lZCQkK9vQOG+lJQUhYWF6fjx43xU0IM4D0UH56Lo4FwUDcnJyapVq5YqV66cr9slNAIAACjiqlatKm9vb506dcql/dSpUwoJCclyTEhIiFv9Jclut8tut1vaAwIC+EWgiPD39+dcFAGch6KDc1F0cC6KBi+v/P2+M749DQAAoIjz9fVVmzZttHbtWmdbRkaG1q5dq8jIyCzHREZGuvSXpNWrV2fbHwAAIDOuNAIAACgGxo0bpyFDhqht27Zq166dZs2apUuXLmnYsGGSpMGDB6tGjRqKjY2VJD3xxBPq0qWLXn75ZfXs2VOLFy/WN998o3feeceT0wAAAMUIoREAAEAx0L9/f505c0aTJk1SYmKiWrZsqVWrVjlvdp2QkOBySXr79u31/vvv67nnntPf//531a9fX8uXL1fTpk1zvU+73a7o6OgsP7KGwsW5KBo4D0UH56Lo4FwUDQV1Hmwmv7+PDQAAAAAAAMUe9zQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAgFJs9uzZqlOnjvz8/BQREaGvv/46x/5LlixRw4YN5efnp2bNmmnlypWFVGnJ5865mDdvnjp16qTAwEAFBgYqKirqhucOuePu34nrFi9eLJvNpj59+hRsgaWIu+ciKSlJo0aNUvXq1WW323Xrrbfyb1Q+cPc8zJo1Sw0aNFDZsmUVFhamsWPH6sqVK4VUbcn11VdfqVevXgoNDZXNZtPy5ctvOGbDhg1q3bq17Ha76tWrp4ULF7q9X0IjAACAUurDDz/UuHHjFB0drR07dqhFixbq3r27Tp8+nWX/LVu26L777tMDDzygnTt3qk+fPurTp4/27t1byJWXPO6eiw0bNui+++7T+vXrFRcXp7CwMN111106ceJEIVdesrh7Hq47duyYnnrqKXXq1KmQKi353D0XaWlp6tatm44dO6aPP/5YBw8e1Lx581SjRo1Crrxkcfc8vP/++xo/fryio6O1f/9+vfvuu/rwww/197//vZArL3kuXbqkFi1aaPbs2bnqf/ToUfXs2VN33HGHdu3apTFjxmjEiBH6/PPP3dqvzRhj8lIwAAAAireIiAjddtttevPNNyVJGRkZCgsL02OPPabx48db+vfv31+XLl3SJ5984my7/fbb1bJlS82dO7fQ6i6J3D0XmTkcDgUGBurNN9/U4MGDC7rcEisv58HhcKhz584aPny4Nm7cqKSkpFxdAYCcuXsu5s6dqxkzZujAgQMqU6ZMYZdbYrl7HkaPHq39+/dr7dq1zrYnn3xSW7du1aZNmwqt7pLOZrNp2bJlOV7Z+Oyzz+rTTz91+Y+dAQMGKCkpSatWrcr1vrjSCAAAoBRKS0vT9u3bFRUV5Wzz8vJSVFSU4uLishwTFxfn0l+Sunfvnm1/5E5ezkVmly9fVnp6uipXrlxQZZZ4eT0PU6ZMUVBQkB544IHCKLNUyMu5WLFihSIjIzVq1CgFBweradOmevHFF+VwOAqr7BInL+ehffv22r59u/MjbEeOHNHKlSv1pz/9qVBqxm/y6zXbJz+LAgAAQPFw9uxZORwOBQcHu7QHBwfrwIEDWY5JTEzMsn9iYmKB1Vka5OVcZPbss88qNDTU8gsCci8v52HTpk169913tWvXrkKosPTIy7k4cuSI1q1bp4EDB2rlypU6fPiwHn30UaWnpys6Orowyi5x8nIe7r//fp09e1YdO3aUMUZXr17Vww8/zMfTPCC71+yUlBT98ssvKlu2bK62w5VGAAAAQDE2bdo0LV68WMuWLZOfn5+nyyk1Lly4oEGDBmnevHmqWrWqp8sp9TIyMhQUFKR33nlHbdq0Uf/+/fWPf/yDj84Wsg0bNujFF1/UW2+9pR07dmjp0qX69NNP9fzzz3u6NOQRVxoBAACUQlWrVpW3t7dOnTrl0n7q1CmFhIRkOSYkJMSt/sidvJyL62bOnKlp06ZpzZo1at68eUGWWeK5ex5++OEHHTt2TL169XK2ZWRkSJJ8fHx08OBB1a1bt2CLLqHy8neievXqKlOmjLy9vZ1tjRo1UmJiotLS0uTr61ugNZdEeTkPEydO1KBBgzRixAhJUrNmzXTp0iU9+OCD+sc//iEvL65bKSzZvWb7+/vn+iojiSuNAAAASiVfX1+1adPG5WalGRkZWrt2rSIjI7McExkZ6dJfklavXp1tf+ROXs6FJE2fPl3PP/+8Vq1apbZt2xZGqSWau+ehYcOG2rNnj3bt2uV83H333c5vKgoLCyvM8kuUvPyd6NChgw4fPuwM7iTp+++/V/Xq1QmM8igv5+Hy5cuWYOh6kMd3cBWufHvNNgAAACiVFi9ebOx2u1m4cKH57rvvzIMPPmgqVapkEhMTjTHGDBo0yIwfP97Zf/PmzcbHx8fMnDnT7N+/30RHR5syZcqYPXv2eGoKJYa752LatGnG19fXfPzxx+bkyZPOx4ULFzw1hRLB3fOQ2ZAhQ0zv3r0LqdqSzd1zkZCQYCpWrGhGjx5tDh48aD755BMTFBRkXnjhBU9NoURw9zxER0ebihUrmg8++MAcOXLEfPHFF6Zu3bqmX79+nppCiXHhwgWzc+dOs3PnTiPJvPLKK2bnzp0mPj7eGGPM+PHjzaBBg5z9jxw5YsqVK2eefvpps3//fjN79mzj7e1tVq1a5dZ++XgaAABAKdW/f3+dOXNGkyZNUmJiolq2bKlVq1Y5b5yZkJDg8j/G7du31/vvv6/nnntOf//731W/fn0tX75cTZs29dQUSgx3z8WcOXOUlpamvn37umwnOjpaMTExhVl6ieLueUDBcfdchIWF6fPPP9fYsWPVvHlz1ahRQ0888YSeffZZT02hRHD3PDz33HOy2Wx67rnndOLECVWrVk29evXS1KlTPTWFEuObb77RHXfc4VweN26cJGnIkCFauHChTp48qYSEBOf68PBwffrppxo7dqxee+011axZU//v//0/de/e3a392ozhGjEAAAAAAAC4IiYHAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCI6AEGDp0qOrUqePpMjzqZo7B0KFDVaFChfwtCAAAeAzvjXhvBCB/EBoBhSQmJkY2m01nz57Ncn3Tpk3VtWvXwi0Kbrl8+bJiYmK0YcOGQt/3Rx99JJvNpmXLllnWtWjRQjabTevXr7esq1Wrltq3b18YJQIA4BbeGxV/nnxvdN2ePXvUt29f1a5dW35+fqpRo4a6deumN954I9fbmD59umw2m3bu3OnSboxRYGCgbDabjh496rLuypUrstvtuv/++/NlHkBRRWgElADz5s3TwYMHPV2GRxXGMbh8+bImT57skTdGHTt2lCRt2rTJpT0lJUV79+6Vj4+PNm/e7LLu+PHjOn78uHMsAAClBe+NSv57I0nasmWL2rZtq927d2vkyJF68803NWLECHl5eem1117L9Xaye5+1b98+JSUlZfk+a9u2bUpLS+N9Fko8H08XAODmlSlTxtMleFxJPwahoaEKDw+3vJmJi4uTMUb33nuvZd315ZzezGzYsEF33HGHjh49Wuov4wcAlBwl/X1BbpSGYzB16lQFBARo27ZtqlSpksu606dP53o7bdu2lZ+fnzZt2qTHHnvM2b5582ZVqVJFbdu21aZNm/S3v/3NuS4377MWLlyoYcOGyRiT61qAooYrjYAiasOGDbLZbProo480depU1axZU35+frrzzjt1+PBhl75ZfWY9KSlJQ4cOVUBAgCpVqqQhQ4Zo165dstlsWrhwobNf165ds7z0O6ttZmRkaNasWWrSpIn8/PwUHByshx56SOfPn89xLitWrJDNZtO3337rbPv3v/8tm82mv/71ry59GzVqpP79+7u0LVq0SG3atFHZsmVVuXJlDRgwQMePH79hvT///LMGDRokf39/5zHYvXu35Rhcd+LECfXp00cVKlRQtWrV9NRTT8nhcEiSjh07pmrVqkmSJk+eLJvNJpvNppiYGElSYmKihg0bppo1a8put6t69erq3bu3jh07luOxcUfHjh21c+dO/fLLL862zZs3q0mTJurRo4f+97//KSMjw2WdzWZThw4d8q0GAAA8hfdGv+G90a9++OEHNWnSxBIYSVJQUFCut+Pr66vbbrvNcjXR5s2bFRkZqQ4dOmS5rlKlSmratGmeageKC0IjoIibNm2ali1bpqeeekoTJkzQ//73Pw0cODDHMcYY9e7dW//617/0t7/9TS+88IJ+/PFHDRky5KZqeeihh/T000+rQ4cOeu211zRs2DC999576t69u9LT07Md17FjR9lsNn311VfOto0bN8rLy8vl6pgzZ87owIED6ty5s7Nt6tSpGjx4sOrXr69XXnlFY8aM0dq1a9W5c2clJSVlu8+MjAz16tVLH3zwgYYMGaKpU6fq5MmT2R4Dh8Oh7t27q0qVKpo5c6a6dOmil19+We+8844kqVq1apozZ44k6S9/+Yv+9a9/6V//+pfzjd0999yjZcuWadiwYXrrrbf0+OOP68KFC0pISLjxgc2ljh07Kj09XVu3bnW2bd68We3bt1f79u2VnJysvXv3uqxr2LChqlSpkm81AADgabw34r3RdbVr19b27dtd3v/kVceOHXXixAmXUOv377Ouf1RN+vXnacuWLYqMjJSXF79So4QzAApFdHS0kWTOnDmT5fomTZqYLl26OJfXr19vJJlGjRqZ1NRUZ/trr71mJJk9e/Y424YMGWJq167tXF6+fLmRZKZPn+5su3r1qunUqZORZBYsWOBs79Kli8t+s9vmxo0bjSTz3nvvufRbtWpVlu1Zza9fv37O5datW5t7773XSDL79+83xhizdOlSI8ns3r3bGGPMsWPHjLe3t5k6darLtvbs2WN8fHxc2jPX++9//9tIMrNmzXK2ORwO84c//MFyDIYMGWIkmSlTprjsp1WrVqZNmzbO5TNnzhhJJjo62qXf+fPnjSQzY8aMHI/Bzdq3b5+RZJ5//nljjDHp6emmfPny5p///Kcxxpjg4GAze/ZsY4wxKSkpxtvb24wcOTLHbV7/OTt69GiB1g4AQGa8N+K90c364osvjLe3t/H29jaRkZHmmWeeMZ9//rlJS0tze1uffvqpkWT+9a9/GWOMOXnypJFkvvzyS3PhwgXj7e1tPv30U2OMMXv37jWSLOchswULFhh+5UZxRywKFHHDhg2Tr6+vc7lTp06SpCNHjmQ7ZuXKlfLx8dEjjzzibPP29nb5jLa7lixZooCAAHXr1k1nz551Ptq0aaMKFSpk+c1dv9epUydt3LhRknThwgXt3r1bDz74oKpWreps37hxo8tlvkuXLlVGRob69evnss+QkBDVr18/x32uWrVKZcqU0ciRI51tXl5eGjVqVLZjHn74YUvNOR3n68qWLStfX19t2LDhhpej34xGjRqpSpUqzv+B3L17ty5duuT8drT27ds7L52Oi4uTw+GwfM4+OTnZ5VgmJydLks6fP+/SfvHixQKbBwAAN4P3Rrw3uq5bt26Ki4vT3Xffrd27d2v69Onq3r27atSooRUrVri1rfbt27tc6bV582aVKVNGt912mypUqKDmzZs732ddf878Piu791O/bzt79qwuX758s1MHCk2pDI2++uor9erVS6GhobLZbFq+fLnb2zDGaObMmbr11ltlt9tVo0YNTZ06Nf+LRalis9ksbbVq1XJZDgwMlKQcX4Dj4+NVvXp1VahQwaW9QYMGea7t0KFDSk5OVlBQkKpVq+byuHjx4g1vNtipUyedPHlShw8f1pYtW2Sz2RQZGenyhmnjxo3q0KGD8zLfQ4cOyRij+vXrW/a5f//+HPd5/RiUK1fOpb1evXpZ9vfz83N+Lv+6wMDAXL3Rsdvteumll/TZZ58pODhYnTt31vTp05WYmJjjuF9++UWJiYkuj5zYbDa1b9/eee+izZs3KygoyDmn34dG2b2Z6d27t8tx7NOnjySpdevWLu2jR4++4bwBlC68f4In8N6I90Y3ctttt2np0qU6f/68vv76a02YMEEXLlxQ37599d13391w/HWVKlVSkyZNXN5LtWrVSmXLlpVkfZ/l6+urdu3auWyjVatWLufkeiiZ+VxNnz4913UBnlYqvz3t0qVLatGihYYPH2650VxuPfHEE/riiy80c+ZMNWvWTOfOndO5c+fyuVKUJH5+fpLkchPj37t8+bKzz+95e3tn2d/k07cw2Gy2LLd1/SaH12VkZCgoKEjvvfdeltvJ/KYis+vhxVdffaUjR46odevWKl++vDp16qTXX39dFy9e1M6dO11+ecjIyJDNZtNnn32W5XHI/MbvZmR3nHNrzJgx6tWrl5YvX67PP/9cEydOVGxsrNatW6dWrVplOebDDz/UsGHDXNpudF47duyo//73v9qzZ4/zc/bXtW/fXk8//bROnDihTZs2KTQ0VLfccovL+Jdfftnlzd7u3bv11FNPadGiRQoODna2h4aG5nruAEoH3j8hv/HeiPdGmeXlvdF1129mfdttt+nWW2/VsGHDtGTJEkVHR+e65o4dO2ru3LlKSkrK8n3W/PnzlZ6erk2bNqlNmzaWn8/33nvP5ef5iy++0IwZM7R69WqXfpnfnwFFWakMjXr06KEePXpkuz41NVX/+Mc/9MEHHygpKUlNmzbVSy+95PwWhf3792vOnDnau3ev838nwsPDC6N0FGO1a9eWJB08eFBhYWEu6y5fvqzjx4/rrrvuyrd9rV27VhcvXnR583Dw4EFL38DAwCwvM46Pj3dZrlu3rtasWaMOHTo4/8fFHbVq1VKtWrW0ceNGHTlyxHkpeefOnTVu3DgtWbJEDofD5UaPdevWlTFG4eHhuvXWW93aX+3atbV+/XpdvnzZ5X/UMn+7ijuy+t/O36tbt66efPJJPfnk/2/vzuOjqPK9j387ZAE0HUAJAY2AoCwqsniNCTioBFF5KZlBGZUrmwHnihsOLjxXTYM+JlcYcfTiMiJh5kHF0QuRcRhHFtERkEGEEVG5IJC4EJwRkgBKyHKePyAtnepOUkUv6c7n/Xr1q6mqc+r8TlUvP36p7v61duzYof79++s3v/mNFi1a5Lf9iBEjLElEY+oSzA8++EBr167VPffc4902aNAgJSUlac2aNdqwYYOuueYaS/9Bgwb5LMfHH3sbGDx4sOUXVgDgRORPCDZyI3Kj+pzkRv5cdNFFkqS9e/fa6jdkyBA999xzWrlypTZv3qz77rvPuy0rK0s//vij/vznP2vXrl0aPXq0pX/9X6z9+uuvJUnZ2dl2pwA0Gy3y42mNueOOO7R+/XotXrxYn3zyiW644QZdddVV2rFjhyTpT3/6k84++2y99dZb6t69u7p166bc3Fz+UoYGDRs2TImJiXruued8fhZdkn73u9+purq6wWTcjmuuuUbV1dXeX7SQjv117JlnnrG07dGjh7744gv985//9K77xz/+YflZ0TFjxqimpkaPPvqoZR/V1dUN/lpHnUsvvVSrV6/W3//+d29i1L9/fyUnJ6ugoEBt2rTxKWr84he/UKtWrTRz5kzLX5mMMfr+++8DjlX3qyUvvviid11tba3mzZvXaJyB1CVY9ef6ww8/6MiRIz7revTooeTkZFVWVgbcX+fOnZWdne1za8xFF12k1q1b6+WXX9Y333zj8xewpKQkDRw4UPPmzdPhw4ctH00DgFAif4Jd5EbkRvXZzY3effddv1ciLV++XJL9jx/W5U5PPvmkqqqqfPKsbt26qXPnzt6PlpFnoaVokVcaNaSkpESFhYUqKSnxfjxj+vTpevvtt1VYWKjHH39cu3btUnFxsV5//XX94Q9/UE1NjaZNm6brr79eq1evjvAM0FylpqbqkUce0UMPPaSf/exnuu6669S2bVutW7dOr776qq688kpde+21QRnr2muv1eDBg/Xggw9qz5496tu3r5YsWeL90uMTTZo0SU8++aRGjBihW2+9Vd99952ef/55nXfeeaqoqPC2Gzp0qG677Tbl5+dry5YtuvLKK5WQkKAdO3bo9ddf129/+1tdf/31DcZ16aWX6uWXX5bL5fK+0bZq1UpZWVn661//qssuu8zniy179Oihxx57TDNmzNCePXuUk5Oj5ORk7d69W0uXLtWUKVM0ffp0v2Pl5OTo4osv1q9//Wvt3LlTvXv31rJly7z/OWnsL2P+tGnTRn379tVrr72mc889Vx06dND555+v6upqDRs2TGPGjFHfvn0VHx+vpUuXat++fbrxxhttj9OQukuv//a3vykpKcly5VBWVpZ+85vfSCKZARA+5E9wgtyI3Ohk3Xnnnfrhhx/085//XL1799bRo0e1bt06vfbaa+rWrZvlo26NOeuss5Senq7169erW7dulo/rZ2Vl6X/+53/kcrksVxUBMSvsv9fWzEgyS5cu9S6/9dZbRpI55ZRTfG7x8fHen8ScPHmykWS2b9/u7bdp0yYjyXzxxRfhngKizKJFi8wll1xiTjnlFJOUlGR69+5tZs6caY4cOeLTru5nZV9//XWf9bt37/b7s6gn/qSqMcZ8//335pZbbjFut9ukpKSYW265xWzevNnSty6ms88+2yQmJpr+/fubv/71r373aYwxv/vd78ygQYNMmzZtTHJysrngggvM/fffb7799ttG5173k/F9+vTxWf/YY48ZSebhhx/22+9//ud/zJAhQ7zPx969e5upU6f6PAf9xfvPf/7T3HzzzSY5OdmkpKSYCRMmmLVr1xpJZvHixT59TznlFMu4dT8FfKJ169aZQYMGmcTERO9PzP7rX/8yU6dONb179zannHKKSUlJMRkZGeaPf/xjo8fEiRkzZhhJJisry7Kt7qd5k5OTTXV1daP7qnuc7d69OwSRAohV5E8IJnIjciOn/vKXv5hJkyaZ3r17m1NPPdUkJiaanj17mjvvvNPs27fP0T5vuukmI8ncfPPNlm1PPvmk3/MVSGFhoeV4AdHGZUyQvjEuSrlcLi1dutT7C0Kvvfaaxo4dq23btlm+/O3UU09VWlqa8vLy9Pjjj6uqqsq77ccff1Tbtm31zjvvaPjw4eGcAtBke/bsUffu3VVYWKgJEyZEOpyIKCoq0s9//nN98MEH/IUIABwif0KsIDciNwLQMD6eVs+AAQNUU1Oj7777zvu54voGDx6s6upqffnll+rRo4ck6X//938l/fSFfgAi78cff/T5Ysq67y5wu90aOHBgBCMDgNhC/gREB3IjAHa1yKLRoUOHfH4lYPfu3dqyZYs6dOigc889V2PHjtW4ceP0m9/8RgMGDNA///lPrVq1Sv369dPIkSOVnZ2tgQMHatKkSXrqqadUW1urqVOnavjw4bZ/xQBA6Nx555368ccflZmZqcrKSi1ZskTr1q3T448/7uhXTgCgJSN/AqJfS8yNysvL9eOPPzbYJi0tLUzRAFEo0p+Pi4S6z0PXv40fP94YY8zRo0fNI488Yrp162YSEhJM586dzc9//nPzySefePfxzTffmF/84hfm1FNPNZ06dTITJkww33//fYRmBDSNv8/8x7KXX37ZDBw40LjdbpOYmGj69u1rnnnmmUiHBQBRifwJsYjcKPZzo/Hjx/t97TrxBiCwFv+dRgAAAACA2PTZZ5/p22+/bbBNdnZ2mKIBog9FIwAAAAAAAFjERToAAAAAAAAAND8t5ouwa2tr9e233yo5OVkulyvS4QAAgACMMTp48KC6dOmiuDj+vhVJ5E8AAESHUOVPLaZo9O233yo9PT3SYQAAgCb66quvdOaZZ0Y6jBaN/AkAgOgS7PypxRSNkpOTJR07gG63O8LRAACAQCoqKpSenu5970bkkD8BABAdQpU/tZiiUd0l1W63m6QHAIAowMehIo/8CQCA6BLs/IkvCgAAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACARbydxt26dVNxcbFl/e2336558+ZZ1i9cuFATJ070WZeUlKQjR45IkqqqqvTQQw9p+fLl2rVrl1JSUpSdna2CggJ16dKlwXHz8/P14IMP2gk/LFwuT6RDiKxcT+jHmB/6MYwJ/RgAgJaB/KlxrrWRjiDCisIwRk7ohzCDQz8GACC8bBWNNm7cqJqaGu/yp59+quHDh+uGG24I2Mftdmv79u3eZZfL5f33Dz/8oI8//lgPP/ywLrzwQh04cEB33323rrvuOn300Uc++5k1a5YmT57sXU5OTrYTOgAAQESQPwEAgGhlq2jUsWNHn+WCggL16NFDQ4cODdjH5XIpLS3N77aUlBStWLHCZ91///d/6+KLL1ZJSYnOOuss7/rk5OSA+wEAAGiuyJ8AAEC0cvydRkePHtWiRYs0adIkn79+1Xfo0CF17dpV6enpGjVqlLZt29bgfsvLy+VyudSuXTuf9QUFBTrttNM0YMAAzZ49W9XV1Q3up7KyUhUVFT43AACASCJ/AgAA0cTWlUYnKioqUllZmSZMmBCwTa9evbRgwQL169dP5eXlmjNnjrKysrRt2zadeeaZlvZHjhzRAw88oJtuuklut9u7/q677tLAgQPVoUMHrVu3TjNmzNDevXv15JNPBhw7Pz9fM2fOdDo9AACAoCN/AgAA0cRljDFOOo4YMUKJiYn605/+1OQ+VVVV6tOnj2666SY9+uijlm2jR4/W119/rTVr1vgkPfUtWLBAt912mw4dOqSkpCS/bSorK1VZWeldrqioUHp6usrLyxvc98nii7A9oR+DL8IGgJhWUVGhlJSUkL9nRwL5k398EXYYxsgJ/RB8ETYARE6o8idHVxoVFxdr5cqVWrJkia1+CQkJGjBggHbu3OmzvqqqSmPGjFFxcbFWr17d6AQzMjJUXV2tPXv2qFevXn7bJCUlBUyIAAAAwo38CQAARBtH32lUWFio1NRUjRw50la/mpoabd26VZ07d/auq0t4duzYoZUrV+q0005rdD9btmxRXFycUlNTbccOAAAQCeRPAAAg2ti+0qi2tlaFhYUaP3684uN9u48bN05nnHGG8vPzJR37mddLLrlEPXv2VFlZmWbPnq3i4mLl5uZKOpbwXH/99fr444/11ltvqaamRqWlpZKkDh06KDExUevXr9eGDRt0+eWXKzk5WevXr9e0adP07//+72rfvv3Jzh8AACDkyJ8AAEA0sl00WrlypUpKSjRp0iTLtpKSEsXF/XTx0oEDBzR58mSVlpaqffv2GjRokNatW6e+fftKkr755hstW7ZMktS/f3+ffb377ru67LLLlJSUpMWLF8vj8aiyslLdu3fXtGnTdO+999oNHQAAICLInwAAQDRy/EXY0SZcX6rJF2F7Qj8GX4QNADEtlr8IO9qELX/ii7BDLyf0Q/BF2AAQOaF6z3b0nUYAAAAAAACIbY5+PQ0NcHKlzfwwXOyV6wr9GOHi6Bjb69PirxgLA67mAgB4FTnoM8cT5CD8mB6GMcKlyEGfHHvNW/wVY2HA1VwAwo0rjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYuY4yJdBDhUFFRoZSUFJWXl8vtdodsHJcrhg5nrivSEUTOGw76lHmCHQUiwBhPpEMAWrxwvWejceHLnzwh23fYTfdEOoKIMZfbzx1dKTGUO7dgZnCkIwAQqvdsrjQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYxEc6gJiT64p0BAiG6x30ecNjv0+Zgz4IKZfLE+kQ/DLGE+kQACB0pnsiHQGCwPWusd3HXG4/d3al2B8HoeVaG+kI/DODIx0BEP240ggAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABbxkQ4g5sz32O+T66APmp/rnXTy2Gv+hoMhymyOgWbJ5fJEOgS/jPFEOgQAsSDHQZ+iIMeAiHC9a0I+hrncZbuPKyX0cSH0XGsjHYF/ZnCkIwCajiuNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFvF2Gnfr1k3FxcWW9bfffrvmzZtnWb9w4UJNnDjRZ11SUpKOHDkiSaqqqtJDDz2k5cuXa9euXUpJSVF2drYKCgrUpUsXb5/9+/frzjvv1J/+9CfFxcVp9OjR+u1vf6tTTz3VTvhA9LveQZ83PPb7lDnogxbJ5fI46JUX7DAsjHGFfAygqcifgMhyvWts9zGX238fcaXYHwctk2utg05DPMEOw8KY0I+B6GOraLRx40bV1NR4lz/99FMNHz5cN9xwQ8A+brdb27dv9y67XD+9AP/www/6+OOP9fDDD+vCCy/UgQMHdPfdd+u6667TRx995G03duxY7d27VytWrFBVVZUmTpyoKVOm6JVXXrETPgAAQNiRPwEAgGhlq2jUsWNHn+WCggL16NFDQ4cODdjH5XIpLS3N77aUlBStWLHCZ91///d/6+KLL1ZJSYnOOussff7553r77be1ceNGXXTRRZKkZ555Rtdcc43mzJnj8xc1AACA5ob8CQAARCvH32l09OhRLVq0SJMmTfL561d9hw4dUteuXZWenq5Ro0Zp27ZtDe63vLxcLpdL7dq1kyStX79e7dq18yY8kpSdna24uDht2LAh4H4qKytVUVHhcwMAAIgk8icAABBNHBeNioqKVFZWpgkTJgRs06tXLy1YsEBvvvmmFi1apNraWmVlZenrr7/22/7IkSN64IEHdNNNN8ntdkuSSktLlZqa6tMuPj5eHTp0UGlpacCx8/PzlZKS4r2lp6fbnyQAAEAQkT8BAIBo4rho9NJLL+nqq69u8PLmzMxMjRs3Tv3799fQoUO1ZMkSdezYUS+88IKlbVVVlcaMGSNjjJ577jmnYXnNmDFD5eXl3ttXX3110vsEAAA4GeRPAAAgmtj6TqM6xcXFWrlypZYsWWKrX0JCggYMGKCdO3f6rK9LeIqLi7V69WrvX8kkKS0tTd99951P++rqau3fvz/gZ/2lY78ykpSUZCs+AACAUCF/AgAA0cbRlUaFhYVKTU3VyJEjbfWrqanR1q1b1blzZ++6uoRnx44dWrlypU477TSfPpmZmSorK9OmTZu861avXq3a2lplZGQ4CR8AACDsyJ8AAEC0sX2lUW1trQoLCzV+/HjFx/t2HzdunM444wzl5+dLkmbNmqVLLrlEPXv2VFlZmWbPnq3i4mLl5uZKOpbwXH/99fr444/11ltvqaamxvs5+w4dOigxMVF9+vTRVVddpcmTJ+v5559XVVWV7rjjDt1444388gcAAIgK5E8AACAa2S4arVy5UiUlJZo0aZJlW0lJieLifrp46cCBA5o8ebJKS0vVvn17DRo0SOvWrVPfvn0lSd98842WLVsmSerfv7/Pvt59911ddtllkqSXX35Zd9xxh4YNG6a4uDiNHj1aTz/9tN3QAQAAIoL8CQAARCOXMcZEOohwqKioUEpKisrLy30+8x9sLpfHfqdcB32ApnrDQZ8yT7CjAE6QF/IRjAn8U+Zo/sL1no3GhS1/WuugU1GwowB+Yi63/z7iSmkR/61CpAzxhHwIY0I/BkInVO/Zjn89DQAAAAAAALGLohEAAAAAAAAsbH+nERrh5KNm8x304SNtzc98B5ck54bhIzTXO+jzhsdeez7OhmbG5QrHRwRmhmEMLhVHC1HkoE9OmMZBaM3x2O8z3UEfm1zv2n8fsfuRNj7OhubG0Vet2PVBGMaQZAaHZZgWgSuNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgER/pAGLOfOOgU17Qw7CY77HfJ9dBn3BwMhe7muvcgZgwMwxjhOF11dEY9ufucnkcjBN6xngiHQJiyRyPgz4Oxpluc5wcB2MUOegTDjlhGKMoDGMALdUHntCPMaSZjuFg7q619ocJBzM40hHYx5VGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC5cxxkQ6iHCoqKhQSkqKysvL5Xa7QzaOa7KDTvOdnIKZ9prneuwPMd9BH7vjOJq7EzaPl/LsD5Hrst8nVrzhoE+ZJ9hRACfJwfM+LOy+fjVPxnia3DZc79loXNjyp/scdJrjsd/nA5t9iuwPoRwHfeyO42TuTtg9XkNstpek6Q76xAhzuf3c0ZXSIv7rhmji5HkfDnZfv5opM7jpbUP1ns2VRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAIv4SAcASbkuB5089prPt9k+bGba75Lrsd9nvt0xnJwTANHN7utRXkiiANBE0z32+xTZbJ9jf4iw+MBjv09RsIPww8k5ARDd7L4eDbHZHhHHlUYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCIt9O4W7duKi4utqy//fbbNW/ePMv6hQsXauLEiT7rkpKSdOTIEe/ykiVL9Pzzz2vTpk3av3+/Nm/erP79+/v0ueyyy/Tee+/5rLvtttv0/PPP2wk/POZ77PfJddCnubI7/+Y69/nGfp9cV/DjiGXtPPb7lDnoAwARRv7UBDkO+hQFOYZIyrHZvigEMQTDHI/9PtMd9GnBTLn9fNOV4iCvBYDjbBWNNm7cqJqaGu/yp59+quHDh+uGG24I2Mftdmv79u3eZZfL94Xu8OHDGjJkiMaMGaPJkycH3M/kyZM1a9Ys73Lbtm3thA4AABAR5E8AACBa2SoadezY0We5oKBAPXr00NChQwP2cblcSktLC7j9lltukSTt2bOnwbHbtm3b4H4AAACaI/InAAAQrRx/p9HRo0e1aNEiTZo0yfLXrxMdOnRIXbt2VXp6ukaNGqVt27Y5Gu/ll1/W6aefrvPPP18zZszQDz/84DR0AACAiCB/AgAA0cTWlUYnKioqUllZmSZMmBCwTa9evbRgwQL169dP5eXlmjNnjrKysrRt2zadeeaZTR7r5ptvVteuXdWlSxd98skneuCBB7R9+3YtWbIkYJ/KykpVVlZ6lysqKpo8HgAAQCiQPwEAgGjiuGj00ksv6eqrr1aXLl0CtsnMzFRmZqZ3OSsrS3369NELL7ygRx99tMljTZkyxfvvCy64QJ07d9awYcP05ZdfqkePHn775Ofna+bMmU0eAwAAINTInwAAQDRx9PG04uJirVy5Urm5ubb6JSQkaMCAAdq5c6eTYb0yMjIkqcH9zJgxQ+Xl5d7bV199dVJjAgAAnAzyJwAAEG0cFY0KCwuVmpqqkSNH2upXU1OjrVu3qnPnzk6G9dqyZYskNbifpKQkud1unxsAAECkkD8BAIBoY/vjabW1tSosLNT48eMVH+/bfdy4cTrjjDOUn58vSZo1a5YuueQS9ezZU2VlZZo9e7aKi4t9/sK2f/9+lZSU6Ntvv5Uk78/LpqWlKS0tTV9++aVeeeUVXXPNNTrttNP0ySefaNq0afrZz36mfv36OZ44AABAuJA/AQCAaGS7aLRy5UqVlJRo0qRJlm0lJSWKi/vp4qUDBw5o8uTJKi0tVfv27TVo0CCtW7dOffv29bZZtmyZJk6c6F2+8cYbJUl5eXnyeDxKTEzUypUr9dRTT+nw4cNKT0/X6NGj9dBDD9kNHQAAICLInwAAQDSyXTS68sorZYzxu23NmjU+y3PnztXcuXMb3N+ECRMa/AWR9PR0vffee3bDBAAAaDbInwAAQDRy9J1GAAAAAAAAiG0UjQAAAAAAAGBh++NpaESuJzzjzA/TOKEWK/No6a4P0zhveOy1dxIXj0kACL+iMI2TE6ZxQi0n0gEgGFzv+v/IarCZy1222juKK8d+FwDRgSuNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFi5jjIl0EOFQUVGhlJQUlZeXy+12h2wcl8sTsn3HpFxPeMaZb/NhnutyMIbHfp9wzb+leiPSAURYmSfSEcAiLwxjzAzDGPYZ42ly23C9Z6NxYcuf1oZs17GpKEzjzPHYaz/dZntJyrHfJWzzb6HM5Q7y4BjiSmkR/z2OLkM8oR/jgzCM4YAZ3PS2oXrP5kojAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYxEc6AIRJrifSEfg334RnnFxXGMbwhH4M2HO9gz5vBD2KyAnHY9LJ8SrzBDuKCMkL0zgzwzQOAIuiSAcQwBxPeMaZHoZxikI/BOxxvWs/PzeXhyHXDpei0A/h5Hi5UsL0/6ZQG+IJzzgfhGmcFoArjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABbxkQ4g5uR6Ih2Bf/M99vs017nkukI/RiwdL9hTZuz3aReGx6QTb0Q6gADaeey1L7PZvlmbGekAgOapKNIBBJDjoE9RkGMIlume0I+R46BPUZBjQES4RubZ7mP+3DzfE83lzTOvM+X24nKlOMhpm6sPPJGOoEXjSiMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIBFvJ3G3bp1U3FxsWX97bffrnnz5lnWL1y4UBMnTvRZl5SUpCNHjniXlyxZoueff16bNm3S/v37tXnzZvXv39+nz5EjR/TrX/9aixcvVmVlpUaMGKFnn31WnTp1shN+eMz32O+T66CP3XGcjBEOua5IRxBZTh4vdjXXc+9Ec33cX2+z/RshicKqzBP6MdqFYYxwvEY6MjMMYyAWkD81QY6DPkVhGMfJGOEw3RPpCCIrJwxjFIVhjHDJsdm+KAQx+OF619hqby4Pz/8bXCn24nLClIdhLkUO+uQEOQZ/PvCEYRAEk60rjTZu3Ki9e/d6bytWrJAk3XDDDQH7uN1unz71k6bDhw9ryJAh+q//+q+A+5g2bZr+9Kc/6fXXX9d7772nb7/9Vr/4xS/shA4AABAR5E8AACBa2brSqGPHjj7LBQUF6tGjh4YOHRqwj8vlUlpaWsDtt9xyiyRpz549freXl5frpZde0iuvvKIrrrhCklRYWKg+ffroww8/1CWXXGJnCgAAAGFF/gQAAKKV4+80Onr0qBYtWqRJkybJ5Qp8ed2hQ4fUtWtXpaena9SoUdq2bZutcTZt2qSqqiplZ2d71/Xu3VtnnXWW1q9fH7BfZWWlKioqfG4AAACRRP4EAACiieOiUVFRkcrKyjRhwoSAbXr16qUFCxbozTff1KJFi1RbW6usrCx9/fXXTR6ntLRUiYmJateunc/6Tp06qbS0NGC//Px8paSkeG/p6elNHhMAACAUyJ8AAEA0cVw0eumll3T11VerS5cuAdtkZmZq3Lhx6t+/v4YOHaolS5aoY8eOeuGFF5wO22QzZsxQeXm59/bVV1+FfEwAAICGkD8BAIBoYus7jeoUFxdr5cqVWrJkia1+CQkJGjBggHbu3NnkPmlpaTp69KjKysp8/lq2b9++Bj/rn5SUpKSkJFvxAQAAhAr5EwAAiDaOrjQqLCxUamqqRo4caatfTU2Ntm7dqs6dOze5z6BBg5SQkKBVq1Z5123fvl0lJSXKzMy0NT4AAECkkD8BAIBoY/tKo9raWhUWFmr8+PGKj/ftPm7cOJ1xxhnKz8+XJM2aNUuXXHKJevbsqbKyMs2ePVvFxcXKzc319tm/f79KSkr07bffSjqW0EjH/kKWlpamlJQU3Xrrrbr33nvVoUMHud1u3XnnncrMzOSXPwAAQFQgfwIAANHIdtFo5cqVKikp0aRJkyzbSkpKFBf308VLBw4c0OTJk1VaWqr27dtr0KBBWrdunfr27etts2zZMk2cONG7fOONN0qS8vLy5PF4JElz585VXFycRo8ercrKSo0YMULPPvus3dABAAAigvwJAABEI9tFoyuvvFLGGL/b1qxZ47M8d+5czZ07t8H9TZgwocFfEJGk1q1ba968eZo3b56dUAEAAJoF8icAABCNHP96GgAAAAAAAGIXRSMAAAAAAABY2P54GhqR67HfZ77/y9UbluegD0JqvifSEUSXcBwvR2M4eG694WAYu8o8YRikmQrH8QUQWUUO+szxOOhjs/10B2PAnpxIBxBlcprpGHafW5LM5S4HA9njSnHy/6zY4OT4utRyjxcC40ojAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYxEc6gFiTN99lu8/MXBOCSCJkvsde+1yb7cPFSVx25x4uzTWu5qqd/eewbWWe0I/hRLge9+0c9AEQ0/LmOMifpsdQ/pRjs31RCGIIhiIHfXKCHEOw5EQ6gOhi/jwz5GO4Uprpc77IfhdXjv25mPIw5KiAH1xpBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsHAZY0ykgwiHiooKpaSkqLy8XG63O2TjuCbb75M332W7z8zcFnHaIme+k+M7M+hhACcl1xPpCILjjTCNU+YJ00AtkzGeJrcN13s2Ghe2/Ok++33y5jjIn6aTP4XUHI/9Ph846AOEUlGkAwgOc7n910gnXCm8roaSGdz0tqF6z+ZKIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgIXLGGMiHUQ4VFRUKCUlReXl5XK73SEbx+Vqpocz1xXpCIJnfjiO8cwwjIGQy/VEOgL/5nsiHYF/zfV4OdFcj3ELZoynyW3D9Z6NxoUvf/KEbN8nZbon0hEEzxxP6Mf4IAxjIPSKIh1AADmRDiCAokgHEEQ5kQ4A9ZnBTW8bqvdsrjQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIBFvJ3G3bp1U3FxsWX97bffrnnz5lnWL1y4UBMnTvRZl5SUpCNHjniXjTHKy8vTiy++qLKyMg0ePFjPPfeczjnnnAbHzc/P14MPPmgn/JZtvrHfJ9cV/Djqm+8J/RhALMj1RDqC6OLkePF6hBAhf4piczz2+0x30MeuHCd9PEEOAogCRZEOIMoUOeiTE+QY0OzYKhpt3LhRNTU13uVPP/1Uw4cP1w033BCwj9vt1vbt273LLpdvIeKJJ57Q008/rd///vfq3r27Hn74YY0YMUKfffaZWrdu7W03a9YsTZ482bucnJxsJ3QAAICIIH8CAADRylbRqGPHjj7LBQUF6tGjh4YOHRqwj8vlUlpamt9txhg99dRTeuihhzRq1ChJ0h/+8Ad16tRJRUVFuvHGG71tk5OTA+4HAACguSJ/AgAA0crxdxodPXpUixYt0qRJkyx//TrRoUOH1LVrV6Wnp2vUqFHatm2bd9vu3btVWlqq7Oxs77qUlBRlZGRo/fr1PvspKCjQaaedpgEDBmj27Nmqrq5uML7KykpVVFT43AAAACKJ/AkAAEQTW1canaioqEhlZWWaMGFCwDa9evXSggUL1K9fP5WXl2vOnDnKysrStm3bdOaZZ6q0tFSS1KlTJ59+nTp18m6TpLvuuksDBw5Uhw4dtG7dOs2YMUN79+7Vk08+GXDs/Px8zZw50+n0AAAAgo78CQAARBPHRaOXXnpJV199tbp06RKwTWZmpjIzM73LWVlZ6tOnj1544QU9+uijTR7r3nvv9f67X79+SkxM1G233ab8/HwlJSX57TNjxgyffhUVFUpPT2/ymAAAAMFG/gQAAKKJo4+nFRcXa+XKlcrNzbXVLyEhQQMGDNDOnTslyfsZ+3379vm027dvX4Ofv8/IyFB1dbX27NkTsE1SUpLcbrfPDQAAIFLInwAAQLRxVDQqLCxUamqqRo4caatfTU2Ntm7dqs6dO0uSunfvrrS0NK1atcrbpqKiQhs2bPD5C1t9W7ZsUVxcnFJTU52EDwAAEHbkTwAAINrY/nhabW2tCgsLNX78eMXH+3YfN26czjjjDOXn50s69jOvl1xyiXr27KmysjLNnj1bxcXF3r+wuVwu3XPPPXrsscd0zjnneH8ytkuXLsrJyZEkrV+/Xhs2bNDll1+u5ORkrV+/XtOmTdO///u/q3379ic5fQAAgNAjfwIAANHIdtFo5cqVKikp0aRJkyzbSkpKFBf308VLBw4c0OTJk1VaWqr27dtr0KBBWrdunfr27ettc//99+vw4cOaMmWKysrKNGTIEL399ttq3bq1pGOXSS9evFgej0eVlZXq3r27pk2b5vN5ewAAgOaM/AkAAEQjlzHGRDqIcKioqFBKSorKy8tD+vl8lyuGDmdu4J8CDpr5ntCPgZYr1xPpCPxz8rhvrnOJJbwehZQxnia3Ddd7NhoXvvzJE7J9h910T+jHyAn9EGjBiiIdQAA5DvoUBTkGWOVEOoDYZgY3vW2o3rMdfacRAAAAAAAAYhtFIwAAAAAAAFjY/k4jNMyYMHykS2H6GNx8B2PY/UhbuD5yw8dOYkOsfEQrVuaBMMmz2X5mSKIAQsnOxxdPRlg+BjfHwRh2P9JWZH8IR3LCNA5CqyjSAQRJUaQDQFQZ4rHX/gOb7VsQrjQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYxEc6ADhjjCvSIfjlchl7HXKb5zzCJ89m+5khiSIicj2RjgCIEjH0vAcizBhPpEPwy+Xy2Osw3Wb7WDPEY6/9BzbbN2dFkQ4AiBKx9LyPMK40AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACARXykA0BsMcYV6RD8cs0PwyC5ntCPEY55hMt8j/0+4TjGiA1OHl8AECHGeCIdgl+utWEYpMhBn+meIAcRRXIc9CkKcgyIXTmRDgDNEVcaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALOIjHQAQDsZ4Ih2CX67JkY4AMW2+sdc+1xWaOE7WfE+kIwCAFskMDsMgDsZw3Rf8MACvOR577afbbB8uOZEOALGCK40AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBhq2jUrVs3uVwuy23q1Kl+2y9cuNDStnXr1j5tjDF65JFH1LlzZ7Vp00bZ2dnasWOHT5v9+/dr7NixcrvdateunW699VYdOnTI5lQBAADCj/wJAABEq3g7jTdu3Kiamhrv8qeffqrhw4frhhtuCNjH7XZr+/bt3mWXy+Wz/YknntDTTz+t3//+9+revbsefvhhjRgxQp999pk3QRo7dqz27t2rFStWqKqqShMnTtSUKVP0yiuv2AkfaHbMizY7vOgJRRgnzeXyRDoE+JPrarzNCWw/HsOlmT7ugaYifwKCy8yOdATB4Vob6Qjg13SPreax8ngEArFVNOrYsaPPckFBgXr06KGhQ4cG7ONyuZSWluZ3mzFGTz31lB566CGNGjVKkvSHP/xBnTp1UlFRkW688UZ9/vnnevvtt7Vx40ZddNFFkqRnnnlG11xzjebMmaMuXbrYmQIAAEBYkT8BAIBo5fg7jY4ePapFixZp0qRJlr9+nejQoUPq2rWr0tPTNWrUKG3bts27bffu3SotLVV2drZ3XUpKijIyMrR+/XpJ0vr169WuXTtvwiNJ2dnZiouL04YNGwKOW1lZqYqKCp8bAABAJJE/AQCAaOK4aFRUVKSysjJNmDAhYJtevXppwYIFevPNN7Vo0SLV1tYqKytLX3/9tSSptLRUktSpUyeffp06dfJuKy0tVWpqqs/2+Ph4dejQwdvGn/z8fKWkpHhv6enpTqYJAAAQNORPAAAgmjguGr300ku6+uqrG7y8OTMzU+PGjVP//v01dOhQLVmyRB07dtQLL7zgdNgmmzFjhsrLy723r776KuRjAgAANIT8CQAARBNb32lUp7i4WCtXrtSSJUts9UtISNCAAQO0c+dOSfJ+Vn/fvn3q3Lmzt92+ffvUv39/b5vvvvvOZz/V1dXav39/wM/6S1JSUpKSkpJsxQcAABAq5E8AACDaOLrSqLCwUKmpqRo5cqStfjU1Ndq6das3wenevbvS0tK0atUqb5uKigpt2LBBmZmZko79ta2srEybNm3ytlm9erVqa2uVkZHhJHwAAICwI38CAADRxvaVRrW1tSosLNT48eMVH+/bfdy4cTrjjDOUn58vSZo1a5YuueQS9ezZU2VlZZo9e7aKi4uVm5sr6dgvg9xzzz167LHHdM4553h/MrZLly7KycmRJPXp00dXXXWVJk+erOeff15VVVW64447dOONN/LLHwAAICqQPwEAgGhku2i0cuVKlZSUaNKkSZZtJSUliov76eKlAwcOaPLkySotLVX79u01aNAgrVu3Tn379vW2uf/++3X48GFNmTJFZWVlGjJkiN5++221bt3a2+bll1/WHXfcoWHDhikuLk6jR4/W008/bTd0AACAiCB/AgAA0chljDGRDiIcKioqlJKSovLycrnd7kiHA8QUl8sTnoFywzROC2VejHQEwDG8ZzcfnAsgdFxrwzRQUZjGaaHM7EhHABwTqvdsx7+eBgAAAAAAgNhF0QgAAAAAAAAWtr/TCADqM8YT6RAAAACiihkcpoHCNQ6AmMSVRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsIiPdADhYoyRJFVUVEQ4EgAA0JC69+q6925EDvkTAADRIVT5U4spGh08eFCSlJ6eHuFIAABAUxw8eFApKSmRDqNFI38CACC6BDt/cpkW8me82tpaffvtt0pOTpbL5Yp0OGFTUVGh9PR0ffXVV3K73ZEOJ+xa8vyZO3NvaXOXWvb8Y2nuxhgdPHhQXbp0UVwcn6SPJPKn6H8+OdGS58/cmTtzb1liaf6hyp9azJVGcXFxOvPMMyMdRsS43e6ofxKcjJY8f+bO3Fuiljz/WJk7Vxg1D+RPsfF8cqolz5+5M/eWpiXPXYqd+Ycif+LPdwAAAAAAALCgaAQAAAAAAAALikYxLikpSXl5eUpKSop0KBHRkufP3Jl7S9SS59+S5w4EW0t/PrXk+TN35t7StOS5S8y/KVrMF2EDAAAAAACg6bjSCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdGomSkoKJDL5dI999zjXfe73/1Ol112mdxut1wul8rKyiz99u/fr7Fjx8rtdqtdu3a69dZbdejQIZ82n3zyiS699FK1bt1a6enpeuKJJyz7ef3119W7d2+1bt1aF1xwgZYvX+6z3RijRx55RJ07d1abNm2UnZ2tHTt2RHTu3bp1k8vl8rkVFBRE9dz379+vO++8U7169VKbNm101lln6a677lJ5eblPv5KSEo0cOVJt27ZVamqq7rvvPlVXV/u0WbNmjQYOHKikpCT17NlTCxcutIw/b948devWTa1bt1ZGRob+/ve/+2w/cuSIpk6dqtNOO02nnnqqRo8erX379gVl7icz//rn3eVyafHixVE1f3+P+9tuu009evRQmzZt1LFjR40aNUpffPGFT79YOPdO5x6r572OMUZXX321XC6XioqKfLbFwnkHQoH8ifxJaln5U0vOnfzNXyJ/In8ifwoZg2bj73//u+nWrZvp16+fufvuu73r586da/Lz801+fr6RZA4cOGDpe9VVV5kLL7zQfPjhh+Zvf/ub6dmzp7npppu828vLy02nTp3M2LFjzaeffmpeffVV06ZNG/PCCy9426xdu9a0atXKPPHEE+azzz4zDz30kElISDBbt271tikoKDApKSmmqKjI/OMf/zDXXXed6d69u/nxxx8jNveuXbuaWbNmmb1793pvhw4diuq5b9261fziF78wy5YtMzt37jSrVq0y55xzjhk9erS3X3V1tTn//PNNdna22bx5s1m+fLk5/fTTzYwZM7xtdu3aZdq2bWvuvfde89lnn5lnnnnGtGrVyrz99tveNosXLzaJiYlmwYIFZtu2bWby5MmmXbt2Zt++fd42v/rVr0x6erpZtWqV+eijj8wll1xisrKyTmreJzt/Y4yRZAoLC33O/Ynno7nPP9Dj/oUXXjDvvfee2b17t9m0aZO59tprTXp6uqmurjbGxMa5dzp3Y2L3vNd58sknzdVXX20kmaVLl3rXx8J5B0KB/In8qaXlTy05dwo0f2PIn8ifyJ9ChaJRM3Hw4EFzzjnnmBUrVpihQ4f6fSK8++67ft/4P/vsMyPJbNy40bvuL3/5i3G5XOabb74xxhjz7LPPmvbt25vKykpvmwceeMD06tXLuzxmzBgzcuRIn31nZGSY2267zRhjTG1trUlLSzOzZ8/2bi8rKzNJSUnm1VdfjcjcjTmW9MydOzfg/qN97nX++Mc/msTERFNVVWWMMWb58uUmLi7OlJaWets899xzxu12e+d6//33m/POO89nP7/85S/NiBEjvMsXX3yxmTp1qne5pqbGdOnSxeTn53vnmZCQYF5//XVvm88//9xIMuvXr3c8d2NObv7GGMubQn3Nef525v6Pf/zDSDI7d+40xkT/uT+ZuRsT2+d98+bN5owzzjB79+61zDPazzsQCuRP5E8tLX9qybmTMeRP5E/kT5HAx9OaialTp2rkyJHKzs623Xf9+vVq166dLrroIu+67OxsxcXFacOGDd42P/vZz5SYmOhtM2LECG3fvl0HDhzwtqk//ogRI7R+/XpJ0u7du1VaWurTJiUlRRkZGd42TpzM3OsUFBTotNNO04ABAzR79myfyw1jZe7l5eVyu92Kj4/3xnzBBReoU6dOPjFXVFRo27ZtTZrX0aNHtWnTJp82cXFxys7O9rbZtGmTqqqqfNr07t1bZ5111knNXTq5+Z+4j9NPP10XX3yxFixYIGOMd1tznn9T53748GEVFhaqe/fuSk9P984rms/9ycz9xH3E2nn/4YcfdPPNN2vevHlKS0uzbI/28w6EAvkT+VNjYi1/asm5U13s5E/kTycifwq9+MabINQWL16sjz/+WBs3bnTUv7S0VKmpqT7r4uPj1aFDB5WWlnrbdO/e3adN3ROntLRU7du3V2lpqc+Tqa7Nifs4sZ+/Nnad7Nwl6a677tLAgQPVoUMHrVu3TjNmzNDevXv15JNPeuOO9rn/61//0qOPPqopU6Z41wWK+cR4A7WpqKjQjz/+qAMHDqimpsZvm7rPQZeWlioxMVHt2rWztHE6d+nk5y9Js2bN0hVXXKG2bdvqnXfe0e23365Dhw7prrvu8sbeHOfflLk/++yzuv/++3X48GH16tVLK1as8Cbu0XzuT3buUuye92nTpikrK0ujRo3yuz2azzsQCuRP5E+NibX8qSXnThL5E/kT+VOkUDSKsK+++kp33323VqxYodatW0c6nLAK1tzvvfde77/79eunxMRE3XbbbcrPz1dSUlIwQg06O3OvqKjQyJEj1bdvX3k8nvAEGGLBmv/DDz/s/feAAQN0+PBhzZ492/vm1xw1de5jx47V8OHDtXfvXs2ZM0djxozR2rVro/p1Ilhzj8XzvmzZMq1evVqbN2+OQHRA9CF/In9qaflTS86dJPIn8ifyp0ji42kRtmnTJn333XcaOHCg4uPjFR8fr/fee09PP/204uPjVVNT0+g+0tLS9N133/msq66u1v79+72X6KWlpVm+ub1uubE2J24/sZ+/NnYEY+7+ZGRkqLq6Wnv27PHGHa1zP3jwoK666iolJydr6dKlSkhI8O7jZObldrvVpk0bnX766WrVqlWjcz969Kjll1eczj1Y8/cnIyNDX3/9tSorK5vt/Js695SUFJ1zzjn62c9+pjfeeENffPGFli5d2uC86rbF8tz9iYXzvmLFCn355Zdq166dd7skjR49WpdddlmD86rb1lznDoQC+RP5U0vLn1py7mRn/uRP5E8S+VOwUTSKsGHDhmnr1q3asmWL93bRRRdp7Nix2rJli1q1atXoPjIzM1VWVqZNmzZ5161evVq1tbXKyMjwtnn//fdVVVXlbbNixQr16tVL7du397ZZtWqVz75XrFihzMxMSVL37t2Vlpbm06aiokIbNmzwtgn33P3ZsmWL4uLivJecR+vcKyoqdOWVVyoxMVHLli2zVNczMzO1detWn4R3xYoVcrvd6tu3b5PmlZiYqEGDBvm0qa2t1apVq7xtBg0apISEBJ8227dvV0lJiaO5B2v+/mzZskXt27f3/oW0Oc7fyePeHPvRAu+berSe+2DM3Z9YOO//+Z//qU8++cRnuyTNnTtXhYWF3nlF43kHQoH8ifyppeVPLTl3aur86yN/In+qm1c0nvdmJTLfv42G1P9G+L1795rNmzebF1980Ugy77//vtm8ebP5/vvvvW2uuuoqM2DAALNhwwbzwQcfmHPOOcfnJ2PLyspMp06dzC233GI+/fRTs3jxYtO2bVvLz6bGx8ebOXPmmM8//9zk5eX5/dnUdu3amTfffNN88sknZtSoUUH52VSnc1+3bp2ZO3eu2bJli/nyyy/NokWLTMeOHc24ceOieu7l5eUmIyPDXHDBBWbnzp0+P41Z/2dDr7zySrNlyxbz9ttvm44dO/r9+cj77rvPfP7552bevHl+fz4yKSnJLFy40Hz22WdmypQppl27dj6/MPCrX/3KnHXWWWb16tXmo48+MpmZmSYzMzMo83Y6/2XLlpkXX3zRbN261ezYscM8++yzpm3btuaRRx6JuvmfOPcvv/zSPP744+ajjz4yxcXFZu3atebaa681HTp08P6kZyyde7tzj9Xz7o8C/GRsLJx3IBTIn5o+d/Kn2Hgtbcm5U/35kz+RP9Uhfwo+ikbNUP0nQl5enpFkuRUWFnrbfP/99+amm24yp556qnG73WbixInm4MGDPvv9xz/+YYYMGWKSkpLMGWecYQoKCixj//GPfzTnnnuuSUxMNOedd57585//7LO9trbWPPzww6ZTp04mKSnJDBs2zGzfvj1ic9+0aZPJyMgwKSkppnXr1qZPnz7m8ccfN0eOHInqudf9RK6/2+7du7199uzZY66++mrTpk0bc/rpp5tf//rXPj+rWrev/v37m8TERHP22Wf7PG7qPPPMM+ass84yiYmJ5uKLLzYffvihz/Yff/zR3H777aZ9+/ambdu25uc//7nZu3dv0ObuZP5/+ctfTP/+/c2pp55qTjnlFHPhhRea559/3tTU1ETd/E+c+zfffGOuvvpqk5qaahISEsyZZ55pbr75ZvPFF1/49ImVc2937rF63v2pn/QYEzvnHQgF8qemz538KTZeS1ty7lR//uRP5E91yJ+Cz2XMCb+zBwAAAAAAAIjvNAIAAAAAAIAfFI0AAAAAAABgER/pAMLpyJEjOnr0aKTDAAAAjUhMTGzSL/8g9MifAACIDqHIn1pM0ejIkSNq06ajpEORDgUAADQiLS1Nu3fvpnAUYeRPAABEj1DkTy2maHTsL2SHJE2TdMrxtQnH7+MD3De0PaEJbYK1vbE+dcuNaNXIkHENbGsVYL2T7YG2Jfhp21DcrZqwvan7aCzuho7dyR4bb7vj30kfX+Nz72pVfWwxvkatjq9rFV97/L76+P3x9XHH7+X/Pv74fZxl+/ExVOtd38rSttpnH61OaHusXf3tjcfQWBv7MQRuV3+ugcb+aZ+NtbMes6bG2fgxazyGRs9tzfH76uNj1Jjjy/K5dx0bSseHst7XHL/VX2dnue4+0Fg1Qd5XY8tN3Vf9fdiJLZj7aiS2quN9j59qy3J1jW+XqgC7CrT+xO0NbWvqPpoyRqWkuaWlOnr0KEWjCDv5/CnQtmDmT03tG4T8yV/u1NCQJ5MjNLXvyeRPjeVFwcyfgp1b+suf/OROkkKSP/nLA068D2b+FDh/C17+1HjuErz8qf4xC0X+FHj8EORPTt/rneQCoczF6paDmKM0Glsoc7H66+v1CUX+5CTvsdPO33RO3Baq/KnFFI1+kiSp7gAGSh6ashwo6QnFclP7BOBq4n2cfkp+At3XTwLq3zclsWks6Qnm9qbuo9GEpAljOOnrc99w0ciVUCNX3Trv/bFtcceX4+J83/ji6r25Bk42rG/wgYskjRVRmr49+GPU3bdqYKy4Ju7DdbxdnE+/n+5d9fbj8q776engqrdP1bs3x9vVX193Xxer8WnfSuaEf9fWG+v4fc3x++rjcQZKegK92TZUZGlKH7vrg7kvf+tbnbC9/oGu6xPoda/+Pl31ttd/La1r74+r3nL93y81AdYHis1IVccTo+OnWlWuesvHmzaWoDRlubG2je0jvpHtrU74N5obp/lToG3BzJdOdowA/OVL/nKnptw7yZ9CmR/VbW8sNwlm/hTM3MvnPnDRyJVQP28KXv7UeHEkePlT4znLyedP/nIn3/vg5U/x9dqGIn/ylzv53gcxfzrZHMVOv1DmYvXHqJ8nhSJ/akrudGLfOk7ypzjfNqHIn5zkVk1p5y9/qn+aQpk/8UXYAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAIv4SAcQfpX6ado1x+/rlqsbWa46YTnh+L8T6rWpfx+M7Y31qVsOwDTxvvb4TX7uXcfva+ot190rwHL9GAKNe6L6Y7cK0L6m3vb666v10yFqVW9b/fWBDn+revf+TldT9xFou7fd8QnG1/jcm1bHHocmvkambl187fH7Y9tqj693xR2/l//7Wu8BqH9ffbzdiQfx+Fje+2qfPuZ4W+Pdd3W9Zf/3ddtrVKNWx/9d/7623nKcd7na2/fYcm2D7eJPaNeq3rZAY/+0z8ba1Y3xUwwNje9vH3Xt4wPGEPj+p3+b4/swx/d57L5VzfH76uPbj5/q4w8n772r7pRXB7j/6aGgeg+Bpi/X3QcaqybI+2psuan7qr8PO7E1dV+N3Qd6TT7hvur4S8fxU21Zrh9CleytP3F7Q9uauo+mjFEpND9O86eqettCkT81tW8Q8qdAOUwo8icTYDmY+ZO/3EkKTf5kNz9ykj/5yZ1874OZP/nLnX66D2b+dGLudOzQBD9/ajx3CV7+FO9n/BP7BiN/ajyXCmL+5DRvcJLzhDIXq1s+2X3ZOQ5O9+Ukf6q3LhT5k5O8x067E9f72xaq/KnFFI0SExOVlpam0tK5kQ4lcuo/mRAV6nK9Kv30ogAAsS4tLU2JiYmRDqPFM8bo1FNP1aFD5E/kT9HjxNzpxHsAiHWhyJ9cxpj6f8eIWUeOHNHRo0cjHUZIVFRUKD09XV999ZXcbnekwwm6WJ+fxBxjQazPT4r9Ocb6/KTomWNiYqJat24d6TBavIqKCqWkpDT7x0u4RcvzKNw4LlYcE/84Lv5xXPzjuFgFOiahyJ9azJVGktS6deuYT0DdbndMP5FifX4Sc4wFsT4/KfbnGOvzk1rGHBE8PF7847j4x3Gx4pj4x3Hxj+PiH8fFKhzHhC/CBgAAAAAAgAVFIwAAAAAAAFhQNIoRSUlJysvLU1JSUqRDCYlYn5/EHGNBrM9Piv05xvr8pJYxRwQPjxf/OC7+cVysOCb+cVz847j4x3GxCucxaVFfhA0AAAAAAICm4UojAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRaMoMm/ePHXr1k2tW7dWRkaG/v73vzfY/vXXX1fv3r3VunVrXXDBBVq+fHmYInXGzvwWLlwol8vlc2vdunUYo7Xv/fff17XXXqsuXbrI5XKpqKio0T5r1qzRwIEDlZSUpJ49e2rhwoUhj9Mpu/Nbs2aN5Ry6XC6VlpaGJ2Cb8vPz9W//9m9KTk5WamqqcnJytH379kb7RdPz0Mkco+m5+Nxzz6lfv35yu91yu93KzMzUX/7ylwb7RNP5k+zPMZrOH0In1vMLp+wclxdffFGXXnqp2rdvr/bt2ys7O7vR4xiN7D5W6ixevFgul0s5OTmhDTBC7B6XsrIyTZ06VZ07d1ZSUpLOPffcmHwe2T0uTz31lHr16qU2bdooPT1d06ZN05EjR8IUbejF+v8FnLJ7XJYsWaLhw4erY8eO3lznr3/9a3iCDSMnj5c6a9euVXx8vPr37x+UWCgaRYnXXntN9957r/Ly8vTxxx/rwgsv1IgRI/Tdd9/5bb9u3TrddNNNuvXWW7V582bl5OQoJydHn376aZgjbxq785Mkt9utvXv3em/FxcVhjNi+w4cP68ILL9S8efOa1H737t0aOXKkLr/8cm3ZskX33HOPcnNzm+2Lot351dm+fbvPeUxNTQ1RhCfnvffe09SpU/Xhhx9qxYoVqqqq0pVXXqnDhw8H7BNtz0Mnc5Si57l45plnqqCgQJs2bdJHH32kK664QqNGjdK2bdv8to+28yfZn6MUPecPoRHr+YVTdo/LmjVrdNNNN+ndd9/V+vXrlZ6eriuvvFLffPNNmCMPHSe5miTt2bNH06dP16WXXhqmSMPL7nE5evSohg8frj179uiNN97Q9u3b9eKLL+qMM84Ic+ShZfe4vPLKK3rwwQeVl5enzz//XC+99JJee+01/Z//83/CHHnoxPr/BZyye1zef/99DR8+XMuXL9emTZt0+eWX69prr9XmzZtDHGl4Of2/VVlZmcaNG6dhw4YFLxiDqHDxxRebqVOnepdrampMly5dTH5+vt/2Y8aMMSNHjvRZl5GRYW677baQxumU3fkVFhaalJSUMEUXfJLM0qVLG2xz//33m/POO89n3S9/+UszYsSIEEYWHE2Z37vvvmskmQMHDoQlpmD77rvvjCTz3nvvBWwTbc/D+poyx2h/LrZv397Mnz/f77ZoP391GppjtJ8/nLxYzy+csntc6quurjbJycnm97//fahCDDsnx6S6utpkZWWZ+fPnm/Hjx5tRo0aFIdLwsntcnnvuOXP22Webo0ePhivEiLB7XKZOnWquuOIKn3X33nuvGTx4cEjjjJRY/7+AU005Lv707dvXzJw5M/gBNRN2jssvf/lL89BDD5m8vDxz4YUXBmV8rjSKAkePHtWmTZuUnZ3tXRcXF6fs7GytX7/eb5/169f7tJekESNGBGwfSU7mJ0mHDh1S165dlZ6e3uhf0qNRNJ3Dk9G/f3917txZw4cP19q1ayMdTpOVl5dLkjp06BCwTbSfw6bMUYrO52JNTY0WL16sw4cPKzMz02+baD9/TZmjFJ3nD8ER6/mFU07zkhP98MMPqqqqavT1M1o4PSazZs1Samqqbr311nCEGXZOjsuyZcuUmZmpqVOnqlOnTjr//PP1+OOPq6amJlxhh5yT45KVlaVNmzZ5P8K2a9cuLV++XNdcc01YYm6OWsLrbTDU1tbq4MGDMfN6ezIKCwu1a9cu5eXlBXW/8UHdG0LiX//6l2pqatSpUyef9Z06ddIXX3zht09paanf9s3x+2KczK9Xr15asGCB+vXrp/Lycs2ZM0dZWVnatm2bzjzzzHCEHXKBzmFFRYV+/PFHtWnTJkKRBUfnzp31/PPP66KLLlJlZaXmz5+vyy67TBs2bNDAgQMjHV6Damtrdc8992jw4ME6//zzA7aLpudhfU2dY7Q9F7du3arMzEwdOXJEp556qpYuXaq+ffv6bRut58/OHKPt/CG4Yj2/cMrJcanvgQceUJcuXSz/4YtWTo7JBx98oJdeeklbtmwJQ4SR4eS47Nq1S6tXr9bYsWO1fPly7dy5U7fffruqqqqC/h+9SHFyXG6++Wb961//0pAhQ2SMUXV1tX71q1/F1MfT7Ir1/wsEy5w5c3To0CGNGTMm0qFE1I4dO/Tggw/qb3/7m+Ljg1vmoWiEqJSZmenzl/OsrCz16dNHL7zwgh599NEIRoam6tWrl3r16uVdzsrK0pdffqm5c+fq//2//xfByBo3depUffrpp/rggw8iHUrINHWO0fZc7NWrl7Zs2aLy8nK98cYbGj9+vN57772ARZVoZGeO0Xb+gGhQUFCgxYsXa82aNS32i+UPHjyoW265RS+++KJOP/30SIfTrNTW1io1NVW/+93v1KpVKw0aNEjffPONZs+eHTNFIyfWrFmjxx9/XM8++6wyMjK0c+dO3X333Xr00Uf18MMPRzo8NFOvvPKKZs6cqTfffLPZfi9qONTU1Ojmm2/WzJkzde655wZ9/xSNosDpp5+uVq1aad++fT7r9+3bp7S0NL990tLSbLWPJCfzqy8hIUEDBgzQzp07QxFiRAQ6h263O2b/snDxxRc3+0LMHXfcobfeekvvv/9+o1diRNPz8ER25lhfc38uJiYmqmfPnpKkQYMGaePGjfrtb3+rF154wdI2Ws+fnTnW19zPH4Ir1vMLp04mL5kzZ44KCgq0cuVK9evXL5RhhpXdY/Lll19qz549uvbaa73ramtrJUnx8fHavn27evToEdqgw8DJY6Vz585KSEhQq1atvOv69Omj0tJSHT16VImJiSGNORycHJeHH35Yt9xyi3JzcyVJF1xwgQ4fPqwpU6boP//zPxUX1/K+VaUl/l/AjsWLFys3N1evv/56zFzV6dTBgwf10UcfafPmzbrjjjskHXvNNcYoPj5e77zzjq644grH+295z74olJiYqEGDBmnVqlXedbW1tVq1alXA76nIzMz0aS9JK1asaPB7LSLFyfzqq6mp0datW9W5c+dQhRl20XQOg2XLli3N9hwaY3THHXdo6dKlWr16tbp3795on2g7h07mWF+0PRdra2tVWVnpd1u0nb9AGppjfdF2/nByYj2/cMppXvLEE0/o0Ucf1dtvv62LLrooHKGGjd1j0rt3b23dulVbtmzx3q677jrvr0Clp6eHM/yQcfJYGTx4sHbu3OktoknS//7v/6pz584xUTCSnB2XH374wVIYqiusHfse4JanJbzeOvXqq69q4sSJevXVVzVy5MhIhxNxbrfb8pr7q1/9ynv1eUZGxskNEJSv00bILV682CQlJZmFCxeazz77zEyZMsW0a9fOlJaWGmOMueWWW8yDDz7obb927VoTHx9v5syZYz7//HOTl5dnEhISzNatWyM1hQbZnd/MmTPNX//6V/Pll1+aTZs2mRtvvNG0bt3abNu2LVJTaNTBgwfN5s2bzebNm40k8+STT5rNmzeb4uJiY4wxDz74oLnlllu87Xft2mXatm1r7rvvPvP555+befPmmVatWpm33347UlNokN35zZ071xQVFZkdO3aYrVu3mrvvvtvExcWZlStXRmoKDfqP//gPk5KSYtasWWP27t3rvf3www/eNtH+PHQyx2h6Lj744IPmvffeM7t37zaffPKJefDBB43L5TLvvPOOMSb6z58x9ucYTecPoRHr+YVTdo9LQUGBSUxMNG+88YbP6+fBgwcjNYWgs3tM6ovVX0+ze1xKSkpMcnKyueOOO8z27dvNW2+9ZVJTU81jjz0WqSmEhN3jkpeXZ5KTk82rr75qdu3aZd555x3To0cPM2bMmEhNIehi/f8CTtk9Li+//LKJj4838+bN83m9LSsri9QUQsLucakvmL+eRtEoijzzzDPmrLPOMomJiebiiy82H374oXfb0KFDzfjx433a//GPfzTnnnuuSUxMNOedd57585//HOaI7bEzv3vuucfbtlOnTuaaa64xH3/8cQSibrq6n5ivf6ub1/jx483QoUMtffr3728SExPN2WefbQoLC8Med1PZnd9//dd/mR49epjWrVubDh06mMsuu8ysXr06MsE3gb+5SfI5J9H+PHQyx2h6Lk6aNMl07drVJCYmmo4dO5phw4Z5iynGRP/5M8b+HKPp/CF0Yj2/cMrOcenatavf18+8vLzwBx5Cdh8rJ4rVopEx9o/LunXrTEZGhklKSjJnn322+b//9/+a6urqMEcdenaOS1VVlfF4PN7cMD093dx+++3mwIED4Q88RGL9/wJO2T0uQ4cObbB9rHDyeDlRMItGLmNa6PV+AAAAAAAACIjvNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFj8f+kt0LM5tX//AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -902,24 +900,24 @@ "fig, axs = plt.subplots(2, 2, figsize = (14, 14))\n", "\n", "axs[0, 0].set_title(\"Unique weights - Class\")\n", - "clrbar = axs[0, 0].imshow(rasters_unique[\"Class\"], cmap='viridis')\n", + "clrbar = axs[0, 0].imshow(arrays_unique[\"Class\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_unique[\"Class\"], ax = axs[0, 0], transform = evidence_raster.transform, cmap='viridis')\n", + "show(arrays_unique[\"Class\"], ax = axs[0, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", "axs[1, 0].set_title(\"Unique weights - W+\")\n", - "clrbar = axs[1, 0].imshow(rasters_unique[\"W+\"], cmap='viridis')\n", + "clrbar = axs[1, 0].imshow(arrays_unique[\"W+\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_unique[\"W+\"], ax = axs[1, 0], transform = evidence_raster.transform, cmap='viridis')\n", + "show(arrays_unique[\"W+\"], ax = axs[1, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", "axs[1, 1].set_title(\"Unique weights - S_W+\")\n", - "clrbar = axs[1, 1].imshow(rasters_unique[\"S_W+\"], cmap='viridis')\n", + "clrbar = axs[1, 1].imshow(arrays_unique[\"S_W+\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_unique[\"S_W+\"], ax = axs[1, 1], transform = evidence_raster.transform, cmap='viridis')" + "show(arrays_unique[\"S_W+\"], ax = axs[1, 1], transform = raster_meta[\"transform\"], cmap=colormap_name)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 61, "metadata": {}, "outputs": [ { @@ -928,13 +926,13 @@ "" ] }, - "execution_count": 8, + "execution_count": 61, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -949,34 +947,34 @@ "fig, axs = plt.subplots(3, 2, figsize = (14, 20))\n", "\n", "axs[0, 0].set_title(\"Ascending weights - Class\")\n", - "clrbar = axs[0, 0].imshow(rasters_ascending[\"Class\"], cmap='viridis')\n", + "clrbar = axs[0, 0].imshow(arrays_ascending[\"Class\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_ascending[\"Class\"], ax = axs[0, 0], transform = evidence_raster.transform, cmap='viridis')\n", + "show(arrays_ascending[\"Class\"], ax = axs[0, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", "axs[1, 0].set_title(\"Ascending weights - W+\")\n", - "clrbar = axs[1, 0].imshow(rasters_ascending[\"W+\"], cmap='viridis')\n", + "clrbar = axs[1, 0].imshow(arrays_ascending[\"W+\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_ascending[\"W+\"], ax = axs[1, 0], transform = evidence_raster.transform, cmap='viridis')\n", + "show(arrays_ascending[\"W+\"], ax = axs[1, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", "axs[1, 1].set_title(\"Ascending weights - S_W+\")\n", - "clrbar = axs[1, 1].imshow(rasters_ascending[\"S_W+\"], cmap='viridis')\n", + "clrbar = axs[1, 1].imshow(arrays_ascending[\"S_W+\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_ascending[\"S_W+\"], ax = axs[1, 1], transform = evidence_raster.transform, cmap='viridis')\n", + "show(arrays_ascending[\"S_W+\"], ax = axs[1, 1], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", "axs[2, 0].set_title(\"Ascending weights - Generalized W+\")\n", - "clrbar = axs[2, 0].imshow(rasters_ascending[\"Generalized W+\"], cmap='viridis')\n", + "clrbar = axs[2, 0].imshow(arrays_ascending[\"Generalized W+\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_ascending[\"Generalized W+\"], ax = axs[2, 0], transform = evidence_raster.transform, cmap='viridis')\n", + "show(arrays_ascending[\"Generalized W+\"], ax = axs[2, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", "axs[2, 1].set_title(\"Ascending weights - Generalized S_W+\")\n", - "clrbar = axs[2, 1].imshow(rasters_ascending[\"Generalized S_W+\"], cmap='viridis')\n", + "clrbar = axs[2, 1].imshow(arrays_ascending[\"Generalized S_W+\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_ascending[\"Generalized S_W+\"], ax = axs[2, 1], transform = evidence_raster.transform, cmap='viridis')\n" + "show(arrays_ascending[\"Generalized S_W+\"], ax = axs[2, 1], transform = raster_meta[\"transform\"], cmap=colormap_name)\n" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 62, "metadata": {}, "outputs": [ { @@ -985,13 +983,13 @@ "" ] }, - "execution_count": 9, + "execution_count": 62, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1006,29 +1004,55 @@ "fig, axs = plt.subplots(3, 2, figsize = (14, 20))\n", "\n", "axs[0, 0].set_title(\"Descending weights - Class\")\n", - "clrbar = axs[0, 0].imshow(rasters_descending[\"Class\"], cmap='viridis')\n", + "clrbar = axs[0, 0].imshow(arrays_descending[\"Class\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_descending[\"Class\"], ax = axs[0, 0], transform = evidence_raster.transform, cmap='viridis')\n", + "show(arrays_descending[\"Class\"], ax = axs[0, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", "axs[1, 0].set_title(\"Descending weights - W+\")\n", - "clrbar = axs[1, 0].imshow(rasters_descending[\"W+\"], cmap='viridis')\n", + "clrbar = axs[1, 0].imshow(arrays_descending[\"W+\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_descending[\"W+\"], ax = axs[1, 0], transform = evidence_raster.transform, cmap='viridis')\n", + "show(arrays_descending[\"W+\"], ax = axs[1, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", "axs[1, 1].set_title(\"Descending weights - S_W+\")\n", - "clrbar = axs[1, 1].imshow(rasters_descending[\"S_W+\"], cmap='viridis')\n", + "clrbar = axs[1, 1].imshow(arrays_descending[\"S_W+\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_descending[\"S_W+\"], ax = axs[1, 1], transform = evidence_raster.transform, cmap='viridis')\n", + "show(arrays_descending[\"S_W+\"], ax = axs[1, 1], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", "axs[2, 0].set_title(\"Descending weights - Generalized W+\")\n", - "clrbar = axs[2, 0].imshow(rasters_descending[\"Generalized W+\"], cmap='viridis')\n", + "clrbar = axs[2, 0].imshow(arrays_descending[\"Generalized W+\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_descending[\"Generalized W+\"], ax = axs[2, 0], transform = evidence_raster.transform, cmap='viridis')\n", + "show(arrays_descending[\"Generalized W+\"], ax = axs[2, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", "axs[2, 1].set_title(\"Descending weights - Generalized S_W+\")\n", - "clrbar = axs[2, 1].imshow(rasters_descending[\"Generalized S_W+\"], cmap='viridis')\n", + "clrbar = axs[2, 1].imshow(arrays_descending[\"Generalized S_W+\"], cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(rasters_descending[\"Generalized S_W+\"], ax = axs[2, 1], transform = evidence_raster.transform, cmap='viridis')" + "show(arrays_descending[\"Generalized S_W+\"], ax = axs[2, 1], transform = raster_meta[\"transform\"], cmap=colormap_name)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Calculating posterior probabilities / responses" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# NOTE: The below demonstrates simply how calculate responses should work, but it is not using valid data/outputs\n", + "import numpy as np\n", + "# Say we have 3 different weight calculations that can be used for posterior probabilities calculations:\n", + "arrays_ascending1, arrays_ascending2, arrays_descending1 = np.empty(), np.empty(), np.empty()\n", + "\n", + "# Make a list out of them:\n", + "output_arrays = [arrays_ascending1, arrays_ascending2, arrays_descending1]\n", + "\n", + "# Then we can call calculate responses using any of the output Dataframes\n", + "# weights_ascending is now an output Dataframe from some weight calculations with correct deposit and pixel counts\n", + "posterior_array, posterior_array_std, confidence = weights_of_evidence_calculate_responses(weights_ascending, output_arrays)" ] } ], From 663136287f8318d610ff267d1a63f9444ba5aeda Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Tue, 10 Oct 2023 14:05:23 +0300 Subject: [PATCH 26/31] Fix wofe test file --- tests/prediction/weights_of_evidence_test.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/tests/prediction/weights_of_evidence_test.py b/tests/prediction/weights_of_evidence_test.py index ac5ffd86..315c186f 100644 --- a/tests/prediction/weights_of_evidence_test.py +++ b/tests/prediction/weights_of_evidence_test.py @@ -6,7 +6,7 @@ import rasterio from eis_toolkit import exceptions -from eis_toolkit.prediction.weights_of_evidence import weights_of_evidence +from eis_toolkit.prediction.weights_of_evidence import weights_of_evidence_calculate_weights test_dir = Path(__file__).parent.parent EVIDENCE_PATH = test_dir.joinpath("../tests/data/remote/wofe/wofe_evidence_raster.tif") @@ -18,7 +18,7 @@ def test_weights_of_evidence(): """Test that weights of evidence works as intended.""" - df, rasters, raster_meta = weights_of_evidence(evidence_raster, deposits) + df, rasters, raster_meta = weights_of_evidence_calculate_weights(evidence_raster, deposits) print(df["Studentized contrast"]) np.testing.assert_equal(df.shape[1], 10) # 10 columns for unique weights @@ -30,10 +30,12 @@ def test_weights_of_evidence(): def test_too_high_studentized_contrast_threshold(): """Tests that too high studentized contrast threshold for reclassification raises the correct exception.""" with pytest.raises(exceptions.ClassificationFailedException): - weights_of_evidence(evidence_raster, deposits, weights_type="ascending", studentized_contrast_threshold=2) + weights_of_evidence_calculate_weights( + evidence_raster, deposits, weights_type="ascending", studentized_contrast_threshold=2 + ) def test_invalid_choice_in_rasters_to_generate(): """Tests that invalid metric/column in rasters to generate raises the correct exception.""" with pytest.raises(exceptions.InvalidColumnException): - weights_of_evidence(evidence_raster, deposits, rasters_to_generate=["invalid_metric"]) + weights_of_evidence_calculate_weights(evidence_raster, deposits, arrays_to_generate=["invalid_metric"]) From cc8136c753df2672cff53f7e3901809157793f14 Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Wed, 11 Oct 2023 12:16:17 +0300 Subject: [PATCH 27/31] wofe wip --- eis_toolkit/prediction/weights_of_evidence.py | 24 ++- notebooks/weights_of_evidence.ipynb | 161 ++++++++++++++---- 2 files changed, 147 insertions(+), 38 deletions(-) diff --git a/eis_toolkit/prediction/weights_of_evidence.py b/eis_toolkit/prediction/weights_of_evidence.py index 5dcc2c6a..6282ec5a 100644 --- a/eis_toolkit/prediction/weights_of_evidence.py +++ b/eis_toolkit/prediction/weights_of_evidence.py @@ -254,7 +254,7 @@ def weights_of_evidence_calculate_weights( weights_type: Literal["unique", "categorical", "ascending", "descending"] = "unique", studentized_contrast_threshold: Number = 1, arrays_to_generate: Optional[Sequence[str]] = None, -) -> Tuple[pd.DataFrame, dict, dict]: +) -> Tuple[pd.DataFrame, dict, dict, int, int]: """ Calculate weights of spatial associations. @@ -282,6 +282,8 @@ def weights_of_evidence_calculate_weights( Dataframe with weights of spatial association between the input data. Dictionary of arrays for specified metrics. Raster metadata. + Number of deposit pixels. + Number of all evidence pixels. """ if arrays_to_generate is None: @@ -355,11 +357,15 @@ def weights_of_evidence_calculate_weights( # 5. Generate arrays for desired metrics arrays_dict = _generate_arrays_from_metrics(evidence_array, weights_df, metrics_to_arrays) - return weights_df, arrays_dict, raster_meta + # Return nr. of deposit pixels and nr. of all evidence pixels for to be used in calculate responses + nr_of_deposits = int(np.sum(masked_deposit_array == 1)) + nr_of_pixels = int(np.size(masked_evidence_array)) + + return weights_df, arrays_dict, raster_meta, nr_of_deposits, nr_of_pixels def weights_of_evidence_calculate_responses( - weights_df: pd.DataFrame, output_arrays: Sequence[Dict[str, np.ndarray]] + output_arrays: Sequence[Dict[str, np.ndarray]], nr_of_deposits: int, nr_of_pixels: int ) -> Tuple[np.ndarray, float, np.ndarray]: """Calculate the posterior probabilities for the given generalized weight arrays. @@ -368,6 +374,8 @@ def weights_of_evidence_calculate_responses( output_arrays: List of output array dictionaries returned by weights of evidence calculations. For each dictionary, generalized weight and generalized standard deviation arrays are fetched and summed together pixel-wise to calculate the posterior probabilities. + nr_of_deposits: Number of deposit pixels in the input data for weights of evidence calculations. + nr_of_pixels: Number of evidence pixels in the input data for weights of evidence calculations. Returns: Array of posterior probabilites. @@ -377,16 +385,14 @@ def weights_of_evidence_calculate_responses( generalized_weight_arrays_sum = sum([item[GENERALIZED_WEIGHT_PLUS_COLUMN] for item in output_arrays]) generalized_weight_std_arrays_sum = sum([item[GENERALIZED_S_WEIGHT_PLUS_COLUMN] for item in output_arrays]) - prior_probabilities = weights_df[DEPOSIT_COUNT_COLUMN] / weights_df[PIXEL_COUNT_COLUMN] + prior_probabilities = nr_of_deposits / nr_of_pixels prior_odds = np.log(prior_probabilities / (1 - prior_probabilities)) posterior_probabilities = np.exp(generalized_weight_arrays_sum + prior_odds) / ( 1 + np.exp(generalized_weight_arrays_sum + prior_odds) ) probabilities_squared = np.square(posterior_probabilities) - probabilities_probabilities_std = np.sqrt( - (weights_df[DEPOSIT_COUNT_COLUMN] + generalized_weight_std_arrays_sum) * probabilities_squared - ) + posterior_probabilities_std = np.sqrt((nr_of_deposits + generalized_weight_std_arrays_sum) * probabilities_squared) - confidence_array = posterior_probabilities / probabilities_probabilities_std - return posterior_probabilities, probabilities_probabilities_std, confidence_array + confidence_array = posterior_probabilities / posterior_probabilities_std + return posterior_probabilities, posterior_probabilities_std, confidence_array diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb index 897a73b2..611dcfa3 100644 --- a/notebooks/weights_of_evidence.ipynb +++ b/notebooks/weights_of_evidence.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 53, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -19,22 +19,22 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "with rasterio.open(\"../tests/data/remote/wofe/wofe_evidence_raster.tif\") as evidence_raster:\n", " deposits = gpd.read_file(\"../tests/data/remote/wofe/wofe_deposits.shp\")\n", "\n", - " weights_unique, arrays_unique, raster_meta = weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='unique')\n", - " weights_categorical, _, _ = weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='categorical', studentized_contrast_threshold=1)\n", - " weights_ascending, arrays_ascending, _ = weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='ascending', studentized_contrast_threshold=1)\n", - " weights_descending, arrays_descending, _ = weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='descending', studentized_contrast_threshold=1)" + " weights_unique, arrays_unique, raster_meta, nr_of_deposits, nr_of_pixels = weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='unique')\n", + " weights_categorical, arrays_categorical, _, _, _= weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='categorical', studentized_contrast_threshold=1)\n", + " weights_ascending, arrays_ascending, _, _, _= weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='ascending', studentized_contrast_threshold=1)\n", + " weights_descending, arrays_descending, _, _, _ = weights_of_evidence_calculate_weights(evidence_raster, deposits, weights_type='descending', studentized_contrast_threshold=1)" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -201,7 +201,7 @@ "7 0.0000 0.0000 0.0000 " ] }, - "execution_count": 55, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -213,7 +213,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -417,7 +417,7 @@ "7 -0.8055 1.0047 " ] }, - "execution_count": 56, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -429,7 +429,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -633,7 +633,7 @@ "7 -0.3994 0.3806 " ] }, - "execution_count": 57, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -645,7 +645,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -849,7 +849,7 @@ "7 -0.0501 0.2608 " ] }, - "execution_count": 58, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -861,7 +861,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -870,7 +870,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -879,7 +879,7 @@ "" ] }, - "execution_count": 60, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, @@ -917,7 +917,64 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot categorical weights\n", + "\n", + "fig, axs = plt.subplots(3, 2, figsize = (14, 20))\n", + "\n", + "axs[0, 0].set_title(\"Categorical weights - Class\")\n", + "clrbar = axs[0, 0].imshow(arrays_categorical[\"Class\"], cmap=colormap_name)\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(arrays_categorical[\"Class\"], ax = axs[0, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", + "\n", + "axs[1, 0].set_title(\"Categorical weights - W+\")\n", + "clrbar = axs[1, 0].imshow(arrays_categorical[\"W+\"], cmap=colormap_name)\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(arrays_categorical[\"W+\"], ax = axs[1, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", + "\n", + "axs[1, 1].set_title(\"Categorical weights - S_W+\")\n", + "clrbar = axs[1, 1].imshow(arrays_categorical[\"S_W+\"], cmap=colormap_name)\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(arrays_categorical[\"S_W+\"], ax = axs[1, 1], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", + "\n", + "axs[2, 0].set_title(\"Categorical weights - Generalized W+\")\n", + "clrbar = axs[2, 0].imshow(arrays_categorical[\"Generalized W+\"], cmap=colormap_name)\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(arrays_categorical[\"Generalized W+\"], ax = axs[2, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", + "\n", + "axs[2, 1].set_title(\"Categorical weights - Generalized S_W+\")\n", + "clrbar = axs[2, 1].imshow(arrays_categorical[\"Generalized S_W+\"], cmap=colormap_name)\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(arrays_categorical[\"Generalized S_W+\"], ax = axs[2, 1], transform = raster_meta[\"transform\"], cmap=colormap_name)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -926,7 +983,7 @@ "" ] }, - "execution_count": 61, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, @@ -974,7 +1031,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -983,7 +1040,7 @@ "" ] }, - "execution_count": 62, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, @@ -1038,21 +1095,67 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "# NOTE: The below demonstrates simply how calculate responses should work, but it is not using valid data/outputs\n", - "import numpy as np\n", - "# Say we have 3 different weight calculations that can be used for posterior probabilities calculations:\n", - "arrays_ascending1, arrays_ascending2, arrays_descending1 = np.empty(), np.empty(), np.empty()\n", - "\n", + "# Say we have 4 different weight calculations that can be used for posterior probabilities calculations\n", "# Make a list out of them:\n", - "output_arrays = [arrays_ascending1, arrays_ascending2, arrays_descending1]\n", + "output_arrays = [arrays_categorical, arrays_ascending, arrays_descending]\n", "\n", "# Then we can call calculate responses using any of the output Dataframes\n", "# weights_ascending is now an output Dataframe from some weight calculations with correct deposit and pixel counts\n", - "posterior_array, posterior_array_std, confidence = weights_of_evidence_calculate_responses(weights_ascending, output_arrays)" + "posterior_array, posterior_array_std, confidence = weights_of_evidence_calculate_responses(output_arrays, nr_of_deposits, nr_of_pixels)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8))\n", + "\n", + "ax1.set_title(\"Posterior probabilities\")\n", + "clrbar = ax1.imshow(posterior_array, cmap=colormap_name)\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(posterior_array, transform = raster_meta[\"transform\"], cmap=colormap_name)\n", + "\n", + "ax2.set_title(\"Posterior probabilities std\")\n", + "clrbar = ax2.imshow(posterior_array_std, cmap=colormap_name)\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(posterior_array_std, transform = raster_meta[\"transform\"], cmap=colormap_name)" ] } ], From 47d15ff3bd8f46f98197fb2d0b642eb861e9cfbb Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Wed, 11 Oct 2023 16:33:23 +0300 Subject: [PATCH 28/31] Wofe calculate responses v1 ready, notebook updated --- eis_toolkit/prediction/weights_of_evidence.py | 29 +++++----- notebooks/weights_of_evidence.ipynb | 54 ++++++++++--------- 2 files changed, 46 insertions(+), 37 deletions(-) diff --git a/eis_toolkit/prediction/weights_of_evidence.py b/eis_toolkit/prediction/weights_of_evidence.py index 6282ec5a..be2aab1a 100644 --- a/eis_toolkit/prediction/weights_of_evidence.py +++ b/eis_toolkit/prediction/weights_of_evidence.py @@ -147,7 +147,8 @@ def _generalized_classes_categorical(df: pd.DataFrame, studentized_contrast_thre return gen_df -def _calculate_generalized_weights_categorical(df: pd.DataFrame, deposits) -> pd.DataFrame: +def _generalized_weights_categorical(df: pd.DataFrame, deposits) -> pd.DataFrame: + """Calculate generalized weights for categorical weights type. Assumes class 99 exists as the general class.""" gen_df = df.copy() total_deposits = np.sum(deposits == 1) total_no_deposits = deposits.size - total_deposits @@ -199,8 +200,12 @@ def _generalized_classes_cumulative(df: pd.DataFrame, studentized_contrast_thres return gen_df -def _calculate_generalized_weights_cumulative(df: pd.DataFrame, deposits: np.ndarray) -> pd.DataFrame: - """Calculate generalized weights.for cumulative methods.""" +def _generalized_weights_cumulative(df: pd.DataFrame, deposits: np.ndarray) -> pd.DataFrame: + """ + Calculate generalized weights for cumulative methods. + + Assumes there are classes 1 and 2 as the general classes. + """ gen_df = df.copy() total_deposits = np.sum(deposits == 1) total_no_deposits = deposits.size - total_deposits @@ -349,10 +354,10 @@ def weights_of_evidence_calculate_weights( # 4. If we use cumulative weights type, calculate generalized classes and weights if weights_type == "categorical": weights_df = _generalized_classes_categorical(weights_df, studentized_contrast_threshold) - weights_df = _calculate_generalized_weights_categorical(weights_df, masked_deposit_array) + weights_df = _generalized_weights_categorical(weights_df, masked_deposit_array) elif weights_type == "ascending" or weights_type == "descending": weights_df = _generalized_classes_cumulative(weights_df, studentized_contrast_threshold) - weights_df = _calculate_generalized_weights_cumulative(weights_df, masked_deposit_array) + weights_df = _generalized_weights_cumulative(weights_df, masked_deposit_array) # 5. Generate arrays for desired metrics arrays_dict = _generate_arrays_from_metrics(evidence_array, weights_df, metrics_to_arrays) @@ -382,17 +387,17 @@ def weights_of_evidence_calculate_responses( Array of standard deviations in the posterior probability calculations. Confidence of the prospectivity values obtained in the posterior probability array. """ - generalized_weight_arrays_sum = sum([item[GENERALIZED_WEIGHT_PLUS_COLUMN] for item in output_arrays]) - generalized_weight_std_arrays_sum = sum([item[GENERALIZED_S_WEIGHT_PLUS_COLUMN] for item in output_arrays]) + gen_weights_sum = sum([item[GENERALIZED_WEIGHT_PLUS_COLUMN] for item in output_arrays]) + gen_weights_variance_sum = sum([np.square(item[GENERALIZED_S_WEIGHT_PLUS_COLUMN]) for item in output_arrays]) prior_probabilities = nr_of_deposits / nr_of_pixels prior_odds = np.log(prior_probabilities / (1 - prior_probabilities)) - posterior_probabilities = np.exp(generalized_weight_arrays_sum + prior_odds) / ( - 1 + np.exp(generalized_weight_arrays_sum + prior_odds) - ) + posterior_probabilities = np.exp(gen_weights_sum + prior_odds) / (1 + np.exp(gen_weights_sum + prior_odds)) - probabilities_squared = np.square(posterior_probabilities) - posterior_probabilities_std = np.sqrt((nr_of_deposits + generalized_weight_std_arrays_sum) * probabilities_squared) + posterior_probabilities_squared = np.square(posterior_probabilities) + posterior_probabilities_std = np.sqrt( + (1 / nr_of_deposits + gen_weights_variance_sum) * posterior_probabilities_squared + ) confidence_array = posterior_probabilities / posterior_probabilities_std return posterior_probabilities, posterior_probabilities_std, confidence_array diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb index 611dcfa3..3a21f376 100644 --- a/notebooks/weights_of_evidence.ipynb +++ b/notebooks/weights_of_evidence.ipynb @@ -1095,7 +1095,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -1105,57 +1112,54 @@ "\n", "# Then we can call calculate responses using any of the output Dataframes\n", "# weights_ascending is now an output Dataframe from some weight calculations with correct deposit and pixel counts\n", - "posterior_array, posterior_array_std, confidence = weights_of_evidence_calculate_responses(output_arrays, nr_of_deposits, nr_of_pixels)" + "posterior_array, posterior_array_std, posterior_confidence = weights_of_evidence_calculate_responses(output_arrays, nr_of_deposits, nr_of_pixels)" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "" ] }, + "execution_count": 22, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8))\n", + "# Plot posterior probabilities weights\n", + "\n", + "fig, axs = plt.subplots(2, 2, figsize = (14, 14))\n", + "\n", + "axs[0, 0].set_title(\"Posterior probabilities\")\n", + "clrbar = axs[0, 0].imshow(posterior_array, cmap=colormap_name)\n", + "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", + "show(posterior_array, ax = axs[0, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", - "ax1.set_title(\"Posterior probabilities\")\n", - "clrbar = ax1.imshow(posterior_array, cmap=colormap_name)\n", + "axs[0, 1].set_title(\"Posterior probabilities std\")\n", + "clrbar = axs[0, 1].imshow(posterior_array_std, cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(posterior_array, transform = raster_meta[\"transform\"], cmap=colormap_name)\n", + "show(posterior_array_std, ax = axs[0, 1], transform = raster_meta[\"transform\"], cmap=colormap_name)\n", "\n", - "ax2.set_title(\"Posterior probabilities std\")\n", - "clrbar = ax2.imshow(posterior_array_std, cmap=colormap_name)\n", + "axs[1, 0].set_title(\"Posterior confidence\")\n", + "clrbar = axs[1, 0].imshow(posterior_confidence, cmap=colormap_name)\n", "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", - "show(posterior_array_std, transform = raster_meta[\"transform\"], cmap=colormap_name)" + "show(posterior_confidence, ax = axs[1, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)" ] } ], From 34b9d9d931850426714703fdcd6b1fbb9730b8b7 Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Wed, 11 Oct 2023 17:18:22 +0300 Subject: [PATCH 29/31] Update wofe test --- tests/prediction/weights_of_evidence_test.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tests/prediction/weights_of_evidence_test.py b/tests/prediction/weights_of_evidence_test.py index 315c186f..de282040 100644 --- a/tests/prediction/weights_of_evidence_test.py +++ b/tests/prediction/weights_of_evidence_test.py @@ -18,9 +18,8 @@ def test_weights_of_evidence(): """Test that weights of evidence works as intended.""" - df, rasters, raster_meta = weights_of_evidence_calculate_weights(evidence_raster, deposits) + df, rasters, raster_meta, _, _ = weights_of_evidence_calculate_weights(evidence_raster, deposits) - print(df["Studentized contrast"]) np.testing.assert_equal(df.shape[1], 10) # 10 columns for unique weights np.testing.assert_equal(df.shape[0], 8) # 8 classes in the test data np.testing.assert_equal(len(rasters), 3) # 3 rasters should be generated with default rasters_to_generate From 5514c1dc66ec59e6ed8883eea43e87aaa5d8f317 Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Thu, 12 Oct 2023 08:19:00 +0300 Subject: [PATCH 30/31] Update calculate responses to accept unique weight arrays --- eis_toolkit/prediction/weights_of_evidence.py | 29 ++++++++++++++----- notebooks/weights_of_evidence.ipynb | 19 ++++-------- 2 files changed, 28 insertions(+), 20 deletions(-) diff --git a/eis_toolkit/prediction/weights_of_evidence.py b/eis_toolkit/prediction/weights_of_evidence.py index be2aab1a..7f668ee1 100644 --- a/eis_toolkit/prediction/weights_of_evidence.py +++ b/eis_toolkit/prediction/weights_of_evidence.py @@ -369,26 +369,41 @@ def weights_of_evidence_calculate_weights( return weights_df, arrays_dict, raster_meta, nr_of_deposits, nr_of_pixels +@beartype def weights_of_evidence_calculate_responses( output_arrays: Sequence[Dict[str, np.ndarray]], nr_of_deposits: int, nr_of_pixels: int -) -> Tuple[np.ndarray, float, np.ndarray]: +) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: """Calculate the posterior probabilities for the given generalized weight arrays. Args: - weights_df: Output Dataframe from weights of evidence calculations including deposit count and pixel count. output_arrays: List of output array dictionaries returned by weights of evidence calculations. - For each dictionary, generalized weight and generalized standard deviation arrays are fetched and summed - together pixel-wise to calculate the posterior probabilities. + For each dictionary, generalized weight and generalized standard deviation arrays are used and summed + together pixel-wise to calculate the posterior probabilities. If generalized arrays are not found, + the W+ and S_W+ arrays are used (so if outputs from unique weight calculations are used for this function). nr_of_deposits: Number of deposit pixels in the input data for weights of evidence calculations. nr_of_pixels: Number of evidence pixels in the input data for weights of evidence calculations. Returns: Array of posterior probabilites. Array of standard deviations in the posterior probability calculations. - Confidence of the prospectivity values obtained in the posterior probability array. + Array of confidence of the prospectivity values obtained in the posterior probability array. """ - gen_weights_sum = sum([item[GENERALIZED_WEIGHT_PLUS_COLUMN] for item in output_arrays]) - gen_weights_variance_sum = sum([np.square(item[GENERALIZED_S_WEIGHT_PLUS_COLUMN]) for item in output_arrays]) + gen_weights_sum = sum( + [ + item[GENERALIZED_WEIGHT_PLUS_COLUMN] + if GENERALIZED_WEIGHT_PLUS_COLUMN in item.keys() + else item[WEIGHT_PLUS_COLUMN] + for item in output_arrays + ] + ) + gen_weights_variance_sum = sum( + [ + np.square(item[GENERALIZED_S_WEIGHT_PLUS_COLUMN]) + if GENERALIZED_S_WEIGHT_PLUS_COLUMN in item.keys() + else np.square(item[WEIGHT_S_PLUS_COLUMN]) + for item in output_arrays + ] + ) prior_probabilities = nr_of_deposits / nr_of_pixels prior_odds = np.log(prior_probabilities / (1 - prior_probabilities)) diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb index 3a21f376..80773743 100644 --- a/notebooks/weights_of_evidence.ipynb +++ b/notebooks/weights_of_evidence.ipynb @@ -1095,20 +1095,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 20, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# Say we have 4 different weight calculations that can be used for posterior probabilities calculations\n", "# Make a list out of them:\n", - "output_arrays = [arrays_categorical, arrays_ascending, arrays_descending]\n", + "output_arrays = [arrays_unique, arrays_categorical, arrays_ascending, arrays_descending]\n", "\n", "# Then we can call calculate responses using any of the output Dataframes\n", "# weights_ascending is now an output Dataframe from some weight calculations with correct deposit and pixel counts\n", @@ -1117,22 +1110,22 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 22, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From c3593ea6aa47d897032fee22580944ee2a0e335c Mon Sep 17 00:00:00 2001 From: Niko Aarnio Date: Thu, 12 Oct 2023 16:28:34 +0300 Subject: [PATCH 31/31] Notebook saves calculated posterior rasters locally --- notebooks/weights_of_evidence.ipynb | 40 ++++++++++++++++++++++++++--- 1 file changed, 36 insertions(+), 4 deletions(-) diff --git a/notebooks/weights_of_evidence.ipynb b/notebooks/weights_of_evidence.ipynb index 80773743..62bddc71 100644 --- a/notebooks/weights_of_evidence.ipynb +++ b/notebooks/weights_of_evidence.ipynb @@ -21,7 +21,15 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "108 1\n" + ] + } + ], "source": [ "with rasterio.open(\"../tests/data/remote/wofe/wofe_evidence_raster.tif\") as evidence_raster:\n", " deposits = gpd.read_file(\"../tests/data/remote/wofe/wofe_deposits.shp\")\n", @@ -1099,9 +1107,9 @@ "metadata": {}, "outputs": [], "source": [ - "# Say we have 4 different weight calculations that can be used for posterior probabilities calculations\n", + "# Say we have 2 different weight calculations that can be used for posterior probabilities calculations\n", "# Make a list out of them:\n", - "output_arrays = [arrays_unique, arrays_categorical, arrays_ascending, arrays_descending]\n", + "output_arrays = [arrays_ascending, arrays_descending]\n", "\n", "# Then we can call calculate responses using any of the output Dataframes\n", "# weights_ascending is now an output Dataframe from some weight calculations with correct deposit and pixel counts\n", @@ -1125,7 +1133,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAARSCAYAAAAtoADOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAADH6ElEQVR4nOzdeXwTdf7H8Xd6cqYcbSmFch+CclRcC6iAWi5ZBUX5gSiXgC6e4Imr0qJrUVh1VcRjoeiiy64uIF4oFa+VgoAUOZQFhBaVcghtOaTQ9vv7AxpJp6VNaJImfT0fjzzCzHy/M9/PTNJ8+GQyYzPGGAEAAAAAAABnCPL1AAAAAAAAAFD1UDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AlBh8+fPl81m065du3w9lEqVlJQkm82mAwcOVNo6W7RooT/+8Y/ltvv8889ls9n0+eefO+aNGTNGLVq0cGpns9mUlJRU4W2PGTOm4oMFAABnRQ5UceRA5y5Q4kBgoGgEeFBxglH8qFGjhtq1a6c77rhDe/furfTtHTt2TElJSU4fvghMK1euVFJSknJycnw9FAAALMiB4Cn+lgNt2bJFSUlJAVdwRPUR4usBANXB9OnT1bJlSx0/flz//e9/NWfOHH344YfatGmTatWqVWnbOXbsmJKTkyVJffr0qbT1Frv55ps1fPhwhYeHV/q6q6tevXrpt99+U1hY2Fnb/fbbbwoJ+f1P9sqVK5WcnKwxY8aoXr16Tm23bt2qoCC+EwAA+B45EMpSXXKgLVu2KDk5WX369LGcRQX4A4pGgBcMHDhQF110kSRp/PjxatiwoZ555hm9++67GjFihI9HV76jR4+qdu3aCg4OVnBwcKWt99ixY5WaMBYrKChQUVFRuUlIVRAUFKQaNWqU264ibYqR0AIAqgpyoNKRA5EDAf6iapVhgWriiiuukCTt3LlT0qkP+Mcff1ytW7dWeHi4WrRooYcfflj5+flO/dauXav+/fsrMjJSNWvWVMuWLTVu3DhJ0q5duxQVFSVJSk5OdpwOfuZvwH/44Qddf/31atCggWrUqKGLLrpIS5cuddpG8enkX3zxhSZNmqTo6Gg1bdrUaVnJ02tfeuklnX/++QoPD1dsbKxuv/12yynDffr00QUXXKB169apV69eqlWrlh5++OEy99GYMWNUp04d/fjjj+rfv79q166t2NhYTZ8+XcYYR7tdu3bJZrNp1qxZeu655xz7cMuWLZKkFStW6LLLLlPt2rVVr149DR48WN9//32p2zxw4ICGDRsmu92uhg0b6u6779bx48ed2qSmpuqKK65QdHS0wsPD1bFjR82ZM6fMOD755BN17dpVNWrUUMeOHbVo0SKn5aX9nr80Zx7LpKQk3X///ZKkli1bOo518XEp7XfwOTk5uueeexQXF6fw8HC1adNGTz31lIqKipzaLVy4UN26dVPdunVlt9vVqVMn/e1vfzvr2AAAqChyIHKgYoGSA52t3/z583XDDTdIki6//HLHeItjNsboiSeeUNOmTVWrVi1dfvnl2rx5c7nbBLyJM40AH9ixY4ckqWHDhpJOffP2+uuv6/rrr9e9996r1atXKyUlRd9//70WL14sSdq3b5/69eunqKgoPfTQQ6pXr5527drl+ACOiorSnDlz9Kc//UnXXnutrrvuOklS586dJUmbN2/WJZdcoiZNmuihhx5S7dq19e9//1tDhgzRf/7zH1177bVOY5w0aZKioqL02GOP6ejRo2XGkpSUpOTkZCUmJupPf/qTtm7dqjlz5mjNmjX6+uuvFRoa6mj766+/auDAgRo+fLhuuukmNWrU6Kz7qbCwUAMGDFD37t319NNPa9myZZo2bZoKCgo0ffp0p7apqak6fvy4Jk6cqPDwcDVo0EBpaWkaOHCgWrVqpaSkJP3222964YUXdMkll+jbb7+1nCI8bNgwtWjRQikpKVq1apWef/55HTp0SG+88YajzZw5c3T++efrmmuuUUhIiN577z1NmjRJRUVFuv32253Wt23bNv3f//2fbrvtNo0ePVqpqam64YYbtGzZMvXt2/essZ/Nddddp//973/65z//qWeffVaRkZGS5EiYSzp27Jh69+6tn3/+WbfeequaNWumlStXaurUqdqzZ4+ee+45SdLy5cs1YsQIXXnllXrqqackSd9//72+/vpr3X333W6PFwCAYuRA5ECBlAOV169Xr16666679Pzzz+vhhx9Whw4dJMnx/Nhjj+mJJ57QVVddpauuukrffvut+vXrpxMnTri9j4BKZwB4TGpqqpFk0tLSzP79+83u3bvNwoULTcOGDU3NmjXNTz/9ZDIyMowkM378eKe+9913n5FkVqxYYYwxZvHixUaSWbNmTZnb279/v5Fkpk2bZll25ZVXmk6dOpnjx4875hUVFZmePXuatm3bWsZ86aWXmoKCglLj2blzpzHGmH379pmwsDDTr18/U1hY6Gj34osvGklm3rx5jnm9e/c2kszLL79c/o4zxowePdpIMnfeeafTeAcNGmTCwsLM/v37jTHG7Ny500gydrvd7Nu3z2kdXbt2NdHR0ebXX391zNuwYYMJCgoyo0aNcsybNm2akWSuueYap/6TJk0yksyGDRsc844dO2YZa//+/U2rVq2c5jVv3txIMv/5z38c83Jzc03jxo1NfHy8Y95nn31mJJnPPvvMKfbmzZs7ra/kcZ05c6bTsSi57dGjRzumH3/8cVO7dm3zv//9z6ndQw89ZIKDg01WVpYxxpi7777b2O12y3EHAMBV5EDkQNUhB6pIv7ffftsSpzG/v4YGDRpkioqKHPMffvhhI8kpDsCX+Hka4AWJiYmKiopSXFychg8frjp16mjx4sVq0qSJPvzwQ0nSlClTnPrce++9kqQPPvhAkhwX+nv//fd18uRJl7Z/8OBBrVixQsOGDdPhw4d14MABHThwQL/++qv69++vbdu26eeff3bqM2HChHJ/u5+WlqYTJ07onnvucbro4IQJE2S32x1jLxYeHq6xY8e6NPY77rjD8W+bzaY77rhDJ06cUFpamlO7oUOHOn3LtGfPHmVkZGjMmDFq0KCBY37nzp3Vt29fx34/U8lvye68805Jcmpbs2ZNx79zc3N14MAB9e7dWz/++KNyc3Od+sfGxjp9e2m32zVq1CitX79e2dnZFYq/Mrz99tu67LLLVL9+fcexP3DggBITE1VYWKgvv/xS0qnX2NGjR7V8+XKvjQ0AENjIgU4hBwrMHOhccqfi19Cdd94pm83mmH/PPfe4vC7Ak6pl0ejLL7/U1VdfrdjYWNlsNi1ZssTldRhjNGvWLLVr107h4eFq0qSJ/vKXv1T+YBEQZs+ereXLl+uzzz7Tli1bHL9Rl6TMzEwFBQWpTZs2Tn1iYmJUr149ZWZmSpJ69+6toUOHKjk5WZGRkRo8eLBSU1Mtv/kvzfbt22WM0aOPPqqoqCinx7Rp0ySdOvX7TC1btix3vcVja9++vdP8sLAwtWrVyrG8WJMmTVy6MGNQUJBatWrlNK9du3aSZLmmQMnxljU26dQpwQcOHLCcct62bVun6datWysoKMhpW19//bUSExMd1weIiopyXJegZMLUpk0bpyTgbOP3pG3btmnZsmWWY5+YmCjp92M/adIktWvXTgMHDlTTpk01btw4LVu2zGvjBFC1kT/BHeRAp5ADBWYOdC65U/FxKrnvo6KiVL9+fVfCBDyqWl7T6OjRo+rSpYvGjRvn+M2zq+6++2598sknmjVrljp16qSDBw/q4MGDlTxSBIqLL77YceeQspT8YC1t+TvvvKNVq1bpvffe08cff6xx48bpr3/9q1atWqU6deqU2bf4Qn/33XefI1ErqWTCdua3SZXFE+v05LpLHpMdO3boyiuv1HnnnadnnnlGcXFxCgsL04cffqhnn33WckHFqqKoqEh9+/bVAw88UOry4iQuOjpaGRkZ+vjjj/XRRx/po48+UmpqqkaNGqXXX3/dm0MGUAWRP8Ed5ECeW6cn100OVLEciNwJ1UG1LBoNHDhQAwcOLHN5fn6+/vznP+uf//yncnJydMEFF+ipp55Snz59JJ26uNmcOXO0adMmRwW/It9IAKVp3ry5ioqKtG3bNsdF8SRp7969ysnJUfPmzZ3ad+/eXd27d9df/vIXvfXWWxo5cqQWLlyo8ePHl5l0FX9TFRoa6vhmpbLGLklbt251+jbsxIkT2rlz5zlvq6ioSD/++KPjA12S/ve//0mS5QKOZxtbST/88IMiIyNVu3Ztp/nbtm1zei9v375dRUVFjm299957ys/P19KlS9WsWTNHu88++6zUMRR/u3nmcano+MtTXoJ9ptatW+vIkSMVOh5hYWG6+uqrdfXVV6uoqEiTJk3SK6+8okcffdSSVAOoXsifUNnIgcpGDlS2qpYDldevrPEWH6dt27Y5vYb279+vQ4cOVThGwNOq5c/TynPHHXcoPT1dCxcu1HfffacbbrhBAwYM0LZt2ySd+qPZqlUrvf/++2rZsqVatGih8ePH800Z3HLVVVdJkuPuDcWeeeYZSdKgQYMkSYcOHXK6zaokde3aVZIcp2fXqlVLkiy3eo2OjlafPn30yiuvaM+ePZYx7N+/362xJyYmKiwsTM8//7zT2ObOnavc3FzH2M/Fiy++6Pi3MUYvvviiQkNDdeWVV561X+PGjdW1a1e9/vrrTvtj06ZN+uSTTxz7/UyzZ892mn7hhRckyfGfpOLrG5wZa25urlJTU0sdwy+//OK484sk5eXl6Y033lDXrl0VExNz1vGXpzjZK3msSzNs2DClp6fr448/tizLyclRQUGBpFN3djlTUFCQ484zFfkJAIDqjfwJriIHOjtyoNJVpRyoIv3KGm9iYqJCQ0P1wgsvOO3Xku8HwNeq5ZlGZ5OVlaXU1FRlZWUpNjZW0qnTWZctW6bU1FQ9+eST+vHHH5WZmam3335bb7zxhgoLCzV58mRdf/31WrFihY8jgL/p0qWLRo8erVdffVU5OTnq3bu3vvnmG73++usaMmSILr/8cknS66+/rpdeeknXXnutWrdurcOHD+u1116T3W53fPjXrFlTHTt21L/+9S+1a9dODRo00AUXXKALLrhAs2fP1qWXXqpOnTppwoQJatWqlfbu3av09HT99NNP2rBhg8tjj4qK0tSpU5WcnKwBAwbommuu0datW/XSSy/pD3/4g2666aZz2jc1atTQsmXLNHr0aCUkJOijjz7SBx98oIcffrjMW6ueaebMmRo4cKB69OihW265xXG72YiICCUlJVna79y5U9dcc40GDBig9PR0LViwQDfeeKO6dOkiSerXr5/j26Rbb71VR44c0Wuvvabo6OhSE9F27drplltu0Zo1a9SoUSPNmzdPe/fuLTPBckW3bt0kSX/+8581fPhwhYaG6uqrr7Z8cyhJ999/v5YuXao//vGPGjNmjLp166ajR49q48aNeuedd7Rr1y5FRkY6/vN2xRVXqGnTpsrMzNQLL7ygrl27On0DDAAlkT/BHeRAZSMHKltVyoEq0q9r164KDg7WU089pdzcXIWHh+uKK65QdHS07rvvPqWkpOiPf/yjrrrqKq1fv14fffSRIiMjz3k/AZXGB3dsq1IkmcWLFzum33//fSPJ1K5d2+kREhJihg0bZowxZsKECUaS2bp1q6PfunXrjCTzww8/eDsEVGHFt2c92y1ijTHm5MmTJjk52bRs2dKEhoaauLg4M3XqVKdbw3777bdmxIgRplmzZiY8PNxER0ebP/7xj2bt2rVO61q5cqXp1q2bCQsLs9yidMeOHWbUqFEmJibGhIaGmiZNmpg//vGP5p133qnQmEvebrbYiy++aM477zwTGhpqGjVqZP70pz+ZQ4cOObXp3bu3Of/888vZY78bPXq0qV27ttmxY4fp16+fqVWrlmnUqJGZNm2a061ti283O3PmzFLXk5aWZi655BJTs2ZNY7fbzdVXX222bNni1Kb4drNbtmwx119/valbt66pX7++ueOOO8xvv/3m1Hbp0qWmc+fOpkaNGqZFixbmqaeeMvPmzbPsl+bNm5tBgwaZjz/+2HTu3NmEh4eb8847z7z99ttO63P3drPGnLqNbJMmTUxQUJDT9kvebtYYYw4fPmymTp1q2rRpY8LCwkxkZKTp2bOnmTVrljlx4oQxxph33nnH9OvXz0RHR5uwsDDTrFkzc+utt5o9e/aUum8BVF/kTygPOdDvyIECNweqaL/XXnvNtGrVygQHBzvFXFhYaJKTk03jxo1NzZo1TZ8+fcymTZtKjQPwFZsxJc71rGZsNpsWL16sIUOGSJL+9a9/aeTIkdq8ebPlVpt16tRRTEyMpk2bpieffNLplp+//fabatWqpU8++UR9+/b1ZghAQBozZozeeecdHTlyxNdDAQCUQP4EeA45EICqhJ+nlRAfH6/CwkLt27dPl112WaltLrnkEhUUFGjHjh1q3bq1pN8v7Fbygn0AAACBjvwJAIDAVC2LRkeOHNH27dsd0zt37lRGRoYaNGigdu3aaeTIkRo1apT++te/Kj4+Xvv379enn36qzp07a9CgQUpMTNSFF16ocePG6bnnnlNRUZFuv/129e3b1+kOBwAAAIGC/AkAgOqnWt49be3atYqPj1d8fLwkacqUKYqPj9djjz0mSUpNTdWoUaN07733qn379hoyZIjWrFnjuL1kUFCQ3nvvPUVGRqpXr14aNGiQOnTooIULF/osJgAAAE8ifwIAoPqp9tc0AgAAAAAAgFW1PNMIAAAAAAAAZ0fRCAAAAAAAABbV5kLYRUVF+uWXX1S3bl3ZbDZfDwcAAJTBGKPDhw8rNjZWQUF8v+VL5E8AAPgHT+VP1aZo9MsvvyguLs7XwwAAABW0e/duNW3a1NfDqNbInwAA8C+VnT9Vm6JR3bp1JZ3agXa73cejAQAAZcnLy1NcXJzjsxu+Q/4EAIB/8FT+VG2KRsWnVNvtdpIeAAD8AD+H8j3yJwAA/Etl509cKAAAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFiGuNG7RooUyMzMt8ydNmqTZs2db5s+fP19jx451mhceHq7jx49Lkk6ePKlHHnlEH374oX788UdFREQoMTFRM2bMUGxs7Fm3m5KSooceesiV4XuFzZbk6yH4VBczwOPb2GBb5vFtGJPk8W0AAKoH8qfyVff8SZFJnt/GAc9vg/wJAAKPS0WjNWvWqLCw0DG9adMm9e3bVzfccEOZfex2u7Zu3eqYttlsjn8fO3ZM3377rR599FF16dJFhw4d0t13361rrrlGa9eudVrP9OnTNWHCBMd03bp1XRk6AACAT5A/AQAAf+VS0SgqKsppesaMGWrdurV69+5dZh+bzaaYmJhSl0VERGj58uVO81588UVdfPHFysrKUrNmzRzz69atW+Z6AAAAqiryJwAA4K/cvqbRiRMntGDBAo0bN87p26+Sjhw5oubNmysuLk6DBw/W5s2bz7re3Nxc2Ww21atXz2n+jBkz1LBhQ8XHx2vmzJkqKCg463ry8/OVl5fn9AAAAPAl8icAAOBPXDrT6ExLlixRTk6OxowZU2ab9u3ba968eercubNyc3M1a9Ys9ezZU5s3b1bTpk0t7Y8fP64HH3xQI0aMkN1ud8y/6667dOGFF6pBgwZauXKlpk6dqj179uiZZ54pc9spKSlKTk52NzwAAIBKR/4EAAD8ic0YY9zp2L9/f4WFhem9996rcJ+TJ0+qQ4cOGjFihB5//HHLsqFDh+qnn37S559/7pT0lDRv3jzdeuutOnLkiMLDw0ttk5+fr/z8fMd0Xl6e4uLilJube9Z1n6vqfiFHLoQNADhXeXl5ioiI8Phnti+QP5WuuudPXAgbAHCuPJU/uXWmUWZmptLS0rRo0SKX+oWGhio+Pl7bt293mn/y5EkNGzZMmZmZWrFiRbkBJiQkqKCgQLt27VL79u1LbRMeHl5mQgQAAOBt5E8AAMDfuHVNo9TUVEVHR2vQoEEu9SssLNTGjRvVuHFjx7zihGfbtm1KS0tTw4YNy11PRkaGgoKCFB0d7fLYAQAAfIH8CQAA+BuXzzQqKipSamqqRo8erZAQ5+6jRo1SkyZNlJKSIunUbV67d++uNm3aKCcnRzNnzlRmZqbGjx8v6VTCc/311+vbb7/V+++/r8LCQmVnZ0uSGjRooLCwMKWnp2v16tW6/PLLVbduXaWnp2vy5Mm66aabVL9+/XONHwAAwOPInwAAgD9yuWiUlpamrKwsjRs3zrIsKytLQUG/n7x06NAhTZgwQdnZ2apfv766deumlStXqmPHjpKkn3/+WUuXLpUkde3a1Wldn332mfr06aPw8HAtXLhQSUlJys/PV8uWLTV58mRNmTLF1aEDAAD4BPkTAADwR25fCNvfeOuimtX9Qo5cCBsAcK4C+ULY/ob8yUu4EDYA4Bx56jPbrWsaAQAAAAAAILC5dfc0lM2dM228ceaMN84A8hZv7ONq/42nF/BtJADAwZ0zbbxw5oxXzgDyFi/sY/InzyN/AuBtnGkEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwsBljjK8H4Q15eXmKiIhQbm6u7Ha7x7ZjsyV5bN3e1sUM8PUQfGaDbZmvhwAfMSbJ10MAqj1vfWajfORPbohM8vUIfOdAkq9HAB8hfwJ8z1Of2ZxpBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsAjx9QACTRczwNdDQCVw5zhusC3zwEjgbTZbkq+HUCpjknw9BADwnMgkX48AlcGd43jAjT6ocsifgMDFmUYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALAI8fUAAs0G2zKX+3QxAzwwEnibN46jO68vBAabLcnXQyiVMUm+HgKAQHAgyfU+kW70QdXjjePozusLAYH8CTh3nGkEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwCHGlcYsWLZSZmWmZP2nSJM2ePdsyf/78+Ro7dqzTvPDwcB0/flySdPLkST3yyCP68MMP9eOPPyoiIkKJiYmaMWOGYmNjHX0OHjyoO++8U++9956CgoI0dOhQ/e1vf1OdOnVcGT7g97qYAS732WBb5oGRAKfYbEm+HkKpjEny9RAAB/InwMcik1zvc8CNPkAFkT/Bn7hUNFqzZo0KCwsd05s2bVLfvn11ww03lNnHbrdr69atjmmbzeb497Fjx/Ttt9/q0UcfVZcuXXTo0CHdfffduuaaa7R27VpHu5EjR2rPnj1avny5Tp48qbFjx2rixIl66623XBk+AACA15E/AQAAf+VS0SgqKsppesaMGWrdurV69+5dZh+bzaaYmJhSl0VERGj58uVO81588UVdfPHFysrKUrNmzfT9999r2bJlWrNmjS666CJJ0gsvvKCrrrpKs2bNcvpGDQAAoKohfwIAAP7K7WsanThxQgsWLNC4ceOcvv0q6ciRI2revLni4uI0ePBgbd68+azrzc3Nlc1mU7169SRJ6enpqlevniPhkaTExEQFBQVp9erVZa4nPz9feXl5Tg8AAABfIn8CAAD+xO2i0ZIlS5STk6MxY8aU2aZ9+/aaN2+e3n33XS1YsEBFRUXq2bOnfvrpp1LbHz9+XA8++KBGjBghu90uScrOzlZ0dLRTu5CQEDVo0EDZ2dllbjslJUURERGOR1xcnOtBAgAAVCLyJwAA4E/cLhrNnTtXAwcOPOvpzT169NCoUaPUtWtX9e7dW4sWLVJUVJReeeUVS9uTJ09q2LBhMsZozpw57g7LYerUqcrNzXU8du/efc7rBAAAOBfkTwAAwJ+4dE2jYpmZmUpLS9OiRYtc6hcaGqr4+Hht377daX5xwpOZmakVK1Y4viWTpJiYGO3bt8+pfUFBgQ4ePFjmb/2lU3cZCQ8Pd2l8AAAAnkL+BAAA/I1bZxqlpqYqOjpagwYNcqlfYWGhNm7cqMaNGzvmFSc827ZtU1pamho2bOjUp0ePHsrJydG6desc81asWKGioiIlJCS4M3wAAACvI38CAAD+xuUzjYqKipSamqrRo0crJMS5+6hRo9SkSROlpKRIkqZPn67u3burTZs2ysnJ0cyZM5WZmanx48dLOpXwXH/99fr222/1/vvvq7Cw0PE7+wYNGigsLEwdOnTQgAEDNGHCBL388ss6efKk7rjjDg0fPpw7fwAAAL9A/gQAAPyRy0WjtLQ0ZWVlady4cZZlWVlZCgr6/eSlQ4cOacKECcrOzlb9+vXVrVs3rVy5Uh07dpQk/fzzz1q6dKkkqWvXrk7r+uyzz9SnTx9J0ptvvqk77rhDV155pYKCgjR06FA9//zzrg4dAADAJ8ifAACAP7IZY4yvB+ENeXl5ioiIUG5urtNv/iubzZbkcp8uZkDlDwQ4bYNtma+HAHidMUm+HgLOgbc+s1G+qpw/KdKNPkBFHUjy9QgAryN/8m+e+sx2++5pAAAAAAAACFwUjQAAAAAAAGDh8jWNcHbu/NTMnZ8P8ZO2qqeqHkdvvSaBqsStn7pUUZwqjmrBnZ+aufPzIX7SVvVU1ePordckUIWQP6E0nGkEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAACLEF8PINBssC3z9RBK5c64upgBHhjJufPGPq6qsQOofmy2JF8PoVTGJPl6CAgkB5J8PYLSuTOuSDf6eIM39nFVjR1AtUP+VHk40wgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBhM8YYXw/CG/Ly8hQREaHc3FzZ7XaPbaerVrncZ4NtmQdG4qyLGeByH3fG5ep2hth6uLwNdyRrmse34c4+DhTeeA0D8G/GJFW4rbc+s1E+bx0LW5QbnQ4kVfYwrCLd2IY743JxO9MO2Fzfhhu8kT+5tY8DhTdewwD8WlXInzjTCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYBHi6wFA6mIGeHwbG2zLPL4NdyRrmst93NpfLsbvjWMCAADOQWSS57dxwAvbcIM7+ZNb+8vV+L1xTAAAXsWZRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsAhxpXGLFi2UmZlpmT9p0iTNnj3bMn/+/PkaO3as07zw8HAdP37cMb1o0SK9/PLLWrdunQ4ePKj169era9euTn369OmjL774wmnerbfeqpdfftmV4XvFBtsyl/t0MQM8MBLfcDX+qhp7dT+OAIDKQ/5UAQeSXO8T6UafqsrV+Ktq7NX9OAJAAHKpaLRmzRoVFhY6pjdt2qS+ffvqhhtuKLOP3W7X1q1bHdM2m81p+dGjR3XppZdq2LBhmjBhQpnrmTBhgqZPn+6YrlWrlitDBwAA8AnyJwAA4K9cKhpFRUU5Tc+YMUOtW7dW7969y+xjs9kUExNT5vKbb75ZkrRr166zbrtWrVpnXQ8AAEBVRP4EAAD8ldvXNDpx4oQWLFigcePGWb79OtORI0fUvHlzxcXFafDgwdq8ebNb23vzzTcVGRmpCy64QFOnTtWxY8fcHToAAIBPkD8BAAB/4tKZRmdasmSJcnJyNGbMmDLbtG/fXvPmzVPnzp2Vm5urWbNmqWfPntq8ebOaNm1a4W3deOONat68uWJjY/Xdd9/pwQcf1NatW7Vo0aIy++Tn5ys/P98xnZeXV+HtAQAAeAL5EwAA8CduF43mzp2rgQMHKjY2tsw2PXr0UI8ePRzTPXv2VIcOHfTKK6/o8ccfr/C2Jk6c6Ph3p06d1LhxY1155ZXasWOHWrduXWqflJQUJScnV3gbAAAAnkb+BAAA/IlbP0/LzMxUWlqaxo8f71K/0NBQxcfHa/v27e5s1iEhIUGSzrqeqVOnKjc31/HYvXv3OW0TAADgXJA/AQAAf+NW0Sg1NVXR0dEaNGiQS/0KCwu1ceNGNW7c2J3NOmRkZEjSWdcTHh4uu93u9AAAAPAV8icAAOBvXP55WlFRkVJTUzV69GiFhDh3HzVqlJo0aaKUlBRJ0vTp09W9e3e1adNGOTk5mjlzpjIzM52+YTt48KCysrL0yy+/SJLj9rIxMTGKiYnRjh079NZbb+mqq65Sw4YN9d1332ny5Mnq1auXOnfu7HbgAAAA3kL+BAAA/JHLRaO0tDRlZWVp3LhxlmVZWVkKCvr95KVDhw5pwoQJys7OVv369dWtWzetXLlSHTt2dLRZunSpxo4d65gePny4JGnatGlKSkpSWFiY0tLS9Nxzz+no0aOKi4vT0KFD9cgjj7g6dAAAAJ8gfwIAAP7IZowxvh6EN+Tl5SkiIkK5ubkePdXaZktyuU8XM6DyB1LCBtsyj2/DHd6IXfJO/N6KpSqqqq8vAFWHMUkVbuutz2yUryrnT4p0o4+rDnhhG+7wRuySd+L3VixVUVV9fQGoMqpC/uTWNY0AAAAAAAAQ2CgaAQAAAAAAwMLlaxrh7ALp51beEChxVHdV9XXvzrh4TQKADwTSz628IVDiqO6q6uvenXHxmgQCFmcaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALEJ8PYBAs8G2zNdD8CtdzACvbMfV4+LOuNw59t6KP1C4ur94PwKAnziQ5OsR+JfIJO9sx9Xj4s643Dn23oo/ULi6v3g/AjgDZxoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMAixNcDgHd0MQN8PYRSDbH1cLlPsqa53Mcb8VfVfVyduXNMNtiWeWAkvuGN12Qg7S8AsIhM8vUISjXtgM3lPu7kT16Jv4ru42rNnWNywI0+VZU3XpOBtL8Q8DjTCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYBHi6wEEmi5mgK+HUKoNtmUu9/FGLMma5nIfb4yrqu4veN40Jbvcx53XsTe48zoGAJ+ITPL1CEp3IMn1Pl6Ixa3PHW/s4yq6v+B5gZQ/ufU6BgIYZxoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsQlxp3KJFC2VmZlrmT5o0SbNnz7bMnz9/vsaOHes0Lzw8XMePH3dML1q0SC+//LLWrVungwcPav369eratatTn+PHj+vee+/VwoULlZ+fr/79++ull15So0aNXBm+V2ywLXO5TxczwOPbcWcb3lBVx+Ut7rxeXBVI+7iqvu5d3Y43jnsg8cbfSMCTyJ8q4ECS630i3ejj6nbc2YY3VNVxeYs7rxdXBdI+rqqve1e3443jHki88TcS1YJLZxqtWbNGe/bscTyWL18uSbrhhhvK7GO32536lEyajh49qksvvVRPPfVUmeuYPHmy3nvvPb399tv64osv9Msvv+i6665zZegAAAA+Qf4EAAD8lUtnGkVFRTlNz5gxQ61bt1bv3r3L7GOz2RQTE1Pm8ptvvlmStGvXrlKX5+bmau7cuXrrrbd0xRVXSJJSU1PVoUMHrVq1St27d3clBAAAAK8ifwIAAP7K7WsanThxQgsWLNC4ceNks9nKbHfkyBE1b95ccXFxGjx4sDZv3uzSdtatW6eTJ08qMTHRMe+8885Ts2bNlJ6eXma//Px85eXlOT0AAAB8ifwJAAD4E7eLRkuWLFFOTo7GjBlTZpv27dtr3rx5evfdd7VgwQIVFRWpZ8+e+umnnyq8nezsbIWFhalevXpO8xs1aqTs7Owy+6WkpCgiIsLxiIuLq/A2AQAAPIH8CQAA+BO3i0Zz587VwIEDFRsbW2abHj16aNSoUeratat69+6tRYsWKSoqSq+88oq7m62wqVOnKjc31/HYvXu3x7cJAABwNuRPAADAn7h0TaNimZmZSktL06JFi1zqFxoaqvj4eG3fvr3CfWJiYnTixAnl5OQ4fVu2d+/es/7WPzw8XOHh4S6NDwAAwFPInwAAgL9x60yj1NRURUdHa9CgQS71Kyws1MaNG9W4ceMK9+nWrZtCQ0P16aefOuZt3bpVWVlZ6tGjh0vbBwAA8BXyJwAA4G9cPtOoqKhIqampGj16tEJCnLuPGjVKTZo0UUpKiiRp+vTp6t69u9q0aaOcnBzNnDlTmZmZGj9+vKPPwYMHlZWVpV9++UXSqYRGOvUNWUxMjCIiInTLLbdoypQpatCggex2u+6880716NGDO38AAAC/QP4EAAD8kctFo7S0NGVlZWncuHGWZVlZWQoK+v3kpUOHDmnChAnKzs5W/fr11a1bN61cuVIdO3Z0tFm6dKnGjh3rmB4+fLgkadq0aUpKSpIkPfvsswoKCtLQoUOVn5+v/v3766WXXnJ16AAAAD5B/gQAAPyRy0Wjfv36yRhT6rLPP//cafrZZ5/Vs88+e9b1jRkz5qx3EJGkGjVqaPbs2Zo9e7YrQwUAAKgSyJ8AAIA/cvvuaQAAAAAAAAhcFI0AAAAAAABg4fLP03B2XcwAl/sMsbl+F5MhLrZfItfHBddssC3z9RD8ijf2lzvbGOKl7aDi2L9ANRCZ5HKXaQdslT+OEpKV5PFtVHsHknw9Av/ijf3lrWPCsfcs9i8qCWcaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAwmaMMb4ehDfk5eUpIiJCubm5stvtHttOks3mcp8lJt0DI/GNDbZlLrXvYgZ4aCTe52rsQFXjzvuR1z0qypikCrf11mc2yleV86fkyABKYQ8kudY+0sX2VZmrsQNVjTvvR173qKCqkD9xphEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMAixNcDCDRLTLrLfYbYenhlO97QxQzw9RAqxQbbMl8PAThn3ng/emMbvB+BwJccaVzuM+2AzSvb8YrIJF+PoHIcSPL1CIBz5433oze2wfsRlYQzjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABY2Y4zx9SC8IS8vTxEREcrNzZXdbvfYdmy2JI+t+1x0MQN8PYRKs8G2zNdDgJ+oqq/7qvoarqr7yx1VdR9XZ8YkVbittz6zUb7qnj8pMsnXI6g8B5J8PQL4i6r6uq+qr+Gqur/cUVX3cTVWFfInzjQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIBFiCuNW7RooczMTMv8SZMmafbs2Zb58+fP19ixY53mhYeH6/jx445pY4ymTZum1157TTk5Obrkkks0Z84ctW3b9qzbTUlJ0UMPPeTK8Ku1DbZlLvfpYgZ4YCTO3BkXUB154/0YSNzZX/w9gqeQP/mxA0mu94l0o4+r3BkXUB154/0YSNzZX/w9CnguFY3WrFmjwsJCx/SmTZvUt29f3XDDDWX2sdvt2rp1q2PaZrM5LX/66af1/PPP6/XXX1fLli316KOPqn///tqyZYtq1KjhaDd9+nRNmDDBMV23bl1Xhg4AAOAT5E8AAMBfuVQ0ioqKcpqeMWOGWrdurd69e5fZx2azKSYmptRlxhg999xzeuSRRzR48GBJ0htvvKFGjRppyZIlGj58uKNt3bp1y1wPAABAVUX+BAAA/JXb1zQ6ceKEFixYoHHjxlm+/TrTkSNH1Lx5c8XFxWnw4MHavHmzY9nOnTuVnZ2txMREx7yIiAglJCQoPT3daT0zZsxQw4YNFR8fr5kzZ6qgoOCs48vPz1deXp7TAwAAwJfInwAAgD9x6UyjMy1ZskQ5OTkaM2ZMmW3at2+vefPmqXPnzsrNzdWsWbPUs2dPbd68WU2bNlV2drYkqVGjRk79GjVq5FgmSXfddZcuvPBCNWjQQCtXrtTUqVO1Z88ePfPMM2VuOyUlRcnJye6GBwAAUOnInwAAgD9xu2g0d+5cDRw4ULGxsWW26dGjh3r06OGY7tmzpzp06KBXXnlFjz/+eIW3NWXKFMe/O3furLCwMN16661KSUlReHh4qX2mTp3q1C8vL09xcXEV3iYAAEBlI38CAAD+xK2fp2VmZiotLU3jx493qV9oaKji4+O1fft2SXL8xn7v3r1O7fbu3XvW398nJCSooKBAu3btKrNNeHi47Ha70wMAAMBXyJ8AAIC/catolJqaqujoaA0aNMilfoWFhdq4caMaN24sSWrZsqViYmL06aefOtrk5eVp9erVTt+wlZSRkaGgoCBFR0e7M3wAAACvI38CAAD+xuWfpxUVFSk1NVWjR49WSIhz91GjRqlJkyZKSUmRdOo2r927d1ebNm2Uk5OjmTNnKjMz0/ENm81m0z333KMnnnhCbdu2ddwyNjY2VkOGDJEkpaena/Xq1br88stVt25dpaena/LkybrppptUv379cwwfAADA88ifAACAP3K5aJSWlqasrCyNGzfOsiwrK0tBQb+fvHTo0CFNmDBB2dnZql+/vrp166aVK1eqY8eOjjYPPPCAjh49qokTJyonJ0eXXnqpli1bpho1akg6dZr0woULlZSUpPz8fLVs2VKTJ092+r09AABAVUb+BAAA/JHNGGN8PQhvyMvLU0REhHJzcz36+3ybLclj6/a2LmaAx7exwbbM49tA9eWN17A73HndV9VYAgl/jzzLmKQKt/XWZzbKR/7khsgkz2/jgBe2gerLG69hd7jzuq+qsQQS/h55VFXIn9y6phEAAAAAAAACG0UjAAAAAAAAWLh8TSOcnSunj50Lb5zG7Y2f0HjrJzf87CQwBMpPtAIlDgCoLIGUP3nlJzTe+skNPzsJDIHyE61AiQPwM5xpBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsAjx9QDgHmOSfD2EUtlsSS6172IGeGYgfmKakl1qn6xpHhqJ91X3Yw8A8L5AyZ8U6WL7AFOd86fqfuwBeB9nGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwCLE1wNAYDEmyddDKJVNyzy+jS5mgMt9lsjFPjbPx+EtG9yIxZ19jOrJndcXAPhKlc2fbF7YSGSSy12S5WKfA65vo8pyJxY39jGqqUB6r6DScKYRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqIRAAAAAAAALCgaAQAAAAAAwIKiEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAIsTXAwC8wZgkXw+hVF21ytdDQAAbYuvhUvslJt1DIzk3G2zLfD0EAKiWqmr+ZIvy9QgQyKYdsLnUPjnSeGgk5+hAkq9HgADBmUYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALBwqWjUokUL2Ww2y+P2228vtf38+fMtbWvUqOHUxhijxx57TI0bN1bNmjWVmJiobdu2ObU5ePCgRo4cKbvdrnr16umWW27RkSNHXAwVAADA+8ifAACAvwpxpfGaNWtUWFjomN60aZP69u2rG264ocw+drtdW7dudUzbbDan5U8//bSef/55vf7662rZsqUeffRR9e/fX1u2bHEkSCNHjtSePXu0fPlynTx5UmPHjtXEiRP11ltvuTJ8oMrJUHfXOhgX23uJzZbk6yGgFEtMukvtXX49eksVfd0DFUX+BFQus9/VHkkeGMW5I3+qmpIjjUvtXX89ekuSrweAAOFS0SgqKsppesaMGWrdurV69+5dZh+bzaaYmJhSlxlj9Nxzz+mRRx7R4MGDJUlvvPGGGjVqpCVLlmj48OH6/vvvtWzZMq1Zs0YXXXSRJOmFF17QVVddpVmzZik2NtaVEAAAALyK/AkAAPgrt69pdOLECS1YsEDjxo2zfPt1piNHjqh58+aKi4vT4MGDtXnzZseynTt3Kjs7W4mJiY55ERERSkhIUHr6qW/I09PTVa9ePUfCI0mJiYkKCgrS6tWry9xufn6+8vLynB4AAAC+RP4EAAD8idtFoyVLlignJ0djxowps0379u01b948vfvuu1qwYIGKiorUs2dP/fTTT5Kk7OxsSVKjRo2c+jVq1MixLDs7W9HR0U7LQ0JC1KBBA0eb0qSkpCgiIsLxiIuLcydMAACASkP+BAAA/InbRaO5c+dq4MCBZz29uUePHho1apS6du2q3r17a9GiRYqKitIrr7zi7mYrbOrUqcrNzXU8du/e7fFtAgAAnA35EwAA8CcuXdOoWGZmptLS0rRo0SKX+oWGhio+Pl7bt2+XJMdv9ffu3avGjRs72u3du1ddu3Z1tNm3b5/TegoKCnTw4MEyf+svSeHh4QoPD3dpfAAAAJ5C/gQAAPyNW2capaamKjo6WoMGDXKpX2FhoTZu3OhIcFq2bKmYmBh9+umnjjZ5eXlavXq1evToIenUt205OTlat26do82KFStUVFSkhIQEd4YPAADgdeRPAADA37h8plFRUZFSU1M1evRohYQ4dx81apSaNGmilJQUSdL06dPVvXt3tWnTRjk5OZo5c6YyMzM1fvx4SafuDHLPPffoiSeeUNu2bR23jI2NjdWQIUMkSR06dNCAAQM0YcIEvfzyyzp58qTuuOMODR8+nDt/AAAAv0D+BAAA/JHLRaO0tDRlZWVp3LhxlmVZWVkKCvr95KVDhw5pwoQJys7OVv369dWtWzetXLlSHTt2dLR54IEHdPToUU2cOFE5OTm69NJLtWzZMtWoUcPR5s0339Qdd9yhK6+8UkFBQRo6dKief/55V4cOAADgE+RPAADAH9mMMcbXg/CGvLw8RUREKDc3V3a73dfDAQKKzZbkle10MQO8sp3qKkPdfT0EQBKf2VUJxwLwHG/lT4r00naqKbPf1yMATvHUZ7bbd08DAAAAAABA4KJoBAAAAAAAAAuXr2kEACUZk+TrIQAAAPgV8icA/oAzjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYBHi6wF4izFGkpSXl+fjkQAAgLMp/qwu/uyG75A/AQDgHzyVP1WbotHhw4clSXFxcT4eCQAAqIjDhw8rIiLC18Oo1sifAADwL5WdP9lMNfkar6ioSL/88ovq1q0rm83m6+F4TV5enuLi4rR7927Z7XZfD8frqnP8xE7s1S12qXrHH0ixG2N0+PBhxcbGKiiIX9L7EvmT/7+f3FGd4yd2Yif26iWQ4vdU/lRtzjQKCgpS06ZNfT0Mn7Hb7X7/JjgX1Tl+Yif26qg6xx8osXOGUdVA/hQY7yd3Vef4iZ3Yq5vqHLsUOPF7In/i6zsAAAAAAABYUDQCAAAAAACABUWjABceHq5p06YpPDzc10PxieocP7ETe3VUneOvzrEDla26v5+qc/zETuzVTXWOXSL+iqg2F8IGAAAAAABAxXGmEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAgqJRFTNjxgzZbDbdc889jnmvvvqq+vTpI7vdLpvNppycHEu/gwcPauTIkbLb7apXr55uueUWHTlyxKnNd999p8suu0w1atRQXFycnn76act63n77bZ133nmqUaOGOnXqpA8//NBpuTFGjz32mBo3bqyaNWsqMTFR27Zt82nsLVq0kM1mc3rMmDHDr2M/ePCg7rzzTrVv3141a9ZUs2bNdNdddyk3N9epX1ZWlgYNGqRatWopOjpa999/vwoKCpzafP7557rwwgsVHh6uNm3aaP78+Zbtz549Wy1atFCNGjWUkJCgb775xmn58ePHdfvtt6thw4aqU6eOhg4dqr1791ZK7OcSf8njbrPZtHDhQr+Kv7TX/a233qrWrVurZs2aioqK0uDBg/XDDz849QuEY+9u7IF63IsZYzRw4EDZbDYtWbLEaVkgHHfAE8ifyJ+k6pU/VefcqbT4JfIn8ifyJ48xqDK++eYb06JFC9O5c2dz9913O+Y/++yzJiUlxaSkpBhJ5tChQ5a+AwYMMF26dDGrVq0yX331lWnTpo0ZMWKEY3lubq5p1KiRGTlypNm0aZP55z//aWrWrGleeeUVR5uvv/7aBAcHm6efftps2bLFPPLIIyY0NNRs3LjR0WbGjBkmIiLCLFmyxGzYsMFcc801pmXLlua3337zWezNmzc306dPN3v27HE8jhw54texb9y40Vx33XVm6dKlZvv27ebTTz81bdu2NUOHDnX0KygoMBdccIFJTEw069evNx9++KGJjIw0U6dOdbT58ccfTa1atcyUKVPMli1bzAsvvGCCg4PNsmXLHG0WLlxowsLCzLx588zmzZvNhAkTTL169czevXsdbW677TYTFxdnPv30U7N27VrTvXt307Nnz3OK+1zjN8YYSSY1NdXp2J95PKp6/GW97l955RXzxRdfmJ07d5p169aZq6++2sTFxZmCggJjTGAce3djNyZwj3uxZ555xgwcONBIMosXL3bMD4TjDngC+RP5U3XLn6pz7lRW/MaQP5E/kT95CkWjKuLw4cOmbdu2Zvny5aZ3796lvhE+++yzUj/4t2zZYiSZNWvWOOZ99NFHxmazmZ9//tkYY8xLL71k6tevb/Lz8x1tHnzwQdO+fXvH9LBhw8ygQYOc1p2QkGBuvfVWY4wxRUVFJiYmxsycOdOxPCcnx4SHh5t//vOfPondmFNJz7PPPlvm+v099mL//ve/TVhYmDl58qQxxpgPP/zQBAUFmezsbEebOXPmGLvd7oj1gQceMOeff77Tev7v//7P9O/f3zF98cUXm9tvv90xXVhYaGJjY01KSoojztDQUPP222872nz//fdGkklPT3c7dmPOLX5jjOVDoaSqHL8rsW/YsMFIMtu3bzfG+P+xP5fYjQns475+/XrTpEkTs2fPHkuc/n7cAU8gfyJ/qm75U3XOnYwhfyJ/In/yBX6eVkXcfvvtGjRokBITE13um56ernr16umiiy5yzEtMTFRQUJBWr17taNOrVy+FhYU52vTv319bt27VoUOHHG1Kbr9///5KT0+XJO3cuVPZ2dlObSIiIpSQkOBo445zib3YjBkz1LBhQ8XHx2vmzJlOpxsGSuy5ubmy2+0KCQlxjLlTp05q1KiR05jz8vK0efPmCsV14sQJrVu3zqlNUFCQEhMTHW3WrVunkydPOrU577zz1KxZs3OKXTq3+M9cR2RkpC6++GLNmzdPxhjHsqocf0VjP3r0qFJTU9WyZUvFxcU54vLnY38usZ+5jkA77seOHdONN96o2bNnKyYmxrLc34874AnkT+RP5Qm0/Kk6507FYyd/In86E/mT54WU3wSetnDhQn377bdas2aNW/2zs7MVHR3tNC8kJEQNGjRQdna2o03Lli2d2hS/cbKzs1W/fn1lZ2c7vZmK25y5jjP7ldbGVecauyTddddduvDCC9WgQQOtXLlSU6dO1Z49e/TMM884xu3vsR84cECPP/64Jk6c6JhX1pjPHG9ZbfLy8vTbb7/p0KFDKiwsLLVN8e+gs7OzFRYWpnr16lnauBu7dO7xS9L06dN1xRVXqFatWvrkk080adIkHTlyRHfddZdj7FUx/orE/tJLL+mBBx7Q0aNH1b59ey1fvtyRuPvzsT/X2KXAPe6TJ09Wz549NXjw4FKX+/NxBzyB/In8qTyBlj9V59xJIn8ifyJ/8hWKRj62e/du3X333Vq+fLlq1Kjh6+F4VWXFPmXKFMe/O3furLCwMN16661KSUlReHh4ZQy10rkSe15engYNGqSOHTsqKSnJOwP0sMqK/9FHH3X8Oz4+XkePHtXMmTMdH35VUUVjHzlypPr27as9e/Zo1qxZGjZsmL7++mu//jtRWbEH4nFfunSpVqxYofXr1/tgdID/IX8if6pu+VN1zp0k8ifyJ/InX+LnaT62bt067du3TxdeeKFCQkIUEhKiL774Qs8//7xCQkJUWFhY7jpiYmK0b98+p3kFBQU6ePCg4xS9mJgYy5Xbi6fLa3Pm8jP7ldbGFZURe2kSEhJUUFCgXbt2Ocbtr7EfPnxYAwYMUN26dbV48WKFhoY61nEucdntdtWsWVORkZEKDg4uN/YTJ05Y7rzibuyVFX9pEhIS9NNPPyk/P7/Kxl/R2CMiItS2bVv16tVL77zzjn744QctXrz4rHEVLwvk2EsTCMd9+fLl2rFjh+rVq+dYLklDhw5Vnz59zhpX8bKqGjvgCeRP5E/VLX+qzrmTK/GTP5E/SeRPlY2ikY9deeWV2rhxozIyMhyPiy66SCNHjlRGRoaCg4PLXUePHj2Uk5OjdevWOeatWLFCRUVFSkhIcLT58ssvdfLkSUeb5cuXq3379qpfv76jzaeffuq07uXLl6tHjx6SpJYtWyomJsapTV5enlavXu1o4+3YS5ORkaGgoCDHKef+GnteXp769eunsLAwLV261FJd79GjhzZu3OiU8C5fvlx2u10dO3asUFxhYWHq1q2bU5uioiJ9+umnjjbdunVTaGioU5utW7cqKyvLrdgrK/7SZGRkqH79+o5vSKti/O687s2pmxY4PtT99dhXRuylCYTj/uc//1nfffed03JJevbZZ5WamuqIyx+PO+AJ5E/kT9Utf6rOuVNF4y+J/In8qTgufzzuVYpvrr+Nsyl5Rfg9e/aY9evXm9dee81IMl9++aVZv369+fXXXx1tBgwYYOLj483q1avNf//7X9O2bVunW8bm5OSYRo0amZtvvtls2rTJLFy40NSqVcty29SQkBAza9Ys8/3335tp06aVetvUevXqmXfffdd89913ZvDgwZVy21R3Y1+5cqV59tlnTUZGhtmxY4dZsGCBiYqKMqNGjfLr2HNzc01CQoLp1KmT2b59u9OtMUveNrRfv34mIyPDLFu2zERFRZV6+8j777/ffP/992b27Nml3j4yPDzczJ8/32zZssVMnDjR1KtXz+kOA7fddptp1qyZWbFihVm7dq3p0aOH6dGjR6XE7W78S5cuNa+99prZuHGj2bZtm3nppZdMrVq1zGOPPeZ38Z8Z+44dO8yTTz5p1q5dazIzM83XX39trr76atOgQQPHLT0D6di7GnugHvfSqIxbxgbCcQc8gfyp4rGTPwXG39LqnDuVjJ/8ifypGPlT5aNoVAWVfCNMmzbNSLI8UlNTHW1+/fVXM2LECFOnTh1jt9vN2LFjzeHDh53Wu2HDBnPppZea8PBw06RJEzNjxgzLtv/973+bdu3ambCwMHP++eebDz74wGl5UVGRefTRR02jRo1MeHi4ufLKK83WrVt9Fvu6detMQkKCiYiIMDVq1DAdOnQwTz75pDl+/Lhfx158i9zSHjt37nT02bVrlxk4cKCpWbOmiYyMNPfee6/TbVWL19W1a1cTFhZmWrVq5fS6KfbCCy+YZs2ambCwMHPxxRebVatWOS3/7bffzKRJk0z9+vVNrVq1zLXXXmv27NlTabG7E/9HH31kunbtaurUqWNq165tunTpYl5++WVTWFjod/GfGfvPP/9sBg4caKKjo01oaKhp2rSpufHGG80PP/zg1CdQjr2rsQfqcS9NyaTHmMA57oAnkD9VPHbyp8D4W1qdc6eS8ZM/kT8VI3+qfDZjzrjPHgAAAAAAACCuaQQAAAAAAIBSUDQCAAAAAACARYivB+BNx48f14kTJ3w9DAAAUI6wsLAK3fkHnkf+BACAf/BE/lRtikbHjx9XzZpRko74eigAAKAcMTEx2rlzJ4UjHyN/AgDAf3gif6o2RaNT35AdkTRZUu3Tc0NPP4eU8Xy25aEVaFNZy8vrUzxdjuByNhl0lmXBZcx3Z3lZy0JLaXu2cQdXYHlF11HeuM+278513zjanb4mfUih07MtuODUZEihgk/PCw4pOv1ccPr59Pyg088q/Tnk9HOQZfnpbajIMT/Y0rbAaR3BZ7Q91a7k8vLHUF4b18dQdruSsZa17d/XWV476z6r6DjL32flj6HcY1t4+rng9DYKzelpOT3bTm1KpzdlfS48/Sg5z5Xp4ueytlVYyesqb7qi6yq5DlfGVpnrKmdsJ0/3PX2oLdMFhc5dTpaxqrLmn7n8bMsquo6KbCNf0rPZ2Tpx4gRFIx879/yprGWVmT9VtG8l5E+l5U5n2+S55AgV7Xsu+VN5eVFl5k+VnVuWlj+VkjtJ8kj+VFoecOZzZeZPZedvlZc/lZ+7VF7+VHKfeSJ/Knv7Hsif3P2sdycX8GQuVjxdiTlKuWPzZC5Wcn6JPp7In9zJe1xpV1o4Zy7zVP5UbYpGvwuXVLwDy0oeKjJdVtLjiemK9imDrYLPQfo9+SnruWQSUPK5IolNeUlPZS6v6DrKTUgqsA13+jo9n71oZAstlK14nuP51LKg09NBQc4ffEElPlzLTjasH/BlF0nKK6JUfHnlb6P4Ofgs2wqq4Dpsp9sFOfX7/dlWYj02x7zf3w62EutUiWdzul3J+cXPxWM1Tu2DZc74d1GJbZ1+Ljz9XHB6nGUlPWV92J6tyFKRPq7Or8x1lTY/+IzlJXd0cZ+y/u6VXKetxPKSf0uL25fGVmK65P1LTRnzyxqbkU6eToxOH2qdtJWYPt20vASlItPltS1vHSHlLA8+49+oatzNn8paVpn50rluowyl5Uul5U4VeXYnf/JkflS8vLzcpDLzp8rMvZyeyy4a2UJL5k2Vlz+VXxypvPyp/Jzl3POn0nIn5+fKy59CSrT1RP5UWu7k/FyJ+dO55iiu9PNkLlZyGyXzJE/kTxXJnc7sW8yd/CnIuY0n8id3cquKtCstfyp5mDyZP3EhbAAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIBFiK8H4H35+j3swtPPxdMF5UyfPGM69PS/Q0u0KflcGcvL61M8XQZTweei0w+V8mw7/VxYYrr4WWVMlxxDWds9U8ltB5fRvrDE8pLzC/T7Lgousazk/LJ2f3CJ59IOV0XXUdZyR7vTAYYUOj2b4FOvQxNSKFM8L6To9POpZUWn59uCTj+r9Ocixw4o+Vxwut2ZO/H0thzPBU59zOm2xrHughLTpT8XLy9UoYJP/7vkc1GJ6SDHdIGj76nporO2CzmjXXCJZWVt+/d1lteueBu/j+Fs2y9tHcXtQ8ocQ9nPv//bnF6HOb3OU8/BhaefC04vP32oT7+cHM+24kNeUMbz7y8FlXgJVHy6+LmsbRVW8rrKm67oukquw5WxVXRd5T2X9Tf5jOeTp/90nD7UlumSQzgp1+afufxsyyq6jopsI1+oetzNn06WWOaJ/KmifSshfyorh/FE/mTKmK7M/Km03EnyTP7kan7kTv5USu7k/FyZ+VNpudPvz5WZP52ZO53aNZWfP5Wfu1Re/hRSyvbP7FsZ+VP5uVQl5k/u5g3u5DyezMWKp891Xa7sB3fX5U7+VGKeJ/Ind/IeV9qdOb+0ZZ7Kn6pN0SgsLEwxMTHKzn7W10PxnZJvJviF4lzvpH7/owAAgS4mJkZhYWG+Hka1R/4k8ic/dGbudOYzAAQ6T+RPNmNMye8xAtbx48d14sSJSltfXl6e4uLitHv3btnt9kpbb1UQyLFJxOfPAjk2ifj8WSDHJnk/vrCwMNWoUcPj20H5Kjt/Kk2gv3+8jf1ZudiflY99WrnYn5XLn/enJ/KnanOmkSTVqFHDIwmo3W73uxdTRQVybBLx+bNAjk0iPn8WyLFJgR8frDyVP5WG11flYn9WLvZn5WOfVi72Z+Vif57ChbABAAAAAABgQdEIAAAAAAAAFhSNzkF4eLimTZum8PBwXw+l0gVybBLx+bNAjk0iPn8WyLFJgR8ffIvXV+Vif1Yu9mflY59WLvZn5WJ/OqtWF8IGAAAAAABAxXCmEQAAAAAAACwoGgEAAAAAAMCCohEAAAAAAAAsKBoBAAAAAADAoloXjWbPnq0WLVqoRo0aSkhI0DfffHPW9m+//bbOO+881ahRQ506ddKHH37otHzRokXq16+fGjZsKJvNpoyMDMs6+vTpI5vN5vS47bbbKjMsSZUb28mTJ/Xggw+qU6dOql27tmJjYzVq1Cj98ssvTus4ePCgRo4cKbvdrnr16umWW27RkSNHKj02X8XXokULy7GbMWNGlY9PkpKSknTeeeepdu3aql+/vhITE7V69WqnNt46fr6IzZ+P3Zluu+022Ww2Pffcc07z/fW9V1JZ8Xnr+FV2bGPGjLGMe8CAAU5t/PnYVSQ+b773UPX4Is8KZL7IfQKZL/KRQOaL/CCQ+eIzO9B54jX6/fff65prrlFERIRq166tP/zhD8rKyvJUCL5jqqmFCxeasLAwM2/ePLN582YzYcIEU69ePbN3795S23/99dcmODjYPP3002bLli3mkUceMaGhoWbjxo2ONm+88YZJTk42r732mpFk1q9fb1lP7969zYQJE8yePXscj9zc3CodW05OjklMTDT/+te/zA8//GDS09PNxRdfbLp16+a0ngEDBpguXbqYVatWma+++sq0adPGjBgxolJj82V8zZs3N9OnT3c6dkeOHKny8RljzJtvvmmWL19uduzYYTZt2mRuueUWY7fbzb59+xxtvHH8fBWbPx+7YosWLTJdunQxsbGx5tlnn3Va5q/vvYrG543j54nYRo8ebQYMGOA07oMHDzqtx5+PXUXi89Z7D1WPr/KsQOWr3CdQ+SofCVS+yg8Cla8+swOZJ/bp9u3bTYMGDcz9999vvv32W7N9+3bz7rvvlrlOf1Zti0YXX3yxuf322x3ThYWFJjY21qSkpJTaftiwYWbQoEFO8xISEsytt95qabtz586zFo3uvvvucxp7eTwZW7FvvvnGSDKZmZnGGGO2bNliJJk1a9Y42nz00UfGZrOZn3/++VzCsfBFfMac+s+PNz6svBFfbm6ukWTS0tKMMd47fr6IzRj/P3Y//fSTadKkidm0aZMllkB4750tPmO8c/w8Edvo0aPN4MGDy9ymvx+78uIzxnvvPVQ9vsqzApWvcp9A5at8JFD5Kj8IVL76zA5kntin//d//2duuukmzwy4iqmWP087ceKE1q1bp8TERMe8oKAgJSYmKj09vdQ+6enpTu0lqX///mW2P5s333xTkZGRuuCCCzR16lQdO3bM5XWUxVux5ebmymazqV69eo511KtXTxdddJGjTWJiooKCgir11FxfxVdsxowZatiwoeLj4zVz5kwVFBS4H0wpvBHfiRMn9OqrryoiIkJdunRxrMPTx89XsRXz12NXVFSkm2++Wffff7/OP//8Utfhz++98uIr5snj58nX5ueff67o6Gi1b99ef/rTn/Trr786rcOfj5109viKefq9h6rH13lWoPF17hNofJ2PBBpf5weBxtef2YHIE/u0qKhIH3zwgdq1a6f+/fsrOjpaCQkJWrJkicfi8KUQXw/AFw4cOKDCwkI1atTIaX6jRo30ww8/lNonOzu71PbZ2dkubfvGG29U8+bNFRsbq++++04PPvigtm7dqkWLFrkWRBm8Edvx48f14IMPasSIEbLb7Y51REdHO7ULCQlRgwYNXN5HZ+Or+CTprrvu0oUXXqgGDRpo5cqVmjp1qvbs2aNnnnnmHKP6nSfje//99zV8+HAdO3ZMjRs31vLlyxUZGelYh6ePn69ik/z72D311FMKCQnRXXfdVeY6/Pm9V158kuePn6diGzBggK677jq1bNlSO3bs0MMPP6yBAwcqPT1dwcHBfn/syotP8s57D1WPL/OsQOTL3CcQ+TIfCUS+zA8CkS8/swOVJ/bpvn37dOTIEc2YMUNPPPGEnnrqKS1btkzXXXedPvvsM/Xu3dszwfhItSwa+dLEiRMd/+7UqZMaN26sK6+8Ujt27FDr1q19OLKKOXnypIYNGyZjjObMmePr4VS6s8U3ZcoUx787d+6ssLAw3XrrrUpJSVF4eLi3h+qyyy+/XBkZGTpw4IBee+01DRs2TKtXr7b8p9UflRebvx67devW6W9/+5u+/fZb2Ww2Xw+n0lU0Pn89fsOHD3f8u1OnTurcubNat26tzz//XFdeeaUPR1Y5KhKfvx47oDoJ9NzOmwI51/KmQM9/fCHQcxJvKyoqkiQNHjxYkydPliR17dpVK1eu1MsvvxxwRaNq+fO0yMhIBQcHa+/evU7z9+7dq5iYmFL7xMTEuNS+ohISEiRJ27dvP6f1FPNkbMVJRWZmppYvX+70TVRMTIz27dvn1L6goEAHDx485310Jl/FV5qEhAQVFBRo165drgdSBk/GV7t2bbVp00bdu3fX3LlzFRISorlz5zrW4enj56vYSuMvx+6rr77Svn371KxZM4WEhCgkJESZmZm699571aJFC8c6/PW9V5H4SlPZx89bnwmtWrVSZGSk4++9Px+70pSMrzSeeO+h6qlKeVYgqEq5TyCoSvlIIKhK+UEgqEqf2YHCE/s0MjJSISEh6tixo1ObDh06BOTd06pl0SgsLEzdunXTp59+6phXVFSkTz/9VD169Ci1T48ePZzaS9Ly5cvLbF9RxbeLbdy48Tmtp5inYitOKrZt26a0tDQ1bNjQso6cnBytW7fOMW/FihUqKipyFMYqg6/iK01GRoaCgoIq9dsjb742i4qKlJ+f71iHp4+fr2Irjb8cu5tvvlnfffedMjIyHI/Y2Fjdf//9+vjjjx3r8Nf3XkXiK01lHz9vvTZ/+ukn/frrr46/9/587EpTMr7SeOK9h6qnKuVZgaAq5T6BoCrlI4GgKuUHgaAqfWYHCk/s07CwMP3hD3/Q1q1bndr873//U/PmzSs5girAxxfi9pmFCxea8PBwM3/+fLNlyxYzceJEU69ePZOdnW2MMebmm282Dz30kKP9119/bUJCQsysWbPM999/b6ZNm2a57d6vv/5q1q9fbz744AMjySxcuNCsX7/e7Nmzxxhz6rZ806dPN2vXrjU7d+407777rmnVqpXp1atXlY7txIkT5pprrjFNmzY1GRkZTrdqzM/Pd6xnwIABJj4+3qxevdr897//NW3btvXYraO9Hd/KlSvNs88+azIyMsyOHTvMggULTFRUlBk1alSVj+/IkSNm6tSpJj093ezatcusXbvWjB071oSHh5tNmzY51uON4+eL2Pz52JWmtLuH+Ot7ryLxeev4VXZshw8fNvfdd59JT083O3fuNGlpaebCCy80bdu2NcePH3esx1+PXUXi8+Z7D1WPL/KsQOar3C5Q+SrXClS+yn8Cla9ykkDmidfookWLTGhoqHn11VfNtm3bzAsvvGCCg4PNV1995fX4PK3aFo2MMeaFF14wzZo1M2FhYebiiy82q1atcizr3bu3GT16tFP7f//736Zdu3YmLCzMnH/++eaDDz5wWp6ammokWR7Tpk0zxhiTlZVlevXqZRo0aGDCw8NNmzZtzP33329yc3OrdGzFt7Yt7fHZZ5852v36669mxIgRpk6dOsZut5uxY8eaw4cPV3psvohv3bp1JiEhwURERJgaNWqYDh06mCeffNJjf2grM77ffvvNXHvttSY2NtaEhYWZxo0bm2uuucZ88803Tuvw1vHzdmz+fOxKU1rS5K/vvdKUjM+bx68yYzt27Jjp16+fiYqKMqGhoaZ58+ZmwoQJjuSkmL8eu4rE5+33Hqoeb+dZgc4XuV0g80WuFch8kf8EMl/kJIHOE6/RuXPnmjZt2pgaNWqYLl26mCVLlng6DJ+wGWOMN85oAgAAAAAAgP+oltc0AgAAAAAAwNlRNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAPADX375pa6++mrFxsbKZrNpyZIl5fb5/PPPdeGFFyo8PFxt2rTR/PnzPT5OAAAQOCgaAQAA+IGjR4+qS5cumj17doXa79y5U4MGDdLll1+ujIwM3XPPPRo/frw+/vhjD48UAAAECpsxxvh6EAAAAKg4m82mxYsXa8iQIWW2efDBB/XBBx9o06ZNjnnDhw9XTk6Oli1b5oVRAgAAfxfi6wEAAACg8qWnpysxMdFpXv/+/XXPPfeU2Sc/P1/5+fmO6aKiIh08eFANGzaUzWbz1FABAMA5Msbo8OHDio2NVVBQ5f2ojKIRAABAAMrOzlajRo2c5jVq1Eh5eXn67bffVLNmTUuflJQUJScne2uIAACgku3evVtNmzattPVRNAIAAIAkaerUqZoyZYpjOjc3V82aNdPu3btlt9t9ODIAAHA2eXl5iouLU926dSt1vRSNAAAAAlBMTIz27t3rNG/v3r2y2+2lnmUkSeHh4QoPD7fMt9vtFI0AAPADlf1zcu6eBgAAEIB69OihTz/91Gne8uXL1aNHDx+NCAAA+BuKRgAAAH7gyJEjysjIUEZGhiRp586dysjIUFZWlqRTPy0bNWqUo/1tt92mH3/8UQ888IB++OEHvfTSS/r3v/+tyZMn+2L4AADAD1E0AgAA8ANr165VfHy84uPjJUlTpkxRfHy8HnvsMUnSnj17HAUkSWrZsqU++OADLV++XF26dNFf//pX/f3vf1f//v19Mn4AAOB/bMYY4+tBAAAAoOrJy8tTRESEcnNzuaYRAABVmKc+sznTCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AAAAAAABgQdEIAAAAAAAAFhSNAAAAAAAAYEHRCAAAAAAAABYUjQAAAAAAAGBB0QgAAAAAAAAWFI0AnLP58+fLZrNp165dvh6KR82cOVOtWrVScHCwunbtKklq0aKFxowZU27f6rKPAAAAAAQOikaADxQXEIofNWrUULt27XTHHXdo7969lb69Y8eOKSkpSZ9//nmlr7u6+OSTT/TAAw/okksuUWpqqp588klfDwkAAAAAPCrE1wMAqrPp06erZcuWOn78uP773/9qzpw5+vDDD7Vp0ybVqlWr0rZz7NgxJScnS5L69OlTaestdvPNN2v48OEKDw+v9HVXFStWrFBQUJDmzp2rsLAwx/ytW7cqKIj6OwAAAIDAQ9EI8KGBAwfqoosukiSNHz9eDRs21DPPPKN3331XI0aM8PHoynf06FHVrl1bwcHBCg4OrrT1Hjt2rFKLZpVh3759qlmzplPBSFJAF8oAAAAAVG98PQ5UIVdccYUkaefOnZKkgoICPf7442rdurXCw8PVokULPfzww8rPz3fqt3btWvXv31+RkZGqWbOmWrZsqXHjxkmSdu3apaioKElScnKy4ydxSUlJjv4//PCDrr/+ejVo0EA1atTQRRddpKVLlzpto/gndV988YUmTZqk6OhoNW3a1GlZyev1vPTSSzr//PMVHh6u2NhY3X777crJyXFq06dPH11wwQVat26devXqpVq1aunhhx8+63764YcfNGzYMEVFRalmzZpq3769/vznPzu1Wb9+vQYOHCi73a46deroyiuv1KpVq0qN6euvv9aUKVMUFRWl2rVr69prr9X+/fsd7Ww2m1JTU3X06FHH/ps/f76k0q9ptHnzZl1xxRWqWbOmmjZtqieeeEJFRUWlxvLRRx/psssuU+3atVW3bl0NGjRImzdvdmozZswY1alTRz///LOGDBmiOnXqKCoqSvfdd58KCwud2hYVFelvf/ubOnXqpBo1aigqKkoDBgzQ2rVrndotWLBA3bp1U82aNdWgQQMNHz5cu3fvPut+BwAAAFC9cKYRUIXs2LFDktSwYUNJp84+ev3113X99dfr3nvv1erVq5WSkqLvv/9eixcvlnTqDJh+/fopKipKDz30kOrVq6ddu3Zp0aJFkqSoqCjNmTNHf/rTn3TttdfquuuukyR17txZ0qkCxyWXXKImTZrooYceUu3atfXvf/9bQ4YM0X/+8x9de+21TmOcNGmSoqKi9Nhjj+no0aNlxpKUlKTk5GQlJibqT3/6k7Zu3ao5c+ZozZo1+vrrrxUaGupo++uvv2rgwIEaPny4brrpJjVq1KjM9X733Xe67LLLFBoaqokTJ6pFixbasWOH3nvvPf3lL39xxHTZZZfJbrfrgQceUGhoqF555RX16dNHX3zxhRISEpzWeeedd6p+/fqaNm2adu3apeeee0533HGH/vWvf0mS/vGPf+jVV1/VN998o7///e+SpJ49e5Y6vuzsbF1++eUqKChw7M9XX31VNWvWtLT9xz/+odGjR6t///566qmndOzYMc2ZM0eXXnqp1q9frxYtWjjaFhYWqn///kpISNCsWbOUlpamv/71r2rdurX+9Kc/Odrdcsstmj9/vgYOHKjx48eroKBAX331lVatWuU4q+0vf/mLHn30UQ0bNkzjx4/X/v379cILL6hXr15av3696tWrV+b+BwAAAFCNGABel5qaaiSZtLQ0s3//frN7926zcOFC07BhQ1OzZk3z008/mYyMDCPJjB8/3qnvfffdZySZFStWGGOMWbx4sZFk1qxZU+b29u/fbySZadOmWZZdeeWVplOnTub48eOOeUVFRaZnz56mbdu2ljFfeumlpqCgoNR4du7caYwxZt++fSYsLMz069fPFBYWOtq9+OKLRpKZN2+eY17v3r2NJPPyyy+Xv+OMMb169TJ169Y1mZmZTvOLiooc/x4yZIgJCwszO3bscMz75ZdfTN26dU2vXr0s405MTHTqP3nyZBMcHGxycnIc80aPHm1q165tGU/z5s3N6NGjHdP33HOPkWRWr17tmLdv3z4TERHhtI8OHz5s6tWrZyZMmOC0vuzsbBMREeE0f/To0UaSmT59ulPb+Ph4061bN8f0ihUrjCRz1113WcZZHN+uXbtMcHCw+ctf/uK0fOPGjSYkJMQyH0D1lpubaySZ3NxcXw8FAACchac+s/l5GuBDiYmJioqKUlxcnIYPH646depo8eLFatKkiT788ENJ0pQpU5z63HvvvZKkDz74QJIcZ4W8//77OnnypEvbP3jwoFasWKFhw4bp8OHDOnDggA4cOKBff/1V/fv317Zt2/Tzzz879ZkwYUK51y9KS0vTiRMndM899zhdJHrChAmy2+2OsRcLDw/X2LFjyx3v/v379eWXX2rcuHFq1qyZ0zKbzSbp1Bk5n3zyiYYMGaJWrVo5ljdu3Fg33nij/vvf/yovL8+p78SJEx39Jemyyy5TYWGhMjMzyx1TSR9++KG6d++uiy++2DEvKipKI0eOdGq3fPly5eTkaMSIEY79fuDAAQUHByshIUGfffaZZd233Xab0/Rll12mH3/80TH9n//8RzabTdOmTbP0LY5v0aJFKioq0rBhw5y2GxMTo7Zt25a6XQAAAADVU7UsGn355Ze6+uqrFRsbK5vNpiVLlri8DmOMZs2apXbt2ik8PFxNmjRx/DQGqKjZs2dr+fLl+uyzz7Rlyxb9+OOP6t+/vyQpMzNTQUFBatOmjVOfmJgY1atXz1HQ6N27t4YOHark5GRFRkZq8ODBSk1NtVz3qDTbt2+XMUaPPvqooqKinB7FhYd9+/Y59WnZsmW56y0eW/v27Z3mh4WFqVWrVpZiTJMmTSwXmC5NcYHkggsuKLPN/v37dezYMcu2JalDhw4qKiqyXLunZAGqfv36kqRDhw6VO6aSMjMz1bZtW8v8kuPZtm2bpFPXsSq57z/55BPLfi++PlHJcZ45xh07dig2NlYNGjQoc3zbtm2TMUZt27a1bPf777+3bBcAAABA9VUtr2l09OhRdenSRePGjXNc38VVd999tz755BPNmjVLnTp10sGDB3Xw4MFKHikC3cUXX+y4zkxZzjwDpqzl77zzjlatWqX33ntPH3/8scaNG6e//vWvWrVqlerUqVNm3+KLM993332OYlVJJYtWpV2b51x5Yp2uKOvMKWOMx7ZZvO//8Y9/KCYmxrI8JMT5z3Nl3Z2uqKhINptNH330UanrPNvrBQAAAED1Ui2LRgMHDtTAgQPLXJ6fn68///nP+uc//6mcnBxdcMEFeuqpp9SnTx9J0vfff685c+Zo06ZNjrMHKnL2BeCK5s2bq6ioSNu2bVOHDh0c8/fu3aucnBw1b97cqX337t3VvXt3/eUvf9Fbb72lkSNHauHChRo/fnyZhafin2+FhoYqMTGxUscuSVu3bnX6idiJEye0c+dOt7dVvK5NmzaV2SYqKkq1atXS1q1bLct++OEHBQUFKS4uzq3tV0Tz5s0dZxGdqeR4WrduLUmKjo6utH3funVrffzxxzp48GCZZxu1bt1axhi1bNlS7dq1q5TtAgAAAAhM1fLnaeW54447lJ6eroULF+q7777TDTfcoAEDBjj+I/jee++pVatWev/999WyZUu1aNFC48eP50wjVKqrrrpKkvTcc885zX/mmWckSYMGDZJ06idUJc+I6dq1qyQ5fqJWq1YtSbLc7j46Olp9+vTRK6+8oj179ljGcOZt512RmJiosLAwPf/8805jmzt3rnJzcx1jd1VUVJR69eqlefPmKSsry2lZ8XaCg4PVr18/vfvuu9q1a5dj+d69e/XWW2/p0ksvld1ud2v7FXHVVVdp1apV+uabbxzz9u/frzfffNOpXf/+/WW32/Xkk0+Wei0qd/b90KFDZYxRcnKyZVnx/rnuuusUHBys5ORky+vGGKNff/3V5e0CAAAACEzV8kyjs8nKylJqaqqysrIUGxsr6dRPd5YtW6bU1FQ9+eST+vHHH5WZmam3335bb7zxhgoLCzV58mRdf/31WrFihY8jQKDo0qWLRo8erVdffVU5OTnq3bu3vvnmG73++usaMmSILr/8cknS66+/rpdeeknXXnutWrdurcOHD+u1116T3W53FJ5q1qypjh076l//+pfatWunBg0a6IILLtAFF1yg2bNn69JLL1WnTp00YcIEtWrVSnv37lV6erp++uknbdiwweWxR0VFaerUqUpOTtaAAQN0zTXXaOvWrXrppZf0hz/8QTfddJPb++X555/XpZdeqgsvvFATJ05Uy5YttWvXLn3wwQfKyMiQJD3xxBNavny5Lr30Uk2aNEkhISF65ZVXlJ+fr6efftrtbVfEAw88oH/84x8aMGCA7r77btWuXVuvvvqqmjdvru+++87Rzm63a86cObr55pt14YUXavjw4YqKilJWVpY++OADXXLJJXrxxRdd2vbll1+um2++Wc8//7y2bdumAQMGqKioSF999ZUuv/xy3XHHHWrdurWeeOIJTZ06Vbt27dKQIUNUt25d7dy5U4sXL9bEiRN13333VfZuAQAAAOCHKBqVsHHjRhUWFlp+tpGfn6+GDRtKOnVNkPz8fL3xxhuOdnPnzlW3bt20devWUi/AC7jj73//u1q1aqX58+dr8eLFiomJ0dSpU53ujlVcTFq4cKH27t2riIgIXXzxxXrzzTedfjb597//XXfeeacmT56sEydOaNq0abrgggvUsWNHrV27VsnJyZo/f75+/fVXRUdHKz4+Xo899pjbY09KSlJUVJRefPFFTZ48WQ0aNNDEiRP15JNPKjQ01O31dunSRatWrdKjjz6qOXPm6Pjx42revLmGDRvmaHP++efrq6++0tSpU5WSkqKioiIlJCRowYIFSkhIcHvbFdG4cWN99tlnuvPOOzVjxgw1bNhQt912m2JjY3XLLbc4tb3xxhsVGxurGTNmaObMmcrPz1eTJk102WWXVehucqVJTU1V586dNXfuXN1///2KiIjQRRddpJ49ezraPPTQQ2rXrp2effZZx1lJcXFx6tevn6655hr3gwcAAAAQUGzGk1d69QM2m02LFy/WkCFDJEn/+te/NHLkSG3evNlykdg6deooJiZG06ZNs/yk5LffflOtWrX0ySefqG/fvt4MAQAAwCPy8vIUERGh3Nxcj/60FwAAnBtPfWZzplEJ8fHxKiws1L59+3TZZZeV2uaSSy5RQUGBduzY4biY7f/+9z9JslycGAAAAAAAwB9Vy6LRkSNHtH37dsf0zp07lZGRoQYNGqhdu3YaOXKkRo0apb/+9a+Kj4/X/v379emnn6pz584aNGiQEhMTdeGFF2rcuHF67rnnVFRUpNtvv119+/blbkQAAAAAACAgVMu7p61du1bx8fGKj4+XJE2ZMsXp+i2pqakaNWqU7r33XrVv315DhgzRmjVr1KxZM0lSUFCQ3nvvPUVGRqpXr14aNGiQOnTooIULF/osJgAAAAAAgMpU7a9pBAAAgNJxTSMAAPyDpz6zq+WZRgAAAAAAADg7ikYAAAAAAACwqDYXwi4qKtIvv/yiunXrymaz+Xo4AACgDMYYHT58WLGxsQoK4vstAAAAX6k2RaNffvlFcXFxvh4GAACooN27d6tp06a+HgYAAEC1VW2KRnXr1pV0KgHlQo4AAFRdeXl5iouLc3x2AwAAwDeqTdGo+CdpdrudohEAAH6An5MDAAD4FhcKAAAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAAAgAVFIwAAAAAAAFhQNAIAAAAAAIBFiCuNW7RooczMTMv8SZMmafbs2Zb58+fP19ixY53mhYeH6/jx45KkkydP6pFHHtGHH36oH3/8UREREUpMTNSMGTMUGxt71u2mpKTooYcecmX4XpFXw+brIfjUM/me38aUcM9vw37ceH4jAAAAAABUYS4VjdasWaPCwkLH9KZNm9S3b1/dcMMNZfax2+3aunWrY9pm+72ocuzYMX377bd69NFH1aVLFx06dEh33323rrnmGq1du9ZpPdOnT9eECRMc03Xr1nVl6AAAAAAAAHCBS0WjqKgop+kZM2aodevW6t27d5l9bDabYmJiSl0WERGh5cuXO8178cUXdfHFFysrK0vNmjVzzK9bt26Z6wEAAAAAAEDlcvuaRidOnNCCBQs0btw4p7OHSjpy5IiaN2+uuLg4DR48WJs3bz7renNzc2Wz2VSvXj2n+TNmzFDDhg0VHx+vmTNnqqCg4Kzryc/PV15entMDAAAAAAAAFePSmUZnWrJkiXJycjRmzJgy27Rv317z5s1T586dlZubq1mzZqlnz57avHmzmjZtaml//PhxPfjggxoxYoTsdrtj/l133aULL7xQDRo00MqVKzV16lTt2bNHzzzzTJnbTklJUXJysrvhAQAAAAAAVGs2Y4xbV/zt37+/wsLC9N5771W4z8mTJ9WhQweNGDFCjz/+uGXZ0KFD9dNPP+nzzz93KhqVNG/ePN166606cuSIwsNLvypyfn6+8vN/vypzXl6e4uLilJube9Z1nysuhO35bXAhbAAIbHl5eYqIiPD4ZzbKx7EAAMA/eOoz260zjTIzM5WWlqZFixa51C80NFTx8fHavn270/yTJ09q2LBhyszM1IoVK8oNMCEhQQUFBdq1a5fat29fapvw8PAyC0oAAAAAAAA4O7euaZSamqro6GgNGjTIpX6FhYXauHGjGjdu7JhXXDDatm2b0tLS1LBhw3LXk5GRoaCgIEVHR7s8dgAAAAAAAJTP5TONioqKlJqaqtGjRyskxLn7qFGj1KRJE6WkpEiSpk+fru7du6tNmzbKycnRzJkzlZmZqfHjx0s6VTC6/vrr9e233+r9999XYWGhsrOzJUkNGjRQWFiY0tPTtXr1al1++eWqW7eu0tPTNXnyZN10002qX7/+ucYPAAAAAACAUrhcNEpLS1NWVpbGjRtnWZaVlaWgoN9PXjp06JAmTJig7Oxs1a9fX926ddPKlSvVsWNHSdLPP/+spUuXSpK6du3qtK7PPvtMffr0UXh4uBYuXKikpCTl5+erZcuWmjx5sqZMmeLq0AEAAAAAAFBBbl8I299460KOXAjb89vgQtgAENi4+HLVwbEAAMA/eOoz261rGgEAAAAAACCwuXX3NJTNnTNtvHHmjDfOAPIWb+zj6n7GmDdwNhcAAAAAVG2caQQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALCgaAQAAAAAAAALikYAAAAAAACwoGgEAAAAAAAAC4pGAAAAAAAAsKBoBAAAAAAAAAuKRgAAAAAAALAI8fUAAs2UcF+PoHTujOuZ/Mofh6+4GktVPY6BJK+GzddDKJX9uPH1EAAAAACgSuBMIwAAAAAAAFhQNAIAAAAAAIAFRSMAAAAAAABYUDQCAAAAAACABUUjAAAAAAAAWFA0AgAAAAD8f3t3Hx1Vde9//DNJyAQqE0BIAhgJBUSoQBBKCD5QaxCRReFeq4D8CPKoV7BIWgUqEEGvoUKRqlGUy0O7EPFhIXKFmxaCaJUUMEAFRCoCCVomipAMREkg2b8/hJHJSUhmSGYyk/drrVnDOWfvc7777CFDPpw5AwAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFhEBLqAULOoJNAVoDb4Mo9p9tqvA/7nirIFuoRKOc6aQJcAAAAAoIHhSiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAQJDIzMxUQkKCoqKilJSUpB07dly2/eLFi9W5c2c1btxY8fHxmjZtms6ePeunagEAQLAjNAIAAAgCr7/+utLS0pSenq5du3apR48eGjhwoL7++utK269evVozZsxQenq6Dhw4oGXLlun111/X73//ez9XDgAAghWhEQAAQBBYtGiRJk6cqLFjx6pr165asmSJmjRpouXLl1faftu2bbrpppt03333KSEhQXfccYdGjhxZ7dVJAAAAFxEaAQAA1HOlpaXKzc1VSkqKe11YWJhSUlKUk5NTaZ9+/fopNzfXHRIdPnxYGzdu1F133VXlcUpKSuRyuTweAACg4YoIdAEAAAC4vBMnTqisrEyxsbEe62NjY/XZZ59V2ue+++7TiRMndPPNN8sYo/Pnz+vBBx+87MfTMjIyNHfu3FqtHQAABC+uNAIAAAhBW7du1dNPP60XX3xRu3bt0tq1a7VhwwY9+eSTVfaZOXOmioqK3I9jx475sWIAAFDfcKVRLUuze99nUUnt1wH/88c8+vL6QmhwRdkCXUKlHGdNoEsAGoSWLVsqPDxcBQUFHusLCgoUFxdXaZ/Zs2dr9OjRmjBhgiSpW7duKi4u1qRJk/T4448rLMz6f4d2u112O282AADgB1xpBAAAUM9FRkaqV69eys7Odq8rLy9Xdna2kpOTK+3z3XffWYKh8PBwSZIxBL4AAKB6XGkEAAAQBNLS0jRmzBj17t1bffr00eLFi1VcXKyxY8dKklJTU9W2bVtlZGRIkoYMGaJFixapZ8+eSkpK0qFDhzR79mwNGTLEHR4BAABcDqERAABAEBg+fLi++eYbzZkzR06nU4mJicrKynLfHDs/P9/jyqJZs2bJZrNp1qxZ+uqrr9SqVSsNGTJE//3f/x2oIQAAgCBjMw3k+mSXy6Xo6GgVFRXJ4XDU3XF8uO8I9zRCTXFPI9Q33NMIdcFf79moHnMBAEBwqKv3bO5pBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYBHhTeOEhATl5eVZ1j/00EPKzMy0rF+5cqXGjh3rsc5ut+vs2bOSpHPnzmnWrFnauHGjDh8+rOjoaKWkpGj+/Plq06aNu8/Jkyf18MMP63//938VFhamu+++W3/605901VVXeVM+EPQWlXjfJ81e+3UAF7mibIEuoVKOsybQJQAAAABBz6vQaOfOnSorK3Mv79u3TwMGDNA999xTZR+Hw6GDBw+6l222H3/B+O6777Rr1y7Nnj1bPXr00KlTpzR16lT96le/0scff+xuN2rUKB0/flybNm3SuXPnNHbsWE2aNEmrV6/2pnwAAAAAAADUkFehUatWrTyW58+frw4dOqh///5V9rHZbIqLi6t0W3R0tDZt2uSx7oUXXlCfPn2Un5+va6+9VgcOHFBWVpZ27typ3r17S5Kef/553XXXXVq4cKHHFUkAAAAAAACoHT7f06i0tFSrVq3SuHHjPK4equjMmTNq166d4uPjNXToUO3fv/+y+y0qKpLNZlOzZs0kSTk5OWrWrJk7MJKklJQUhYWFafv27VXup6SkRC6Xy+MBAAAAAACAmvE5NFq3bp0KCwt1//33V9mmc+fOWr58ud555x2tWrVK5eXl6tevn7788stK2589e1bTp0/XyJEj5XA4JElOp1MxMTEe7SIiItSiRQs5nc4qj52RkaHo6Gj3Iz4+3vtBAgAAAAAANFA+h0bLli3ToEGDLvvxsOTkZKWmpioxMVH9+/fX2rVr1apVK7388suWtufOndO9994rY4xeeuklX8tymzlzpoqKityPY8eOXfE+AQAAAAAAGgqv7ml0UV5enjZv3qy1a9d61a9Ro0bq2bOnDh065LH+YmCUl5enLVu2uK8ykqS4uDh9/fXXHu3Pnz+vkydPVnmvJOmHb2mz2/naKAAAAAAAAF/4dKXRihUrFBMTo8GDB3vVr6ysTHv37lXr1q3d6y4GRp9//rk2b96sq6++2qNPcnKyCgsLlZub6163ZcsWlZeXKykpyZfyAQAAAAAAUA2vrzQqLy/XihUrNGbMGEVEeHZPTU1V27ZtlZGRIUmaN2+e+vbtq44dO6qwsFALFixQXl6eJkyYIOmHwOjXv/61du3apXfffVdlZWXu+xS1aNFCkZGR6tKli+68805NnDhRS5Ys0blz5zRlyhSNGDGCb04DAAAAAACoI16HRps3b1Z+fr7GjRtn2Zafn6+wsB8vXjp16pQmTpwop9Op5s2bq1evXtq2bZu6du0qSfrqq6+0fv16SVJiYqLHvt577z394he/kCS9+uqrmjJlim6//XaFhYXp7rvv1nPPPedt6QAAAAAAAKghmzHGBLoIf3C5XIqOjlZRUZHHPZNq/ThRNq/7LCqpg0KAC9K4tRcaIMfZBvHWFrL89Z6N6jEXAAAEh7p6z/b529MAAAAAAAAQugiNAAAAAAAAYOH1PY1web581MyXjw/xkbb6p77Oo79ek0B94stHhesrPmoHAACAQOFKIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWEYEuINSk2QNdQeV8qWtRSe3XURv8cY7r69gBNDyuKFugS6iU46wJdAkAAACoY1xpBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWEYEuINQsKvG+T5q97vv4qy5vjzNX6V4fY64PYymyz/WqvT/GXp95OxZfzheA4OaKsnnV3nHW1FElAAAAqCtcaQQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFhGBLgDSopK6P0aave6P4Ysi+1yv+/jjfPnjGAAAAAAA1GdcaQQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAIsKbxgkJCcrLy7Osf+ihh5SZmWlZv3LlSo0dO9Zjnd1u19mzZ93La9eu1ZIlS5Sbm6uTJ09q9+7dSkxM9Ojzi1/8Qu+//77HugceeEBLlizxpny/SLN732dRSe3XESjejr++jr2hzyMAAAAAAF6FRjt37lRZWZl7ed++fRowYIDuueeeKvs4HA4dPHjQvWyz2Ty2FxcX6+abb9a9996riRMnVrmfiRMnat68ee7lJk2aeFM6AAAAAAAAvOBVaNSqVSuP5fnz56tDhw7q379/lX1sNpvi4uKq3D569GhJ0tGjRy977CZNmlx2PwAAAAAAAKg9Pt/TqLS0VKtWrdK4ceMsVw9d6syZM2rXrp3i4+M1dOhQ7d+/36fjvfrqq2rZsqVuuOEGzZw5U999952vpQMAAAAAAKAaXl1pdKl169apsLBQ999/f5VtOnfurOXLl6t79+4qKirSwoUL1a9fP+3fv1/XXHNNjY913333qV27dmrTpo0++eQTTZ8+XQcPHtTatWur7FNSUqKSkh9vMuNyuWp8PAAAAAAAgIbO59Bo2bJlGjRokNq0aVNlm+TkZCUnJ7uX+/Xrpy5duujll1/Wk08+WeNjTZo0yf3nbt26qXXr1rr99tv1xRdfqEOHDpX2ycjI0Ny5c2t8DAAAAAAAAPzIp4+n5eXlafPmzZowYYJX/Ro1aqSePXvq0KFDvhzWLSkpSZIuu5+ZM2eqqKjI/Th27NgVHRMAAAAAAKAh8Sk0WrFihWJiYjR48GCv+pWVlWnv3r1q3bq1L4d127NnjyRddj92u10Oh8PjAQAAAAAAgJrx+uNp5eXlWrFihcaMGaOICM/uqampatu2rTIyMiRJ8+bNU9++fdWxY0cVFhZqwYIFysvL87hC6eTJk8rPz9e///1vSdLBgwclSXFxcYqLi9MXX3yh1atX66677tLVV1+tTz75RNOmTdOtt96q7t27+zxwAAAAAAAAVM3r0Gjz5s3Kz8/XuHHjLNvy8/MVFvbjxUunTp3SxIkT5XQ61bx5c/Xq1Uvbtm1T165d3W3Wr1+vsWPHupdHjBghSUpPT9cTTzyhyMhIbd68WYsXL1ZxcbHi4+N19913a9asWd6WDgAAAAAAgBqyGWNMoIvwB5fLpejoaBUVFdXpR9VcUTav+ywqqb7NlUqz1/0xfOGPsUv+Gb+/xlIf1dfXF4D6w3G25v/c8Nd7NqrHXAAAEBzq6j3bp3saAQAAAAAAILQRGgEAAAAAAMDC63sa4fJC6eNW/hAq42jo6uvr3pe6eE0CAAAAwA+40ggAAAAAAAAWhEYAAAAAAACwIDQCAAAIEpmZmUpISFBUVJSSkpK0Y8eOy7YvLCzU5MmT1bp1a9ntdl133XXauHGjn6oFAADBjnsaAQAABIHXX39daWlpWrJkiZKSkrR48WINHDhQBw8eVExMjKV9aWmpBgwYoJiYGL311ltq27at8vLy1KxZM/8XDwAAghKhEQAAQBBYtGiRJk6cqLFjx0qSlixZog0bNmj58uWaMWOGpf3y5ct18uRJbdu2TY0aNZIkJSQk+LNkAAAQ5Ph4GgAAQD1XWlqq3NxcpaSkuNeFhYUpJSVFOTk5lfZZv369kpOTNXnyZMXGxuqGG27Q008/rbKysiqPU1JSIpfL5fEAAAANF6ERAABAPXfixAmVlZUpNjbWY31sbKycTmelfQ4fPqy33npLZWVl2rhxo2bPnq0//vGPeuqpp6o8TkZGhqKjo92P+Pj4Wh0HAAAILoRGAAAAIai8vFwxMTF65ZVX1KtXLw0fPlyPP/64lixZUmWfmTNnqqioyP04duyYHysGAAD1Dfc0AgAAqOdatmyp8PBwFRQUeKwvKChQXFxcpX1at26tRo0aKTw83L2uS5cucjqdKi0tVWRkpKWP3W6X3W6v3eIBAEDQ4kojAACAei4yMlK9evVSdna2e115ebmys7OVnJxcaZ+bbrpJhw4dUnl5uXvdv/71L7Vu3brSwAgAAKAiQiMAAIAgkJaWpqVLl+rPf/6zDhw4oP/6r/9ScXGx+9vUUlNTNXPmTHf7//qv/9LJkyc1depU/etf/9KGDRv09NNPa/LkyYEaAgAACDJ8PA0AACAIDB8+XN98843mzJkjp9OpxMREZWVluW+OnZ+fr7CwH/8/MD4+Xn/96181bdo0de/eXW3bttXUqVM1ffr0QA0BAAAEGZsxxgS6CH9wuVyKjo5WUVGRHA5H3R0nylZn+w5Fi0r8c5w0L2/P4Etd3h7D1+Og5nyZEwB1w3G25v/c8Nd7NqrHXAAAEBzq6j2bj6cBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsIgIdAHwj0Ulga6gcnOV7nWfIvtcr/v4Y/z19Rw3ZL7MSZq99usIFH+8JkPpfAEAAADwxJVGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGAREegCQs2ikkBXULk0u/d9/DGWIvtcr/v4o676er5Q96JL0r3u48vr2B98eR0DAAAAwEVcaQQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFhHeNE5ISFBeXp5l/UMPPaTMzEzL+pUrV2rs2LEe6+x2u86ePeteXrt2rZYsWaLc3FydPHlSu3fvVmJiokefs2fP6re//a3WrFmjkpISDRw4UC+++KJiY2O9Kd8v0uze91lUUvfH8eUY/lBf6/IXX14v3gqlc1xfX/feHscf8x5K/PEzEgAAAICVV1ca7dy5U8ePH3c/Nm3aJEm65557quzjcDg8+lQMnYqLi3XzzTfrD3/4Q5X7mDZtmv73f/9Xb775pt5//339+9//1n/+5396UzoAAAAAAAC84NWVRq1atfJYnj9/vjp06KD+/ftX2cdmsykuLq7K7aNHj5YkHT16tNLtRUVFWrZsmVavXq1f/vKXkqQVK1aoS5cu+sc//qG+fft6MwQAAAAAAADUgM/3NCotLdWqVas0btw42Wy2KtudOXNG7dq1U3x8vIYOHar9+/d7dZzc3FydO3dOKSkp7nXXX3+9rr32WuXk5FTZr6SkRC6Xy+MBAAAAAACAmvE5NFq3bp0KCwt1//33V9mmc+fOWr58ud555x2tWrVK5eXl6tevn7788ssaH8fpdCoyMlLNmjXzWB8bGyun01llv4yMDEVHR7sf8fHxNT4mAAAAAABAQ+dzaLRs2TINGjRIbdq0qbJNcnKyUlNTlZiYqP79+2vt2rVq1aqVXn75ZV8PW2MzZ85UUVGR+3Hs2LE6PyYAAAAAAECo8OqeRhfl5eVp8+bNWrt2rVf9GjVqpJ49e+rQoUM17hMXF6fS0lIVFhZ6XG1UUFBw2Xsl2e122e18fQ4AAAAAAIAvfLrSaMWKFYqJidHgwYO96ldWVqa9e/eqdevWNe7Tq1cvNWrUSNnZ2e51Bw8eVH5+vpKTk706PgAAAAAAAGrG6yuNysvLtWLFCo0ZM0YREZ7dU1NT1bZtW2VkZEiS5s2bp759+6pjx44qLCzUggULlJeXpwkTJrj7nDx5Uvn5+fr3v/8t6YdASPrhCqO4uDhFR0dr/PjxSktLU4sWLeRwOPTwww8rOTmZb04DAAAAAACoI16HRps3b1Z+fr7GjRtn2Zafn6+wsB8vXjp16pQmTpwop9Op5s2bq1evXtq2bZu6du3qbrN+/XqNHTvWvTxixAhJUnp6up544glJ0rPPPquwsDDdfffdKikp0cCBA/Xiiy96WzoAAAAAAABqyOvQ6I477pAxptJtW7du9Vh+9tln9eyzz152f/fff/9lv4FNkqKiopSZmanMzExvSgUAAAAAAICPfP72NAAAAAAAAIQuQiMAAAAAAABYeP3xNFzeohLv+8xVuvd9vDxOuuZ6fQx4J80e6AqCiz/Oly/H8Pbvlq/HQc1xfgEAAIDA4EojAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABYRgS4g1MxVutd90jW3DioJjDS7d+0XldRNHVfKl7q8Hbu/1Ne66qsie+j8ffRWKL3uAQAAAFw5rjQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAIuIQBcQatI11+s+c5Xul+P4w6KSQFdQO9Lsga4AuHL++Pvoj2Pw9xEAAAAIDK40AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAABAkMjMzlZCQoKioKCUlJWnHjh016rdmzRrZbDYNGzasbgsEAAAhJSLQBYSaNLsPfTS39gupYFFJnR/Cb3w5x2iY6uvr3l+vYW+PU1/Ply918XMCoej1119XWlqalixZoqSkJC1evFgDBw7UwYMHFRMTU2W/o0eP6ne/+51uueUWP1YLAABCAVcaAQAABIFFixZp4sSJGjt2rLp27aolS5aoSZMmWr58eZV9ysrKNGrUKM2dO1c//elP/VgtAAAIBYRGAAAA9Vxpaalyc3OVkpLiXhcWFqaUlBTl5ORU2W/evHmKiYnR+PHja3SckpISuVwujwcAAGi4CI0AAADquRMnTqisrEyxsbEe62NjY+V0Oivt8+GHH2rZsmVaunRpjY+TkZGh6Oho9yM+Pv6K6gYAAMGN0AgAACDEnD59WqNHj9bSpUvVsmXLGvebOXOmioqK3I9jx47VYZUAAKC+40bYAAAA9VzLli0VHh6ugoICj/UFBQWKi4uztP/iiy909OhRDRkyxL2uvLxckhQREaGDBw+qQ4cOln52u112O3eSBwAAP+BKIwAAgHouMjJSvXr1UnZ2tntdeXm5srOzlZycbGl//fXXa+/evdqzZ4/78atf/Uq33Xab9uzZw8fOAABAjXClEQAAQBBIS0vTmDFj1Lt3b/Xp00eLFy9WcXGxxo4dK0lKTU1V27ZtlZGRoaioKN1www0e/Zs1ayZJlvUAAABVITQCAAAIAsOHD9c333yjOXPmyOl0KjExUVlZWe6bY+fn5yssjIvIAQBA7SE0AgAACBJTpkzRlClTKt22devWy/ZduXJl7RcEAABCGv8dBQAAAAAAAAtCIwAAAAAAAFh49fG0hIQE5eXlWdY/9NBDyszMtKxfuXKl++aMF9ntdp09e9a9bIxRenq6li5dqsLCQt1000166aWX1KlTp8seNyMjQzNmzPCm/AYtzYdvz11UUvt1VORLXUBD5I+/j6HEl/PFzyMAAADAk1eh0c6dO1VWVuZe3rdvnwYMGKB77rmnyj4Oh0MHDx50L9tsNo/tzzzzjJ577jn9+c9/Vvv27TV79mwNHDhQn376qaKiotzt5s2bp4kTJ7qXmzZt6k3pAAAAAAAA8IJXoVGrVq08lufPn68OHTqof//+Vfax2WyKi4urdJsxRosXL9asWbM0dOhQSdJf/vIXxcbGat26dRoxYoS7bdOmTavcDwAAAAAAAGqXz/c0Ki0t1apVqzRu3DjL1UOXOnPmjNq1a6f4+HgNHTpU+/fvd287cuSInE6nUlJS3Ouio6OVlJSknJwcj/3Mnz9fV199tXr27KkFCxbo/Pnzl62vpKRELpfL4wEAAAAAAICa8epKo0utW7dOhYWFuv/++6ts07lzZy1fvlzdu3dXUVGRFi5cqH79+mn//v265ppr5HQ6JUmxsbEe/WJjY93bJOk3v/mNbrzxRrVo0ULbtm3TzJkzdfz4cS1atKjKY2dkZGju3Lm+Dg8AAAAAAKBB8zk0WrZsmQYNGqQ2bdpU2SY5OVnJycnu5X79+qlLly56+eWX9eSTT9b4WGlpae4/d+/eXZGRkXrggQeUkZEhu73yO5fOnDnTo5/L5VJ8fHyNjwkAAAAAANCQ+fTxtLy8PG3evFkTJkzwql+jRo3Us2dPHTp0SJLc9ygqKCjwaFdQUHDZ+xclJSXp/PnzOnr0aJVt7Ha7HA6HxwMAAAAAAAA141NotGLFCsXExGjw4MFe9SsrK9PevXvVunVrSVL79u0VFxen7OxsdxuXy6Xt27d7XKFU0Z49exQWFqaYmBhfygcAAAAAAEA1vP54Wnl5uVasWKExY8YoIsKze2pqqtq2bauMjAxJ0rx589S3b1917NhRhYWFWrBggfLy8txXKNlsNj3yyCN66qmn1KlTJ7Vv316zZ89WmzZtNGzYMElSTk6Otm/frttuu01NmzZVTk6Opk2bpv/3//6fmjdvfoXDBwAAAAAAQGW8Do02b96s/Px8jRs3zrItPz9fYWE/Xrx06tQpTZw4UU6nU82bN1evXr20bds2de3a1d3mscceU3FxsSZNmqTCwkLdfPPNysrKUlRUlKQfPma2Zs0aPfHEEyopKVH79u01bdo0j/sVAQAAAAAAoHbZjDEm0EX4g8vlUnR0tIqKiur0/kauKFud7dvfFpXU/THSKr+POVAr/PEa9oUvr/v6OpZQws+juuU4W/N/bvjrPRvVYy4AAAgOdfWe7dM9jQAAAAAAABDaCI0AAAAAAABg4fU9jXB53lx+fyX88TE4f3yExl8fueFjJ6EhVD6iFSrjAAAAABDauNIIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwiAl0AfOM4awJdQqXSomxetV9UUkeFBInoknSv2hfZ59ZRJf7X0OceAAAAAOo7rjQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYBER6AIQWhxnjVftn6ibMixcUbY6P8aiEu/7pGtu7RcSJNLs3vfx5RyjYfLl9QUAAADAE1caAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIBFRKALAPzBcdbU+TGe8KWPzVbbZQBuc5XuVft0za2jSq5Mmj3QFQAAAAANE1caAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWgEAAAAAAAAC0IjAAAAAAAAWBAaAQAAAAAAwILQCAAAAAAAABaERgAAAAAAALDwKjRKSEiQzWazPCZPnlxp+5UrV1raRkVFebQxxmjOnDlq3bq1GjdurJSUFH3++ecebU6ePKlRo0bJ4XCoWbNmGj9+vM6cOePlUAEAAAAAAFBTEd403rlzp8rKytzL+/bt04ABA3TPPfdU2cfhcOjgwYPuZZvN5rH9mWee0XPPPac///nPat++vWbPnq2BAwfq008/dQdMo0aN0vHjx7Vp0yadO3dOY8eO1aRJk7R69WpvygfqnSeMCXQJtcIVZau+EfwuXXO9ah8qr0cAAAAAtcOr0KhVq1Yey/Pnz1eHDh3Uv3//KvvYbDbFxcVVus0Yo8WLF2vWrFkaOnSoJOkvf/mLYmNjtW7dOo0YMUIHDhxQVlaWdu7cqd69e0uSnn/+ed11111auHCh2rRp480QAAAAAAAAUAM+39OotLRUq1at0rhx4yxXD13qzJkzateuneLj4zV06FDt37/fve3IkSNyOp1KSUlxr4uOjlZSUpJycnIkSTk5OWrWrJk7MJKklJQUhYWFafv27VUet6SkRC6Xy+MBAAAAAACAmvE5NFq3bp0KCwt1//33V9mmc+fOWr58ud555x2tWrVK5eXl6tevn7788ktJktPplCTFxsZ69IuNjXVvczqdiomJ8dgeERGhFi1auNtUJiMjQ9HR0e5HfHy8L8MEAAAAAABokHwOjZYtW6ZBgwZd9uNhycnJSk1NVWJiovr376+1a9eqVatWevnll309bI3NnDlTRUVF7sexY8fq/JgAAAAAAAChwqt7Gl2Ul5enzZs3a+3atV71a9SokXr27KlDhw5JkvteRwUFBWrdurW7XUFBgRITE91tvv76a4/9nD9/XidPnqzyXkmSZLfbZbfbvaoPAAAAAAAAP/DpSqMVK1YoJiZGgwcP9qpfWVmZ9u7d6w6I2rdvr7i4OGVnZ7vbuFwubd++XcnJyZJ+uFqpsLBQubm57jZbtmxReXm5kpKSfCkfAAAAAAAA1fD6SqPy8nKtWLFCY8aMUUSEZ/fU1FS1bdtWGRkZkqR58+apb9++6tixowoLC7VgwQLl5eVpwoQJkn74ZrVHHnlETz31lDp16qT27dtr9uzZatOmjYYNGyZJ6tKli+68805NnDhRS5Ys0blz5zRlyhSNGDGCb04DAAAAAACoI16HRps3b1Z+fr7GjRtn2Zafn6+wsB8vXjp16pQmTpwop9Op5s2bq1evXtq2bZu6du3qbvPYY4+puLhYkyZNUmFhoW6++WZlZWUpKirK3ebVV1/VlClTdPvttyssLEx33323nnvuOW9LBwAAAAAAQA3ZjDEm0EX4g8vlUnR0tIqKiuRwOAJdDhBSXFE2vxxnUYlfDtNgPdEw3g4QBHjPrj+YCwAAgkNdvWf7/O1pAAAAAAAACF2ERgAAAAAAALDw+p5GAFCR46x/Ptb0hF+OAgAAAACQuNIIAAAAAAAAlSA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAQSIzM1MJCQmKiopSUlKSduzYUWXbpUuX6pZbblHz5s3VvHlzpaSkXLY9AABARYRGAAAAQeD1119XWlqa0tPTtWvXLvXo0UMDBw7U119/XWn7rVu3auTIkXrvvfeUk5Oj+Ph43XHHHfrqq6/8XDkAAAhWNmOMCXQR/uByuRQdHa2ioiI5HI5AlwMAAKrAe3blkpKS9POf/1wvvPCCJKm8vFzx8fF6+OGHNWPGjGr7l5WVqXnz5nrhhReUmppao2MyFwAABIe6es+OqLU91XMXszGXyxXgSgAAwOVcfK9uIP+vVSOlpaXKzc3VzJkz3evCwsKUkpKinJycGu3ju+++07lz59SiRYsq25SUlKikpMS9zL+bAABo2BpMaHT69GlJUnx8fIArAQAANXH69GlFR0cHuox64cSJEyorK1NsbKzH+tjYWH322Wc12sf06dPVpk0bpaSkVNkmIyNDc+fOvaJaAQBA6GgwoVGbNm107NgxNW3aVDabLdDl+I3L5VJ8fLyOHTvWIC8rb8jjZ+yMvaGNXWrY4w+lsRtjdPr0abVp0ybQpYSM+fPna82aNdq6dauioqKqbDdz5kylpaW5ly++rgAAQMPUYEKjsLAwXXPNNYEuI2AcDkfQ/xJxJRry+Bk7Y2+IGvL4Q2XsXGHkqWXLlgoPD1dBQYHH+oKCAsXFxV2278KFCzV//nxt3rxZ3bt3v2xbu90uu91+xfUCAIDQwLenAQAA1HORkZHq1auXsrOz3evKy8uVnZ2t5OTkKvs988wzevLJJ5WVlaXevXv7o1QAABBCGsyVRgAAAMEsLS1NY8aMUe/evdWnTx8tXrxYxcXFGjt2rCQpNTVVbdu2VUZGhiTpD3/4g+bMmaPVq1crISFBTqdTknTVVVfpqquuCtg4AABA8CA0CnF2u13p6ekN9lLzhjx+xs7YG6KGPP6GPPaGYvjw4frmm280Z84cOZ1OJSYmKisry31z7Pz8fIWF/XgR+UsvvaTS0lL9+te/9thPenq6nnjiCX+WDgAAgpTN8H22AAAAqITL5VJ0dLSKiopC4l5ZAACEqrp6z+aeRgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAAAABgQWhUz8yfP182m02PPPKIe90rr7yiX/ziF3I4HLLZbCosLLT0O3nypEaNGiWHw6FmzZpp/PjxOnPmjEebTz75RLfccouioqIUHx+vZ555xrKfN998U9dff72ioqLUrVs3bdy40WO7MUZz5sxR69at1bhxY6WkpOjzzz8P6NgTEhJks9k8HvPnzw/qsZ88eVIPP/ywOnfurMaNG+vaa6/Vb37zGxUVFXn0y8/P1+DBg9WkSRPFxMTo0Ucf1fnz5z3abN26VTfeeKPsdrs6duyolStXWo6fmZmphIQERUVFKSkpSTt27PDYfvbsWU2ePFlXX321rrrqKt19990qKCiolbFfyfgrzrvNZtOaNWuCavyVve4feOABdejQQY0bN1arVq00dOhQffbZZx79QmHufR17qM77RcYYDRo0SDabTevWrfPYFgrzDgAAgCBiUG/s2LHDJCQkmO7du5upU6e61z/77LMmIyPDZGRkGEnm1KlTlr533nmn6dGjh/nHP/5h/v73v5uOHTuakSNHurcXFRWZ2NhYM2rUKLNv3z7z2muvmcaNG5uXX37Z3eajjz4y4eHh5plnnjGffvqpmTVrlmnUqJHZu3evu838+fNNdHS0WbdunfnnP/9pfvWrX5n27dub77//PmBjb9eunZk3b545fvy4+3HmzJmgHvvevXvNf/7nf5r169ebQ4cOmezsbNOpUydz9913u/udP3/e3HDDDSYlJcXs3r3bbNy40bRs2dLMnDnT3ebw4cOmSZMmJi0tzXz66afm+eefN+Hh4SYrK8vdZs2aNSYyMtIsX77c7N+/30ycONE0a9bMFBQUuNs8+OCDJj4+3mRnZ5uPP/7Y9O3b1/Tr1++Kxn2l4zfGGElmxYoVHnN/6XzU9/FX9bp/+eWXzfvvv2+OHDlicnNzzZAhQ0x8fLw5f/68MSY05t7XsRsTuvN+0aJFi8ygQYOMJPP222+714fCvCP4FBUVGUmmqKgo0KUAAIDLqKv3bEKjeuL06dOmU6dOZtOmTaZ///6V/iLx3nvvVRqcfPrpp0aS2blzp3vd//3f/xmbzWa++uorY4wxL774omnevLkpKSlxt5k+fbrp3Lmze/nee+81gwcP9th3UlKSeeCBB4wxxpSXl5u4uDizYMEC9/bCwkJjt9vNa6+9FpCxG/NDaPTss89Wuf9gH/tFb7zxhomMjDTnzp0zxhizceNGExYWZpxOp7vNSy+9ZBwOh3usjz32mPnZz37msZ/hw4ebgQMHupf79OljJk+e7F4uKyszbdq0MRkZGe5xNmrUyLz55pvuNgcOHDCSTE5Ojs9jN+bKxm+MsfxSXVF9Hr83Y//nP/9pJJlDhw4ZY4J/7q9k7MaE9rzv3r3btG3b1hw/ftwyzmCfdwQnQiMAAIJDXb1n8/G0emLy5MkaPHiwUlJSvO6bk5OjZs2aqXfv3u51KSkpCgsL0/bt291tbr31VkVGRrrbDBw4UAcPHtSpU6fcbSoef+DAgcrJyZEkHTlyRE6n06NNdHS0kpKS3G18cSVjv2j+/Pm6+uqr1bNnTy1YsMDj4xqhMvaioiI5HA5FRES4a+7WrZtiY2M9ana5XNq/f3+NxlVaWqrc3FyPNmFhYUpJSXG3yc3N1blz5zzaXH/99br22muvaOzSlY3/0n20bNlSffr00fLly2WMcW+rz+Ov6diLi4u1YsUKtW/fXvHx8e5xBfPcX8nYL91HqM37d999p/vuu0+ZmZmKi4uzbA/2eQcAAEDwiai+CeramjVrtGvXLu3cudOn/k6nUzExMR7rIiIi1KJFCzmdTneb9u3be7S5+IuH0+lU8+bN5XQ6PX4Zudjm0n1c2q+yNt660rFL0m9+8xvdeOONatGihbZt26aZM2fq+PHjWrRokbvuYB/7iRMn9OSTT2rSpEnudVXVfGm9VbVxuVz6/vvvderUKZWVlVXa5uJ9ZJxOpyIjI9WsWTNLG1/HLl35+CVp3rx5+uUvf6kmTZrob3/7mx566CGdOXNGv/nNb9y118fx12TsL774oh577DEVFxerc+fO2rRpkzv4DOa5v9KxS6E779OmTVO/fv00dOjQSrcH87wDAAAgOBEaBdixY8c0depUbdq0SVFRUYEux69qa+xpaWnuP3fv3l2RkZF64IEHlJGRIbvdXhul1jpvxu5yuTR48GB17dpVTzzxhH8KrGO1Nf7Zs2e7/9yzZ08VFxdrwYIF7vCgPqrp2EeNGqUBAwbo+PHjWrhwoe6991599NFHQf1zorbGHorzvn79em3ZskW7d+8OQHUAAABA5fh4WoDl5ubq66+/1o033qiIiAhFRETo/fff13PPPaeIiAiVlZVVu4+4uDh9/fXXHuvOnz+vkydPuj/iEBcXZ/nmm4vL1bW5dPul/Spr443aGHtlkpKSdP78eR09etRdd7CO/fTp07rzzjvVtGlTvf3222rUqJF7H1cyLofDocaNG6tly5YKDw+vduylpaWWb67zdey1Nf7KJCUl6csvv1RJSUm9HX9Nxx4dHa1OnTrp1ltv1VtvvaXPPvtMb7/99mXHdXFbKI+9MqEw75s2bdIXX3yhZs2aubdL0t13361f/OIXlx3XxW31dewAAAAIXoRGAXb77bdr79692rNnj/vRu3dvjRo1Snv27FF4eHi1+0hOTlZhYaFyc3Pd67Zs2aLy8nIlJSW523zwwQc6d+6cu82mTZvUuXNnNW/e3N0mOzvbY9+bNm1ScnKyJKl9+/aKi4vzaONyubR9+3Z3G3+PvTJ79uxRWFiY+yN7wTp2l8ulO+64Q5GRkVq/fr3l6oTk5GTt3bvXIzDctGmTHA6HunbtWqNxRUZGqlevXh5tysvLlZ2d7W7Tq1cvNWrUyKPNwYMHlZ+f79PYa2v8ldmzZ4+aN2/uvsKsPo7fl9e9+eFLC9yhSLDOfW2MvTKhMO+PP/64PvnkE4/tkvTss89qxYoV7nEF47wDAAAgiNXqbbVRKyp+o87x48fN7t27zdKlS40k88EHH5jdu3ebb7/91t3mzjvvND179jTbt283H374oenUqZMZOXKke3thYaGJjY01o0ePNvv27TNr1qwxTZo0sXztfEREhFm4cKE5cOCASU9Pr/Rr55s1a2beeecd88knn5ihQ4fWytfO+zr2bdu2mWeffdbs2bPHfPHFF2bVqlWmVatWJjU1NajHXlRUZJKSkky3bt3MoUOHPL5avOLXrt9xxx1mz549Jisry7Rq1arSr99+9NFHzYEDB0xmZmalX79tt9vNypUrzaeffmomTZpkmjVr5vENTQ8++KC59tprzZYtW8zHH39skpOTTXJycq2M29fxr1+/3ixdutTs3bvXfP755+bFF180TZo0MXPmzAm68V869i+++MI8/fTT5uOPPzZ5eXnmo48+MkOGDDEtWrRwfyV6KM29t2MP1XmvjCp8e1oozTuCB9+eBgBAcKir92xCo3qo4i8S6enpRpLlsWLFCnebb7/91owcOdJcddVVxuFwmLFjx5rTp0977Pef//ynufnmm43dbjdt27Y18+fPtxz7jTfeMNddd52JjIw0P/vZz8yGDRs8tpeXl5vZs2eb2NhYY7fbze23324OHjwYsLHn5uaapKQkEx0dbaKiokyXLl3M008/bc6ePRvUY3/vvfcqHbckc+TIEXefo0ePmkGDBpnGjRubli1bmt/+9rceX0l/cV+JiYkmMjLS/PSnP/V43Vz0/PPPm2uvvdZERkaaPn36mH/84x8e27///nvz0EMPmebNm5smTZqY//iP/zDHjx+vtbH7Mv7/+7//M4mJieaqq64yP/nJT0yPHj3MkiVLTFlZWdCN/9Kxf/XVV2bQoEEmJibGNGrUyFxzzTXmvvvuM5999plHn1CZe2/HHqrzXpmKoZExoTPvCB6ERgAABIe6es+2GXPJ9xQDAAAAF7hcLkVHR6uoqEgOhyPQ5QAAgCrU1Xs29zQCAAAAAACABaERAAAAAAAALCICXYA/nT17VqWlpYEuAwAAVCMyMrJG35oIAACAutNgQqOzZ8+qceNWks4EuhQAAFCNuLg4HTlyhOAIAAAggBpMaPTDFUZnJE2T9JMLaxtdeI6o4vly2xvVoE1tba+uz8XlaoRXc8iwy2wLr2K9L9ur2taokraXqzu8Bttruo/q6r7cubvSc+Nud+Ge9BFlHs+28PM/LEaUKfzCuvCI8gvP5y88X1gfduFZlT9HXHgOs2y/cAyVu9eHW9qe99hH+CVtf2hXcXv1NVTXxvsaqm5XcaxVHfvHfVbXznrOalpn9ees+hqqnduyC8/nLxyjzFxYlsez7YdD6cKhrM9lFx4V13mzfPG5qmOV1fK+qluu6b4q7sOb2mpzX9XUdu5C3wtTbVk+X+bZ5VwVu6pq/aXbL7etpvuoyTFKJD3rdKq0tJTQCAAAIIAaTGj0I7uki/8ArSp8qclyVaFRXSzXtE8VbDV8DtOPd7mq6rliiFLxubrgpLIMrLow60q213Qf1QY6NTiGL309ni8fGtkalcl2cZ37+YdtYReWw8I8g4OwCuGENSyqOkipOiSpLkSp+fbaP8bF5/DLHCushvuwXWgX5tHvx2dbhf3Y3Ot+/Otgq7BPVXg2F9pVXH/x+WKtxqN9uMwlfy6vcKwLz2UXns9fqLOq0KiqsOJyIUtN+ni7vjb3Vdn68Eu2VzzRF/tU9XOv4j5tFbZX/Fl6sX1lbBWWK35/qalifVW1GenchWDpwlTrnK3C8oWm1QU8NVmurm11+4ioZnv4JX8GAABA4HEjbAAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwIDQCAAAAAACABaERAAAAAAAALAiNAAAAAAAAYEFoBAAAAAAAAAtCIwAAAAAAAFgQGgEAAAAAAMCC0AgAAAAAAAAWhEYAAAAAAACwiAh0Af5Xoh+HXXbh+eLy+WqWz12y3OjCnxtVaFPxuTa2V9fn4nIVTA2fyy88VMmz7cJzWYXli8+qYrliDVUd91IVjx1eRfuyCtsrrj+vH09ReIVtFddXdfrDKzxXNl013UdV293tLgwwoszj2YT/8Do0EWUyF9dFlF94/mFb+YX1trALz6r8udx9Aio+n7/Q7tKTeOFY7ufzHn3MhbbGve/zFZYrf764vUxlCr/w54rP5RWWw9zL5919f1guv2y7iEvahVfYVtWxf9xnde0uHuPHGi53/Mr2cbF9RJU1VP3845/NhX2YC/v84Tm87MLz+QvbL0z1hZeT+9l2ccrPV/H840tBFV4CNV+++FzVscpqeV/VLdd0XxX34U1tNd1Xdc9V/Uy+5PnchR8dF6baslyxhHPybv2l2y+3rab7qMkxSgQAAID6oMGERpGRkYqLi5PT+WygSwmcir+MIChczMrO6cdfuAAg1MXFxSkyMjLQZQAAADRoDSY0ioqK0pEjR1RaWhroUmqNy+VSfHy8jh07JofDEehyQgrntm5wXusG57XucG7rRk3Oa2RkpKKiovxcGQAAAC7VYEIj6YfgKBT/AepwOPhlpo5wbusG57VucF7rDue2bnBeAQAA6jduhA0AAAAAAAALQiMAAAAAAABYEBoFMbvdrvT0dNnt9kCXEnI4t3WD81o3OK91h3NbNzivAAAAwcFmjDHVNwMAAEBD43K5FB0draKiIu4/BQBAPVZX79lcaQQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRG9dgHH3ygIUOGqE2bNrLZbFq3bl21fbZu3aobb7xRdrtdHTt21MqVK+u8zmDj7Xldu3atBgwYoFatWsnhcCg5OVl//etf/VNskPHlNXvRRx99pIiICCUmJtZZfcHKl/NaUlKixx9/XO3atZPdbldCQoKWL19e98UGEV/O66uvvqoePXqoSZMmat26tcaNG6dvv/227osNIhkZGfr5z3+upk2bKiYmRsOGDdPBgwer7ffmm2/q+uuvV1RUlLp166aNGzf6oVoAAABcDqFRPVZcXKwePXooMzOzRu2PHDmiwYMH67bbbtOePXv0yCOPaMKECQQcFXh7Xj/44AMNGDBAGzduVG5urm677TYNGTJEu3fvruNKg4+35/aiwsJCpaam6vbbb6+jyoKbL+f13nvvVXZ2tpYtW6aDBw/qtddeU+fOneuwyuDj7Xn96KOPlJqaqvHjx2v//v168803tWPHDk2cOLGOKw0u77//viZPnqx//OMf2rRpk86dO6c77rhDxcXFVfbZtm2bRo4cqfHjx2v37t0aNmyYhg0bpn379vmxcgAAAFRkM8aYQBeB6tlsNr399tsaNmxYlW2mT5+uDRs2ePwje8SIESosLFRWVpYfqgw+NTmvlfnZz36m4cOHa86cOXVTWAjw5tyOGDFCnTp1Unh4uNatW6c9e/bUeX3BqibnNSsrSyNGjNDhw4fVokUL/xUXxGpyXhcuXKiXXnpJX3zxhXvd888/rz/84Q/68ssv/VBlcPrmm28UExOj999/X7feemulbYYPH67i4mK9++677nV9+/ZVYmKilixZ4q9SUYm6+vpeAABQu+rqPZsrjUJITk6OUlJSPNYNHDhQOTk5AaooNJWXl+v06dP8Ml5LVqxYocOHDys9PT3QpYSM9evXq3fv3nrmmWfUtm1bXXfddfrd736n77//PtClBbXk5GQdO3ZMGzdulDFGBQUFeuutt3TXXXcFurR6raioSJIu+zOT9y8AAID6KSLQBaD2OJ1OxcbGeqyLjY2Vy+XS999/r8aNGweostCycOFCnTlzRvfee2+gSwl6n3/+uWbMmKG///3viojgx1FtOXz4sD788ENFRUXp7bff1okTJ/TQQw/p22+/1YoVKwJdXtC66aab9Oqrr2r48OE6e/aszp8/ryFDhnj9ccyGpLy8XI888ohuuukm3XDDDVW2q+r9y+l01nWJAAAAuAyuNAK8sHr1as2dO1dvvPGGYmJiAl1OUCsrK9N9992nuXPn6rrrrgt0OSGlvLxcNptNr776qvr06aO77rpLixYt0p///GeuNroCn376qaZOnao5c+YoNzdXWVlZOnr0qB588MFAl1ZvTZ48Wfv27dOaNWsCXQoAAAB8wH/th5C4uDgVFBR4rCsoKJDD4eAqo1qwZs0aTZgwQW+++ablYxTw3unTp/Xxxx9r9+7dmjJliqQfwg5jjCIiIvS3v/1Nv/zlLwNcZXBq3bq12rZtq+joaPe6Ll26yBijL7/8Up06dQpgdcErIyNDN910kx599FFJUvfu3fWTn/xEt9xyi5566im1bt06wBXWL1OmTNG7776rDz74QNdcc81l21b1/hUXF1eXJQIAAKAaXGkUQpKTk5Wdne2xbtOmTUpOTg5QRaHjtdde09ixY/Xaa69p8ODBgS4nJDgcDu3du1d79uxxPx588EF17txZe/bsUVJSUqBLDFo33XST/v3vf+vMmTPudf/6178UFhZW7S/vqNp3332nsDDPt83w8HBJEt8p8SNjjKZMmaK3335bW7ZsUfv27avtw/sXAABA/cSVRvXYmTNndOjQIffykSNHtGfPHrVo0ULXXnutZs6cqa+++kp/+ctfJEkPPvigXnjhBT322GMaN26ctmzZojfeeEMbNmwI1BDqJW/P6+rVqzVmzBj96U9/UlJSkvseG40bN/a4kgPenduwsDDLPU5iYmIUFRV12XufNETevmbvu+8+Pfnkkxo7dqzmzp2rEydO6NFHH9W4ceO46vAS3p7XIUOGaOLEiXrppZc0cOBAHT9+XI888oj69OmjNm3aBGoY9c7kyZO1evVqvfPOO2ratKn7Z2Z0dLT79Zeamqq2bdsqIyNDkjR16lT1799ff/zjHzV48GCtWbNGH3/8sV555ZWAjQMAAACSDOqt9957z0iyPMaMGWOMMWbMmDGmf//+lj6JiYkmMjLS/PSnPzUrVqzwe931nbfntX///pdtjx/58pq9VHp6uunRo4dfag0mvpzXAwcOmJSUFNO4cWNzzTXXmLS0NPPdd9/5v/h6zJfz+txzz5muXbuaxo0bm9atW5tRo0aZL7/80v/F12OVnVNJHu9H/fv3t/wMfeONN8x1111nIiMjzc9+9jOzYcMG/xaOShUVFRlJpqioKNClAACAy6ir92ybMVxTDwAAACuXy6Xo6GgVFRXJ4XAEuhwAAFCFunrP5p5GAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAgSGRmZiohIUFRUVFKSkrSjh07Ltv+zTff1PXXX6+oqCh169ZNGzdu9FOlAAAgFBAaAQAABIHXX39daWlpSk9P165du9SjRw8NHDhQX3/9daXtt23bppEjR2r8+PHavXu3hg0bpmHDhmnfvn1+rhwAAAQrmzHGBLoIAAAAXF5SUpJ+/vOf64UXXpAklZeXKz4+Xg8//LBmzJhhaT98+HAVFxfr3Xffda/r27evEhMTtWTJkhod0+VyKTo6WkVFRXI4HLUzEAAAUOvq6j07otb2BAAAgDpRWlqq3NxczZw5070uLCxMKSkpysnJqbRPTk6O0tLSPNYNHDhQ69atq/I4JSUlKikpcS8XFRVJ+uEfogAAoP66+F5d29cFERoBAADUcydOnFBZWZliY2M91sfGxuqzzz6rtI/T6ay0vdPprPI4GRkZmjt3rmV9fHy8D1UDAAB/+/bbbxUdHV1r+yM0AgAAgCRp5syZHlcnFRYWql27dsrPz6/Vf4DCey6XS/Hx8Tp27BgfFQwg5qH+YC7qD+aifigqKtK1116rFi1a1Op+CY0AAADquZYtWyo8PFwFBQUe6wsKChQXF1dpn7i4OK/aS5Ldbpfdbresj46O5heBesLhcDAX9QDzUH8wF/UHc1E/hIXV7ved8e1pAAAA9VxkZKR69eql7Oxs97ry8nJlZ2crOTm50j7Jycke7SVp06ZNVbYHAACoiCuNAAAAgkBaWprGjBmj3r17q0+fPlq8eLGKi4s1duxYSVJqaqratm2rjIwMSdLUqVPVv39//fGPf9TgwYO1Zs0affzxx3rllVcCOQwAABBECI0AAACCwPDhw/XNN99ozpw5cjqdSkxMVFZWlvtm1/n5+R6XpPfr10+rV6/WrFmz9Pvf/16dOnXSunXrdMMNN9T4mHa7Xenp6ZV+ZA3+xVzUD8xD/cFc1B/MRf1QV/NgM7X9fWwAAAAAAAAIetzTCAAAAAAAABaERgAAAAAAALAgNAIAAAAAAIAFoREAAAAAAAAsCI0AAAAasMzMTCUkJCgqKkpJSUnasWPHZdu/+eabuv766xUVFaVu3bpp48aNfqo09HkzF0uXLtUtt9yi5s2bq3nz5kpJSal27lAz3v6duGjNmjWy2WwaNmxY3RbYgHg7F4WFhZo8ebJat24tu92u6667jp9RtcDbeVi8eLE6d+6sxo0bKz4+XtOmTdPZs2f9VG3o+uCDDzRkyBC1adNGNptN69atq7bP1q1bdeONN8put6tjx45auXKl18clNAIAAGigXn/9daWlpSk9PV27du1Sjx49NHDgQH399deVtt+2bZtGjhyp8ePHa/fu3Ro2bJiGDRumffv2+bny0OPtXGzdulUjR47Ue++9p5ycHMXHx+uOO+7QV1995efKQ4u383DR0aNH9bvf/U633HKLnyoNfd7ORWlpqQYMGKCjR4/qrbfe0sGDB7V06VK1bdvWz5WHFm/nYfXq1ZoxY4bS09N14MABLVu2TK+//rp+//vf+7ny0FNcXKwePXooMzOzRu2PHDmiwYMH67bbbtOePXv0yCOPaMKECfrrX//q1XFtxhjjS8EAAAAIbklJSfr5z3+uF154QZJUXl6u+Ph4Pfzww5oxY4al/fDhw1VcXKx3333Xva5v375KTEzUkiVL/FZ3KPJ2LioqKytT8+bN9cILLyg1NbWuyw1ZvsxDWVmZbr31Vo0bN05///vfVVhYWKMrAHB53s7FkiVLtGDBAn322Wdq1KiRv8sNWd7Ow5QpU3TgwAFlZ2e71/32t7/V9u3b9eGHH/qt7lBns9n09ttvX/bKxunTp2vDhg0e/7EzYsQIFRYWKisrq8bH4kojAACABqi0tFS5ublKSUlxrwsLC1NKSopycnIq7ZOTk+PRXpIGDhxYZXvUjC9zUdF3332nc+fOqUWLFnVVZsjzdR7mzZunmJgYjR8/3h9lNgi+zMX69euVnJysyZMnKzY2VjfccIOefvpplZWV+avskOPLPPTr10+5ubnuj7AdPnxYGzdu1F133eWXmvGj2nrPjqjNogAAABAcTpw4obKyMsXGxnqsj42N1WeffVZpH6fTWWl7p9NZZ3U2BL7MRUXTp09XmzZtLL8goOZ8mYcPP/xQy5Yt0549e/xQYcPhy1wcPnxYW7Zs0ahRo7Rx40YdOnRIDz30kM6dO6f09HR/lB1yfJmH++67TydOnNDNN98sY4zOnz+vBx98kI+nBUBV79kul0vff/+9GjduXKP9cKURAAAAEMTmz5+vNWvW6O2331ZUVFSgy2kwTp8+rdGjR2vp0qVq2bJloMtp8MrLyxUTE6NXXnlFvXr10vDhw/X444/z0Vk/27p1q55++mm9+OKL2rVrl9auXasNGzboySefDHRp8BFXGgEAADRALVu2VHh4uAoKCjzWFxQUKC4urtI+cXFxXrVHzfgyFxctXLhQ8+fP1+bNm9W9e/e6LDPkeTsPX3zxhY4ePaohQ4a415WXl0uSIiIidPDgQXXo0KFuiw5RvvydaN26tRo1aqTw8HD3ui5dusjpdKq0tFSRkZF1WnMo8mUeZs+erdGjR2vChAmSpG7duqm4uFiTJk3S448/rrAwrlvxl6resx0OR42vMpK40ggAAKBBioyMVK9evTxuVlpeXq7s7GwlJydX2ic5OdmjvSRt2rSpyvaoGV/mQpKeeeYZPfnkk8rKylLv3r39UWpI83Yerr/+eu3du1d79uxxP371q1+5v6koPj7en+WHFF/+Ttx00006dOiQO7iTpH/9619q3bo1gZGPfJmH7777zhIMXQzy+A4u/6q192wDAACABmnNmjXGbreblStXmk8//dRMmjTJNGvWzDidTmOMMaNHjzYzZsxwt//oo49MRESEWbhwoTlw4IBJT083jRo1Mnv37g3UEEKGt3Mxf/58ExkZad566y1z/Phx9+P06dOBGkJI8HYeKhozZowZOnSon6oNbd7ORX5+vmnatKmZMmWKOXjwoHn33XdNTEyMeeqppwI1hJDg7Tykp6ebpk2bmtdee80cPnzY/O1vfzMdOnQw9957b6CGEDJOnz5tdu/ebXbv3m0kmUWLFpndu3ebvLw8Y4wxM2bMMKNHj3a3P3z4sGnSpIl59NFHzYEDB0xmZqYJDw83WVlZXh2Xj6cBAAA0UMOHD9c333yjOXPmyOl0KjExUVlZWe4bZ+bn53v8j3G/fv20evVqzZo1S7///e/VqVMnrVu3TjfccEOghhAyvJ2Ll156SaWlpfr1r3/tsZ/09HQ98cQT/iw9pHg7D6g73s5FfHy8/vrXv2ratGnq3r272rZtq6lTp2r69OmBGkJI8HYeZs2aJZvNplmzZumrr75Sq1atNGTIEP33f/93oIYQMj7++GPddttt7uW0tDRJ0pgxY7Ry5UodP35c+fn57u3t27fXhg0bNG3aNP3pT3/SNddco//5n//RwIEDvTquzRiuEQMAAAAAAIAnYnIAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsCA0AgAAAAAAgAWhEQAAAAAAACwIjQAAAAAAAGBBaAQAAAAAAAALQiMAAAAAAABYEBoBAAAAAADAgtAIAAAAAAAAFoRGAAAAAAAAsPj/3sL4KBYdFPsAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -1154,6 +1162,30 @@ "plt.colorbar(clrbar, orientation=\"horizontal\", pad = 0.05)\n", "show(posterior_confidence, ax = axs[1, 0], transform = raster_meta[\"transform\"], cmap=colormap_name)" ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "save = True\n", + "\n", + "posterior_raster = \"../tests/data/local/results/posterior_raster_asc_desc.tif\"\n", + "posterior_raster_std = \"../tests/data/local/results/posterior_raster_std_asc_desc.tif\"\n", + "posterior_raster_conf = \"../tests/data/local/results/posterior_raster_confidence_asc_desc.tif\"\n", + "\n", + "raster_meta[\"dtype\"] = np.float32\n", + "\n", + "if save:\n", + " with rasterio.open(posterior_raster, \"w\", **raster_meta) as dest:\n", + " dest.write(posterior_array, 1)\n", + " with rasterio.open(posterior_raster_std, \"w\", **raster_meta) as dest:\n", + " dest.write(posterior_array_std, 1)\n", + " with rasterio.open(posterior_raster_conf, \"w\", **raster_meta) as dest:\n", + " dest.write(posterior_confidence, 1)" + ] } ], "metadata": {