diff --git a/eo-crops/environment.yml b/eo-crops/environment.yml
new file mode 100644
index 0000000..147d290
--- /dev/null
+++ b/eo-crops/environment.yml
@@ -0,0 +1,21 @@
+name: eo-crops
+channels:
+  - conda-forge
+dependencies:
+  - python=3.7
+  - pip
+  - gdal
+  - pip :
+      - eo-learn-coregistration
+      - eo-learn-features
+      - eo-learn-mask
+      - eo-learn-visualization
+      - eo-learn-ml-tools
+      - eo-learn-core
+      - eo-learn-io
+      - eo-learn-geometry
+      - sentinelhub
+      - -r requirements.txt
+
+
+
diff --git a/eo-crops/eocrops/__init__.py b/eo-crops/eocrops/__init__.py
new file mode 100644
index 0000000..b9863c0
--- /dev/null
+++ b/eo-crops/eocrops/__init__.py
@@ -0,0 +1 @@
+name = 'eoflow'
diff --git a/eo-crops/eocrops/input/__init__.py b/eo-crops/eocrops/input/__init__.py
new file mode 100644
index 0000000..b9863c0
--- /dev/null
+++ b/eo-crops/eocrops/input/__init__.py
@@ -0,0 +1 @@
+name = 'eoflow'
diff --git a/eo-crops/eocrops/input/meteoblue.py b/eo-crops/eocrops/input/meteoblue.py
new file mode 100644
index 0000000..ad4eda7
--- /dev/null
+++ b/eo-crops/eocrops/input/meteoblue.py
@@ -0,0 +1,354 @@
+import aiohttp
+import asyncio
+from io import StringIO
+
+import pandas as pd
+import dateutil
+import datetime as dt
+
+import numpy as np
+import datetime
+
+
+class WeatherDownload:
+    def __init__(self, api_key, queryBackbone, ids, coordinates, years, loop =  asyncio.new_event_loop()):
+        '''
+
+        Parameters
+        ----------
+        api_key (str) : API key from meteoblue
+        queryBackbone (dict) : query backbone from meteoblue
+        ids (list) : list of ids from each location request
+        coordinates (list of tuples) : list of each location coordinate
+        years (list) : years of extraction w.r.t the ids
+        '''
+        self.api_key = api_key
+        self.queryBackbone = queryBackbone
+        self.loop = loop
+        self.ids = ids
+        self.coordinates = coordinates
+        self.years = years
+        self.url_query = "http://my.meteoblue.com/dataset/query"
+        self.url_queue = "http://queueresults.meteoblue.com/"
+
+    async def _get_jobIDs_from_query(self, query, time_interval =  ('01-01', '12-31')):
+
+        async def _make_ids(ids, coordinates, dates):
+            for i, (id, coord, date) in enumerate(zip(ids, coordinates, dates)):
+                yield i, id, coord, date
+
+        jobIDs = []
+
+        async for i, id, coord, date in _make_ids(self.ids, self.coordinates, self.years):
+            await asyncio.sleep(0.5) #query spaced by 05 seconds => 2 queries max per queueTime (limit = 5)
+            start_time, end_time = (str(date) + "-" + time_interval[0], str(date) + "-" + time_interval[1])
+
+            self.queryBackbone["geometry"]["geometries"] = \
+                [dict(type='MultiPoint', coordinates=[coord], locationNames=[id])]
+            self.queryBackbone["timeIntervals"] = [start_time + 'T+00:00' + '/' + end_time + 'T+00:00']
+            self.queryBackbone["queries"] = query
+
+            async with aiohttp.ClientSession() as session:
+                # prepare the coroutines that post
+                async with session.post(self.url_query,
+                                        headers={"Content-Type": "application/json", "Accept": "application/json"},
+                                        params={"apikey": self.api_key},
+                                        json=self.queryBackbone
+                                        ) as response:
+                    data = await response.json()
+                    print(data)
+                await session.close()
+            jobIDs.append(data['id'])
+        # now execute them all at once
+        return jobIDs
+
+
+    async def _get_request_from_jobID(self, jobID, sleep = 1, limit = 5):
+
+        await asyncio.sleep(sleep)
+        #limit amount of simultaneously opened connections you can pass limit parameter to connector
+        conn = aiohttp.TCPConnector(limit=limit, ttl_dns_cache=300)
+        session = aiohttp.ClientSession(connector=conn) #ClientSession is the heart and the main entry point for all client API operations.
+        #session contains a cookie storage and connection pool, thus cookies and connections are shared between HTTP requests sent by the same session.
+
+        async with session.get(self.url_queue + jobID) as response:
+            print("Status:", response.status)
+            print("Content-type:", response.headers['content-type'])
+            urlData = await response.text()
+            print(response)
+            await session.close()
+        df = pd.read_csv(StringIO(urlData), sep=",", header=None)
+        df['jobID'] = jobID
+        return df
+
+    @staticmethod
+    async def _gather_with_concurrency(n, *tasks):
+        semaphore = asyncio.Semaphore(n)
+        async def sem_task(task):
+            async with semaphore:
+                return await task
+
+        return await asyncio.gather(*(sem_task(task) for task in tasks))
+
+    def execute(self, query, time_interval = ('01-01', '12-31'), conc_req = 5):
+        try :
+            jobIDs = self.loop.run_until_complete(self._get_jobIDs_from_query(query, time_interval))
+
+            dfs = self.loop.run_until_complete(self._gather_with_concurrency(conc_req,
+                                                                             *[self._get_request_from_jobID(jobID,
+                                                                                                            i/100)
+                                                                              for i, jobID in enumerate(jobIDs)]))
+        finally:
+            print('close')
+            self.loop.close()
+
+        return pd.concat(dfs, axis=0)
+
+#############################################################################################
+
+class WeatherPostprocess:
+    def __init__(self,
+                 input_file,
+                 id_column,
+                 year_column,
+                 resample_range=('-01-01', '-12-31', 1),
+                 planting_date_column = None, havest_date_column = None):
+        '''
+        Format output file from meteoblue API into a pd.DataFrame
+
+        :param input_file (pd.DataFrame) : input file with fields in-situ data
+        :param id_column (str): Name of the column that contains ids of the fields to merge with CEHub data
+        :param planting_date_column (str): Name of the column with planting date in doy format
+        :param havest_date_column (str): Name of the column with harvest date in doy format
+        :param year_column (str) : Name of the column with the yearly season associated to each field
+        :param resample_range (tuple): Query period (interval of date) and number of days to aggregate over period (e.g. 8 days) instead of having daily data
+        '''
+
+        self.id_column = id_column
+        self.planting_date_column = planting_date_column
+        self.havest_date_column = havest_date_column
+        self.year_column = year_column
+        self.resample_range = resample_range
+        self.input_file = input_file[[self.id_column, self.year_column]].drop_duplicates()
+
+        if self.planting_date_column is not None and self.havest_date_column is not None:
+            self.input_file = self.input_file.rename(
+                columns={self.planting_date_column: 'planting_date'})
+            self._apply_convert_doy('planting_date')
+
+
+    def _get_descriptive_period(self, df, stat='mean'):
+        '''
+        Compute descriptive statistics given period
+        '''
+        dict_stats = dict(mean=np.nanmean, max=np.nanmax, min=np.nanmin)
+
+        df['value'] = df['value'].astype('float32')
+        df_agg = df[['variable', 'period', 'location', 'value', self.year_column]]. \
+            groupby(['variable', 'period', 'location', self.year_column]).agg(dict_stats[stat])
+        df_agg.reset_index(inplace=True)
+        df_agg = df_agg.rename(columns={'value': stat + '_value',
+                                        'location': self.id_column})
+        return df_agg
+
+    def _get_cumulated_period(self, df):
+        '''
+        Compute the cumulative sum given period.
+        '''
+
+        df_cum = pd.DataFrame()
+        for var in df.variable.unique():
+            df_subset = df[df.variable == var]
+            df_agg = df_subset[['location', 'period', 'variable', 'value', self.year_column]]. \
+                groupby(['location', self.year_column, 'variable', 'period']).sum()
+            df_agg = df_agg.groupby(level=0).cumsum().reset_index()
+            df_agg = df_agg.rename(columns={'value': 'sum_value'})
+            df_cum = df_cum.append(df_agg)
+
+        return df_cum
+
+    def _get_resampled_periods(self, year = '2021'):
+        '''
+        Get the resampled periods from the resample range
+        '''
+        resample_range_ = (str(year) + self.resample_range[0],
+                           str(year) + self.resample_range[1],
+                           self.resample_range[2])
+
+        start_date = dateutil.parser.parse(resample_range_[0])
+        end_date = dateutil.parser.parse(resample_range_[1])
+        step = dt.timedelta(days=resample_range_[2])
+
+        days = [start_date]
+        while days[-1] + step < end_date:
+            days.append(days[-1] + step)
+        return days
+
+
+    def _format_periods(self, periods):
+        df_resampled = pd.melt(periods, id_vars='period'). \
+            rename(columns={'value': 'timestamp', 'variable': self.year_column})
+
+        # Left join periods to the original dataframe
+        df_resampled['timestamp'] = [str(k) for k in df_resampled['timestamp'].values]
+        df_resampled['timestamp'] = [np.datetime64(str(year) + '-' + '-'.join(k.split('-')[1:]))
+                                     for year, k in zip(df_resampled[self.year_column], df_resampled['timestamp'])]
+        return df_resampled
+
+    def _get_periods(self, df_cehub_):
+        '''
+        Assign the periods to the file obtained through CEHub
+        '''
+
+        def _get_year(x): return x[:4]
+        def _convert_date(x): return dateutil.parser.parse(x[:-5])
+
+        df_cehub = df_cehub_.copy()
+
+        # Assign period ids w.r.t the date from the dataframe
+        df_cehub['timestamp'] = [str(k) for k in df_cehub['timestamp']]
+
+        #Assign dates to a single year to retrieve periods
+        df_cehub[self.year_column] = df_cehub['timestamp'].apply(lambda x: _get_year(x))
+        df_cehub['timestamp'] = df_cehub['timestamp'].apply(lambda x: _convert_date(x))
+
+        dict_year = {}
+        for year in df_cehub[self.year_column].drop_duplicates().values:
+            dict_year[year] = self._get_resampled_periods()
+
+        periods = pd.DataFrame(dict_year)
+
+        periods = periods.reset_index().rename(columns={'index': 'period'})
+        df_resampled = self._format_periods(periods)
+
+        df = pd.merge(df_resampled, df_cehub,
+                      on=['timestamp', self.year_column],
+                      how='right')
+        #Interpolate over new periods
+        fill_nas = df[['period', 'location']].groupby('location').apply(
+            lambda group: group.interpolate(method='pad', limit=self.resample_range[-1]))
+
+        df['period'] = fill_nas['period']
+
+        return df, df[['period', 'timestamp']].drop_duplicates()
+
+
+    def _apply_convert_doy(self, feature):
+        '''
+        Convert dates from CEhub format into day of the year
+        '''
+        def _convert_doy_to_date(doy, year):
+            date = datetime.datetime(int(year), 1, 1) + datetime.timedelta(doy - 1)
+            return np.datetime64(date)
+
+        self.input_file[feature] = [_convert_doy_to_date(doy, year)
+                                    for doy, year in zip(self.input_file[feature],
+                                                         self.input_file[self.year_column])]
+
+    def _add_growing_stage(self, periods_df, feature='planting_date'):
+        '''
+        Retrive the date from weather data associated with a given growing stage (doy format) from the input file
+        The objective is to not take into account observations before sowing date of after harvest date in the statistics
+        '''
+
+        return pd.merge(periods_df,
+                        self.input_file[[feature, self.id_column]].copy(),
+                        left_on='timestamp',
+                        right_on=feature,
+                        how='right'). \
+            rename(columns={'period': 'period_' + feature}).drop(['timestamp'], axis=1)
+
+    def _init_df(self, df):
+        '''
+        Initialize weather dataframe into periods to do the period calculations
+        '''
+        df = df[~df.variable.isin(['variable'])]
+        df = df.drop_duplicates(subset=['location', 'timestamp', 'variable'])
+
+        df = df[df.location.isin(self.input_file[self.id_column].unique())]
+        df, periods_df = self._get_periods(df_cehub_=df)
+        df['value'] = df['value'].astype('float32')
+
+        if self.planting_date_column is not None:
+            periods_sowing = self._add_growing_stage(periods_df, feature='planting_date')
+            df = pd.merge(df[['period', 'timestamp', 'location', 'variable', 'value']],
+                          periods_sowing,
+                          left_on='location',
+                          right_on= self.id_column,
+                          how='left')
+
+            # Observations before planting date are assigned to np.nan
+            df.loc[df.timestamp < df.planting_date, ['value']] = np.nan
+
+        return df
+
+    def _prepare_output_file(self, df_stats, stat='mean'):
+        '''
+        Prepare output dataframe with associated statistics over the periods.
+        The output will have the name of the feature and its corresponding period (tuple)
+        '''
+        df_pivot = pd.pivot_table(df_stats,
+                                  values=[stat + '_value'],
+                                  index=[self.id_column, self.year_column],
+                                  columns=['variable', 'period'], dropna=False)
+
+        df_pivot.reset_index(inplace=True)
+        df_pivot.columns = ['-'.join([str(x) for x in col]).strip() for col in df_pivot.columns.values]
+        df_pivot = df_pivot.rename(
+            columns={
+                self.id_column + '--': self.id_column,
+                self.year_column + '--': self.year_column}
+        )
+        df_pivot = df_pivot.sort_values(by=[self.id_column, self.year_column]).reset_index(drop=True)
+        return df_pivot
+
+
+    def _get_temperature_difference(self, min_weather, max_weather):
+        '''
+        Compute difference between minimum and maximum temperature observed for each period
+        '''
+        diff_weather = min_weather.copy()
+
+        tempMax = max_weather.loc[
+            max_weather.variable.isin(['Temperature']),
+            ['period', 'timestamp', self.id_column, 'value']].rename(
+            columns={'value': 'value_max'})
+
+        diff_weather = pd.merge(diff_weather,
+                                tempMax,
+                                on=['period', 'timestamp', self.id_column],
+                                how='left')
+
+        diff_weather['value'] = diff_weather['value_max'] - diff_weather['value']
+        diff_weather['variable'] = 'Temperature difference'
+
+        return diff_weather
+
+
+    def execute(self, df_weather, stat='mean', return_pivot = False):
+        '''
+        Execute the workflow to get the dataframe aggregated into periods from CEHub data
+        :param df_weather (pd.DataFrame) : cehub dataframe with stat as daily descriptive statistics
+        :return:
+            pd.DataFrame with mean, min, max, sum aggregated into periods defined w.r.t the resample_range
+        '''
+
+        if stat not in ['mean', 'min', 'max', 'sum', 'cumsum']:
+            raise ValueError("Descriptive statistic must be 'mean', 'min', 'max', 'sum' or 'cumsum'")
+
+        init_weather = self._init_df(df=df_weather.copy())
+
+        if stat != 'cumsum':
+            df_stats = self._get_descriptive_period(df = init_weather, stat = stat)
+        else:
+            df_stats = self._get_cumulated_period(df = init_weather)
+
+        df_stats = df_stats.sort_values(by=[self.id_column, self.year_column, "variable"])
+
+        if return_pivot:
+            output = self._prepare_output_file(df_stats=df_stats, stat=stat)
+            output.columns = [''.join(k.split('value-')) for k in output.columns]
+            output.columns = [tuple(k.split('-')) if k != self.id_column else k for k in output.columns]
+            output.columns = [(k[0], float(k[1])) if k != self.id_column else k for k in output.columns]
+
+        return output
diff --git a/eo-crops/eocrops/input/sentinel1.py b/eo-crops/eocrops/input/sentinel1.py
new file mode 100644
index 0000000..f1896a1
--- /dev/null
+++ b/eo-crops/eocrops/input/sentinel1.py
@@ -0,0 +1,110 @@
+import eolearn
+from sentinelhub import  DataCollection
+from eolearn.io import SentinelHubInputTask, SentinelHubDemTask
+import datetime
+from eolearn.core import OverwritePermission
+import eocrops.tasks.preprocessing as preprocessing
+import eocrops.utils.utils as utils
+import os
+
+import multiprocessing
+
+import eocrops.input.utils_sh as utils_sh
+
+from eolearn.core import linearly_connect_tasks, SaveTask, EOWorkflow, FeatureType, OutputTask
+
+
+
+
+def workflow_instructions_S1IW(config, time_stamp,
+                               path_out=None,
+                               polygon=None,
+                               backCoeff='GAMMA0_TERRAIN',
+                               orbit_direction = 'ASC',
+                               speckle_lee_window = 3,
+                               n_threads=multiprocessing.cpu_count()-1):
+    ''' Define the request of image from sentinelhb API by defining the bbox of the field, the time period and the output desired (evalscript)
+    Sentinel-1 IW GRD product, available from 2014 with <12 days revisit and 20 meters resolution, resampled at 10 meters
+    Inputs :
+        - coverage_predicate (float) : upper bound of fraction of pixels contaminated by clouds. Images with higher cloud percentage will be removed
+        - time_stamp (Tuple of two elements) : first and last date to download the picture (e.g ('2017-01-01', '2017-12-31') for a 2017
+        - path_out (string) : Path to save the EOPatch locally OR your AWS path if the values from s3Bucket are not None
+        - config (sentinelhub.SHConfig) : configuration object for sentinelhub API
+        - polygon (geopandas.GeoDataFrame) : input shapefile read as GeoDataFrame with one or multiple observations, each representing one field ID
+        - interpolation (dictionary) : interpolate missing pixels (clouds) and recalibrate time series into fixed time stamp (e.g 16 days)
+        - n_threads (int) : number of threads to download satellite images
+        - backCoeff (str) : Backscatter coefficient during calibration process ('GAMMA0_TERRAIN', 'BETA0', 'SIGMA0_ELLIPSOID' or 'GAMMA0_ELLIPSOID')
+    '''
+
+    if backCoeff not in ['GAMMA0_TERRAIN', 'BETA0', 'SIGMA0_ELLIPSOID', 'GAMMA0_ELLIPSOID'] :
+        raise ValueError(
+            "Backscatter coefficient can only be 'GAMMA0_TERRAIN', 'BETA0', 'SIGMA0_ELLIPSOID' or 'GAMMA0_ELLIPSOID'")
+    if orbit_direction not in ['ASC', 'DES', 'BOTH'] :
+        raise ValueError(
+            "orbit  can only be 'ASC', 'DES' or 'BOTH")
+
+    # Request format to download Sentinel-1 IW GRD products
+    time_difference = datetime.timedelta(hours=2)
+
+    if orbit_direction == 'ASC':
+        data_collection = DataCollection.SENTINEL1_IW_ASC
+    elif orbit_direction == 'DESC':
+        data_collection = DataCollection.SENTINEL1_IW_DES
+    else:
+        data_collection = DataCollection.SENTINEL1_IW
+
+
+    input_task = SentinelHubInputTask(
+        data_collection=data_collection,
+        bands=['VV', 'VH'],
+        bands_feature=(FeatureType.DATA, 'BANDS-S1-IW'),
+        additional_data=[(FeatureType.MASK, 'dataMask', 'IS_DATA'),
+                         (FeatureType.DATA, 'localIncidenceAngle')],
+        resolution=10,
+        time_difference=time_difference,
+        config=config,
+        max_threads=n_threads,
+        aux_request_args={'dataFilter' : {'acquisitionMode' : 'IW'},
+                          'processing' : {'backCoeff' : backCoeff,
+                                          "speckleFilter" : {
+                                              "type" : "LEE",
+                                              "windowSizeX" : speckle_lee_window,
+                                              "windowSizeY" : speckle_lee_window
+                                          },
+                                          'orthorectify' : True,
+                                          'demInstance' : 'COPERNICUS',
+                                          'mosaicking' : 'ORBIT'}
+                          },
+    )
+
+
+    add_polygon_mask = preprocessing.PolygonMask(polygon)
+
+    add_dem = SentinelHubDemTask('DEM', resolution=10, config=config)
+
+    if path_out is None:
+        save = utils_sh.EmptyTask()
+    else:
+        os.makedirs(path_out, exist_ok=True)
+        save = SaveTask(path_out, overwrite_permission=OverwritePermission.OVERWRITE_PATCH)
+
+    output_task = OutputTask("eopatch")
+
+    workflow_nodes = linearly_connect_tasks(input_task,
+                                            add_dem,
+                                            add_polygon_mask,
+                                            save, output_task)
+    workflow = EOWorkflow(workflow_nodes)
+
+    field_bbox = utils.get_bounding_box(polygon)
+    result = workflow.execute(
+        {
+            workflow_nodes[0]: {
+                "bbox": field_bbox,
+                "time_interval": time_stamp
+            }
+        }
+    )
+
+    return result.outputs["eopatch"]
+
diff --git a/eo-crops/eocrops/input/sentinel2.py b/eo-crops/eocrops/input/sentinel2.py
new file mode 100644
index 0000000..e62a269
--- /dev/null
+++ b/eo-crops/eocrops/input/sentinel2.py
@@ -0,0 +1,157 @@
+import eolearn.core
+import eolearn.io
+import eolearn.mask
+import eolearn.features
+import eolearn
+
+from sentinelhub import DataCollection
+from eolearn.io import SentinelHubDemTask, SentinelHubEvalscriptTask
+import datetime
+
+from eolearn.core import OverwritePermission
+
+import eocrops.tasks.preprocessing as preprocessing
+import os
+from eocrops.utils import utils as utils
+import multiprocessing
+
+import eocrops.tasks.vegetation_indices as vegetation_indices
+import eocrops.input.utils_sh as utils_sh
+
+from eolearn.core import SaveTask, linearly_connect_tasks, EOWorkflow, FeatureType, OutputTask
+
+
+def workflow_instructions_S2L2A(config,
+                                time_stamp,
+                                coverage_predicate,
+                                path_out=None,
+                                polygon=None,
+                                interpolation=None,
+                                n_threads=multiprocessing.cpu_count() - 1):
+    ''' Define the request of image from sentinelhb API by defining the bbox of the field, the time period and the output desired (evalscript)
+    Sentinel-2 L2a product, available from 2017 with 5 days revisit and 10 meters resolution
+    Inputs :
+        - coverage_predicate (float) : upper bound of fraction of pixels contaminated by clouds. Images with higher cloud percentage will be removed
+        - time_stamp (Tuple of two elements) : first and last date to download the picture (e.g ('2017-01-01', '2017-12-31') for a 2017
+        - path_out (string) : Path to save the EOPatch locally OR your AWS path if the values from s3Bucket are not None
+        - config (sentinelhub.SHConfig) : configuration object for sentinelhub API
+        - polygon (geopandas.GeoDataFrame) : input shapefile read as GeoDataFrame with one or multiple observations, each representing one field ID
+        - interpolation (dictionary) : interpolate missing pixels (clouds) if True and recalibrate time series into fixed time stamp (e.g 16 days if 'period_length' = 16)
+        - n_threads (int) : number of threads to download satellite images
+    '''
+
+    if interpolation is None:
+        interpolation = {'interpolate': False, 'period_length': None}
+
+    # Request format to download Landsat8 L2A products
+    time_difference = datetime.timedelta(hours=2)
+
+    # Request format to download L8 products
+    evalscript = """
+        function setup() {
+            return {
+                input: [{
+                    bands: ['B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B11', 'B12',
+                    'viewZenithMean','sunZenithAngles','viewAzimuthMean', 'sunAzimuthAngles', 'CLM', "dataMask"],
+                    units: ["REFLECTANCE",  "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE", "REFLECTANCE",  "REFLECTANCE", "REFLECTANCE",
+                    "DEGREES", "DEGREES","DEGREES","DEGREES","DN","DN"]
+                }],
+                output: [
+                    { id:"BANDS", bands:10, sampleType: SampleType.FLOAT32 },
+                    { id:"ILLUMINATION", bands:4, sampleType: SampleType.FLOAT32 },
+                    { id:"CLM", bands:1, sampleType: SampleType.UINT8 },
+                    { id:"IS_DATA", bands:1, sampleType: SampleType.UINT8 }
+                ]
+            }
+        }
+        function evaluatePixel(sample) {
+            return {
+            BANDS: [sample.B02, sample.B03, sample.B04, sample.B05, sample.B06, sample.B07, sample.B08,sample.B8A, 
+            sample.B11, sample.B12], 
+            ILLUMINATION : [sample.viewZenithMean,sample.sunZenithAngles,sample.viewAzimuthMean, sample.sunAzimuthAngles],
+            CLM : [sample.CLM],
+            IS_DATA :  [sample.dataMask]
+
+            };
+        }
+    """
+
+    input_task =\
+        SentinelHubEvalscriptTask(
+            features=[(FeatureType.DATA, 'BANDS', 'BANDS-S2-L2A'),
+                      (FeatureType.DATA, 'ILLUMINATION', 'ILLUMINATION'),
+                      (FeatureType.MASK, 'IS_DATA'),
+                      (FeatureType.MASK, 'CLM')],
+            data_collection=DataCollection.SENTINEL2_L2A,
+            evalscript=evalscript,
+            resolution=10,
+            maxcc=coverage_predicate,
+            time_difference=time_difference,
+            config=config,
+            max_threads=n_threads
+        )
+
+
+    add_dem = SentinelHubDemTask('DEM', resolution=10, config=config)
+    add_polygon_mask = preprocessing.PolygonMask(polygon)
+    cloud_mask = utils_sh.ValidDataS2()
+
+    add_coverage = utils_sh.AddValidDataCoverage()
+
+    add_valid_mask = utils_sh.AddValidDataMaskTask(predicate=utils_sh.calculate_valid_data_mask)
+
+
+    remove_cloudy_scenes = eolearn.features.SimpleFilterTask((eolearn.core.FeatureType.MASK, 'VALID_DATA'), utils_sh.ValidDataCoveragePredicate(coverage_predicate))
+
+
+    vis = vegetation_indices.VegetationIndicesS2('BANDS-S2-L2A',
+                                                 mask_data=bool(1 - interpolation['interpolate']))
+
+
+    norm = vegetation_indices.EuclideanNorm('ECNorm', 'BANDS-S2-L2A')
+
+    if not interpolation['interpolate']:
+        linear_interp = utils_sh.EmptyTask()
+
+    else:
+        if 'period_length' not in interpolation.keys():
+            resampled_range = None
+        elif interpolation['period_length'] is not None:
+            resampled_range = (time_stamp[0], time_stamp[1], interpolation['period_length'])
+
+        copy_features = [(FeatureType.MASK, 'CLM'),
+                         (FeatureType.DATA_TIMELESS, 'DEM'),
+                         (FeatureType.MASK_TIMELESS, 'MASK')]
+
+        linear_interp = preprocessing.InterpolateFeatures(resampled_range=resampled_range,
+                                                          copy_features=copy_features)
+
+
+    if path_out is None:
+        save = utils_sh.EmptyTask()
+
+    else:
+        os.makedirs(path_out, exist_ok=True)
+        save = SaveTask(path_out,
+                        overwrite_permission=OverwritePermission.OVERWRITE_PATCH)
+
+    output_task = OutputTask("eopatch")
+    workflow_nodes = linearly_connect_tasks(input_task,
+                                            cloud_mask, add_valid_mask,
+                                            add_coverage, remove_cloudy_scenes,
+                                            add_dem, add_polygon_mask,
+                                            vis, norm, linear_interp,
+                                            save, output_task)
+    workflow = EOWorkflow(workflow_nodes)
+    
+    field_bbox = utils.get_bounding_box(polygon)
+    result = workflow.execute(
+        {
+            workflow_nodes[0]: {
+                "bbox": field_bbox, 
+                "time_interval": time_stamp
+            }
+        }
+    )
+
+    return result.outputs["eopatch"]
diff --git a/eo-crops/eocrops/input/utils_sh.py b/eo-crops/eocrops/input/utils_sh.py
new file mode 100644
index 0000000..87e7c0c
--- /dev/null
+++ b/eo-crops/eocrops/input/utils_sh.py
@@ -0,0 +1,130 @@
+import eolearn
+from eolearn.core import EOTask, FeatureType
+from sentinelhub import SHConfig
+import numpy as np
+from eolearn.core import AddFeatureTask, RemoveFeatureTask
+
+def config_sentinelhub_cred(api, client_id, client_secret):
+    """
+    Configure properly Sentinelhub credential fetching information from the configuration tool python class.
+    :return:
+    SHConfig
+    """
+
+    config = SHConfig()
+
+    if client_id and client_secret and api:
+        config.instance_id = api
+        config.sh_client_id = client_id
+        config.sh_client_secret = client_secret
+
+    return config
+
+
+def calculate_valid_data_mask(eopatch) :
+    ''' Define which pixel will be masked from eo-patch
+    Inputs :
+        - eopatch : patch downloaded from eo-learn packages (eopatch object with arrays)
+    '''
+    return np.logical_and(eopatch.mask['IS_DATA'].astype(np.bool),
+                          np.logical_not(eopatch.mask['CLM'].astype(np.bool)))
+
+
+def calculate_coverage(array) :
+    ''' Share of pixels not contaminated by clouds
+    Inputs :
+        - array : array from an eopatch object that contains information about cloud coverage (e.g Sentinel-2 L1C)
+    '''
+    return 1.0-np.count_nonzero(array)/np.size(array)
+
+
+class AddValidDataCoverage(EOTask) :
+    ''' Share of pixels not contaminated by clouds
+    Inputs :
+        - EOTask : workflow as EOTask object
+    '''
+
+    def execute(self, eopatch) :
+        valid_data = eopatch[eolearn.core.FeatureType.MASK]['VALID_DATA']
+        time, height, width, channels = valid_data.shape
+
+        coverage = np.apply_along_axis(calculate_coverage, 1, valid_data.reshape((time, height*width*channels)))
+        add_coverage = AddFeatureTask((eolearn.core.FeatureType.SCALAR, 'COVERAGE'))
+        return add_coverage.execute(eopatch=eopatch, data=coverage[:, np.newaxis])
+
+
+class AddValidDataMaskTask(EOTask):
+    def execute(self, eopatch):
+        eopatch.mask["VALID_DATA"] = eopatch.mask["IS_DATA"].astype(bool) & ~(eopatch.mask["CLM"].astype(bool))
+        return eopatch
+
+
+class ValidDataS2(EOTask) :
+    """
+    The tasks recognize clouds from Sentinel Scene Layers (SCL) obtained from Sen2Corr
+    """
+    def execute(self, eopatch) :
+        add_cloud = AddFeatureTask((eolearn.core.FeatureType.MASK, 'VALID_DATA'))
+        return add_cloud.execute(eopatch=eopatch, data=(eopatch.mask['IS_DATA']).astype(bool))
+
+class ValidDataVHRS(EOTask) :
+    """
+    The tasks recognize clouds from Sentinel Scene Layers (SCL) obtained from Sen2Corr
+    """
+
+    def execute(self, eopatch) :
+        cloud_mask_ = np.invert(eopatch[FeatureType.MASK]['CLM'].astype(bool))
+
+        add_bool = AddFeatureTask((eolearn.core.FeatureType.MASK, 'IS_DATA'))
+        add_bool.execute(eopatch=eopatch, data=np.invert(cloud_mask_))
+        add_cloud = AddFeatureTask((eolearn.core.FeatureType.MASK, 'CLM'))
+        add_cloud.execute(eopatch=eopatch, data=cloud_mask_)
+        add_valid = AddFeatureTask((eolearn.core.FeatureType.MASK, 'VALID_DATA'))
+        add_valid.execute(eopatch=eopatch, data=np.invert(cloud_mask_))
+        return eopatch
+
+class ValidPixel :
+    def __call__(self, eopatch) :
+        return np.logical_and(eopatch.mask['IS_DATA'].astype(np.bool),
+                              np.logical_not(eopatch.mask['CLM'].astype(np.bool)))
+
+class CountValid(EOTask) :
+    """
+    The task counts number of valid observations in time-series and stores the results in the timeless mask.
+    """
+
+    def __init__(self, count_what, feature_name) :
+        self.what = count_what
+        self.name = feature_name
+
+    def execute(self, eopatch) :
+        add_count = AddFeatureTask((eolearn.core.FeatureType.MASK_TIMELESS, self.name))
+        add_count.execute(eopatch=eopatch, data=np.count_nonzero(eopatch.mask[self.what], axis=0))
+        return eopatch
+
+
+class ValidDataCoveragePredicate :
+    '''
+    Keep an image only if below % of non contaminated pixels
+    Inputs :
+        - threshold (float) : upper bound of percentage of pixel predicted as cloudy
+    '''
+
+    def __init__(self, threshold) :
+        self.threshold = threshold
+
+    def __call__(self, array) :
+        return calculate_coverage(array)<self.threshold
+
+
+class EmptyTask(EOTask) :
+    '''
+    This task does not make any change. It is just to avoid to duplicate the LinearWorflow with if/else
+    For example, saving a EOPatch in the workflow would depend if the user specify a path in the parameters of the function workflow
+    '''
+
+    def __init__(self) :
+        self.Nothing = 'Nothing'
+
+    def execute(self, eopatch) :
+        return eopatch
\ No newline at end of file
diff --git a/eo-crops/eocrops/input/vhrs.py b/eo-crops/eocrops/input/vhrs.py
new file mode 100644
index 0000000..df4a35c
--- /dev/null
+++ b/eo-crops/eocrops/input/vhrs.py
@@ -0,0 +1,493 @@
+
+from oauthlib.oauth2 import BackendApplicationClient
+from requests_oauthlib import OAuth2Session
+
+from datetime import datetime
+import json
+
+import time
+
+
+from sentinelhub import (
+    DataCollection,
+)
+
+import eocrops.tasks.vegetation_indices as vegetation_indices
+
+from eolearn.io import  SentinelHubEvalscriptTask
+
+import datetime as dt
+import geopandas as gpd
+import eolearn
+import os
+
+import eocrops.utils.utils as utils
+import eocrops.tasks.preprocessing as preprocessing
+import eocrops.tasks.cmd_otb as cmd_otb
+import eocrops.input.utils_sh as utils_sh
+from eolearn.core import SaveTask, FeatureType, OverwritePermission, linearly_connect_tasks, EOWorkflow, OutputTask
+
+
+class DownloadVHRSSentinelHub:
+    '''
+    Initialize query parameters and ingest data into SH
+    Parameters
+    ----------
+    shapefile (GeoDataFrame) : shapefile of your field to extract data
+    time_stamp (tuple) : time period to extract data
+    provider (tuple) : choice between ('AIRBUS', 'PHR'), ('AIRBUS', 'SPOT'),('PLANET', 'PSScene4Band')
+    maxCloudCoverage : maximum cloud cover that may be present in one image
+
+    -------
+    '''
+
+    def __init__(self, shapefile, time_stamp, config, maxCloudCoverage,
+                 url="https://services.sentinel-hub.com/api/v1/dataimport/") :
+        self.shapefile = shapefile
+        self.time_stamp = time_stamp
+        self.config = config
+        self.maxCloudCoverage = maxCloudCoverage
+        self.url = url
+        self.request = False
+        self.order = False
+
+    def get_quotas(self) :
+        '''Get quota from you SH account'''
+        client = BackendApplicationClient(client_id=self.config.sh_client_id)
+        oauth = OAuth2Session(client=client)
+        response = oauth.get(url=self.url+"quotas")
+        response.raise_for_status()
+
+        return response.json()
+
+    def _create_token(self) :
+        '''
+        Create a token for the HTTP API from Sentinelhub third party data import
+        Parameters
+        ----------
+        url (str) : default url for 3rd party data collection
+
+        Returns oauth and the fetch token
+        -------
+
+        '''
+        client = BackendApplicationClient(client_id=self.config.sh_client_id)
+        oauth = OAuth2Session(client=client)
+
+        # Get token for the session
+        token = oauth.fetch_token(token_url='https://services.sentinel-hub.com/oauth/token',
+                                  client_secret=self.config.sh_client_secret)
+
+        # All requests using this session will have an access token automatically added
+        resp = oauth.get("https://services.sentinel-hub.com/oauth/tokeninfo")
+        print(resp.content)
+
+        return oauth, token
+
+    def _get_input_polygon(self) :
+        '''
+        Format the input polygon for the HTTP API request into json format
+        Parameters
+        ----------
+
+        Returns JSON format of the polygon of the field with its corresponding UTM CRS
+        -------
+
+        '''
+        shapefile_boundary = utils.check_crs(self.shapefile.copy())
+        field_bbox = utils.get_bounding_box(shapefile_boundary)
+        input_polygon_json = gpd.GeoSeries([field_bbox.geometry]).to_json()
+        res = json.loads(input_polygon_json)
+        input_polygon = res['features'][0]['geometry']['coordinates']
+        return input_polygon, field_bbox, str(field_bbox.crs).split(':')[-1]
+
+    def _init_param_query(self,
+                          provider=('AIRBUS', 'PHR')) :
+        '''
+        Initialize query parameters
+        Parameters
+        ----------
+        provider (tuple) : choice between ('AIRBUS', 'PHR'), ('AIRBUS', 'SPOT'),('PLANET', 'PSScene4Band')
+        Returns dictionary with your query parameters
+        -------
+
+        '''
+
+        global dict_query
+
+        input_polygon, field_bbox, CRS = self._get_input_polygon()
+        if provider not in [('AIRBUS', 'PHR'), ('AIRBUS', 'SPOT'), ('PLANET', 'PSScene4Band')] :
+            raise ValueError('Available providers are only "PLANET" and "AIRBUS"')
+
+        if provider[0]=='PLANET' :
+            dict_query = dict(provider=provider[0],
+                              axCloudCoverage=self.maxCloudCoverage,
+                              data=[{'itemType' : provider[-1],
+                                     "productBundle" : "analytic_sr_udm2",
+                                     'dataFilter' : {'timeRange' : {'from' : '', 'to' : ''},
+                                                     'self.maxCloudCoverage' : self.maxCloudCoverage,
+                                                     'nativeFilter' : {'type' : 'StringInFilter',
+                                                                       'field_name' : 'quality_category',
+                                                                       'config' : ['standard']}}}])
+
+        elif provider[0]=='AIRBUS' :
+            dict_query = dict(provider=provider[0],
+                              data=[{
+                                  "constellation" : provider[1],
+                                  "dataFilter" : {"timeRange" : {"from" : "",
+                                                                 "to" : ""}}}],
+                              CRS=CRS)
+
+        dict_query['input_polygon'] = input_polygon
+        dict_query['field_bbox'] = field_bbox
+        dict_query['CRS'] = CRS
+
+        try :
+            date_object = datetime.strptime(self.time_stamp[0], "%Y-%m-%d")
+        except :
+            raise ValueError('You must provide a date into yyyy-mm-dd string format')
+
+        dict_query['data'][0]['dataFilter']['timeRange']['from'] = self.time_stamp[0]+"T00:00:00.000Z"
+        dict_query['data'][0]['dataFilter']['timeRange']['to'] = self.time_stamp[1]+"T00:00:00.000Z"
+
+        return dict_query
+
+    def _search_query(self, dict_query, oauth) :
+        '''
+        Search satellite images available with respect to your input query
+        Parameters
+        ----------
+        dict_query (dictionary) : dictionary with the parameters to search the query
+        oauth : oauth client
+        Returns JSON with the results and the list of item ids available
+        -------
+        '''
+        # Last error : need to specify as well product bundle in the search query
+        query = {
+            "provider" : dict_query['provider'],
+            "bounds" : {
+                "properties" : {
+                    "crs" : "http://www.opengis.net/def/crs/EPSG/0/"+dict_query['CRS']
+                },
+                "geometry" : {
+                    "type" : "Polygon",
+                    "coordinates" : dict_query['input_polygon']
+                }
+            },
+            "data" : dict_query['data']
+        }
+
+        response = oauth.post(self.url+"search", json=query)
+        response.raise_for_status()
+
+        results = response.json()
+        # get product ids
+        if dict_query['provider']=='PLANET' :
+            item_ids = [feature["id"] for feature in results["features"]]
+        elif dict_query['provider']=='AIRBUS' :
+            item_ids = [feature["properties"]["id"] for feature in results["features"]]
+        else :
+            raise ValueError('Provider must be set to Planet or Airbus')
+
+        return results, item_ids
+
+    @staticmethod
+    def _payload_data(item_ids, provider=('PLANET', 'PSScene4Band')) :
+        '''
+        Define the payload for your HTTP API
+        Parameters
+        ----------
+        provider (tuple) : choice between ('AIRBUS', 'PHR'), ('AIRBUS', 'SPOT'),('PLANET', 'PSScene4Band')
+        item_id (list) : list of the item ids
+
+        Returns
+        -------
+
+        '''
+
+        output = {}
+
+        if provider[0]=='AIRBUS' :
+
+            output["data"] = [{"constellation" : provider[1],
+                               "products" : [{"id" : item_id} for item_id in item_ids]}]
+
+        elif provider[0]=='PLANET' :
+
+            output['data'] = [{"itemType" : provider[1],
+                               "harmonizeTo" : "NONE",
+                               "productBundle" : "analytic_sr_udm2",
+                               "itemIds" : item_ids}]
+        return output['data']
+
+    def _order_query(self, dict_query,
+                     provider, oauth, item_ids, name_query='') :
+        '''
+        Order the query
+        Parameters
+        ----------
+        dict_query (dictionary) : dictionary from init_param_query() that allows to set all the parameters for your order
+        provider (tuple) : choice between ('AIRBUS', 'PHR'), ('AIRBUS', 'SPOT'),('PLANET', 'PSScene4Band')
+        oauth : oauth client
+        item_ids (list) : list of the item ids returned by SH
+        name_query (str) : name that you can specify to retrieve easily on init_param_query
+        Returns
+        -------
+
+        '''
+        # Order product
+        payload = {
+            "name" : dict_query["provider"].lower()+" products "+name_query,  # ,
+            "input" : {
+                "provider" : dict_query["provider"],
+                "bounds" : {
+                    "properties" : {
+                        "crs" : "http://www.opengis.net/def/crs/EPSG/0/"+dict_query['CRS']
+                    },
+                    "geometry" : {
+                        "type" : "Polygon",
+                        "coordinates" : dict_query['input_polygon']
+                    }
+                },
+                "data" : self._payload_data(item_ids, provider)
+            }
+        }
+        if dict_query["provider"]=='PLANET' :
+            payload["input"]["planetApiKey"] = self.config.planet_key
+
+        response = oauth.post(self.url+"orders", json=payload)  #
+        response.raise_for_status()
+
+        order = response.json()
+
+        # Confirm the order
+        print(order['id'])
+        print(order['sqkm'])
+        print(order['status'])
+
+        return order
+
+    def execute_query(self, provider, name_query=''):
+        '''
+        Execute workflow to get commercial data
+        Parameters
+        ----------
+        provider (tuple) : choice between ('AIRBUS', 'PHR'), ('AIRBUS', 'SPOT'),('PLANET', 'PSScene4Band')
+        name_query (str) : name that you can specify to retrieve easily on init_param_query
+
+        Returns order and collection id to download the data, accessible as well in https://apps.sentinel-hub.com/dashboard/#/tpdi
+        -------
+
+        '''
+        if self.request:
+            raise ValueError('You already have a search request running. Please confirm with confirm_order() method, or call the method reset_order() to launch a new order')
+        self.oauth, _ = self._create_token()
+        dict_query = self._init_param_query(provider)
+        results, item_ids = self._search_query(dict_query, self.oauth)
+        order = self._order_query(dict_query, provider, self.oauth, item_ids, name_query)
+        self.request = True
+        return order['id'], results
+
+    def confirm_order(self, order_id):
+        '''
+        Confirm the order after the having ordered the query
+        Parameters
+        ----------
+        order_id (str) : id of the order
+        Returns collection_id for SH
+        -------
+        '''
+        if self.order:
+            raise ValueError(
+                'You already have an order confirmed. Please wait a little for the order to be ingested in SH and/or reset the workflow to make a new order using reset_order() method')
+        self.order = True
+        # Confirm the order
+        response = self.oauth.post(self.url+f'orders/{order_id}/confirm')
+        response.raise_for_status()
+        jobStatus = response.json()['status']
+        if jobStatus=="RUNNING" :
+            time.sleep(5)  # pause
+            jobStatus = response.json()['status']
+            print(jobStatus)
+
+        ###########################################################
+        response = self.oauth.get(self.url+f"orders/{order_id}")
+        response.raise_for_status()
+        order = response.json()
+
+        if jobStatus=="RUNNING" :
+            time.sleep(2)  # pause to let query ingested
+
+        self.running = True
+
+        return order_id, order['collectionId']
+
+    def check_status(self, order_id) :
+        oauth, _ = self._create_token()
+        return oauth.get(self.url+f"orders/{order_id}").json()['status']
+
+    def reset_workflow(self):
+        ''' Reset workflow to make any new order'''
+        self.request = False
+        self.order = False
+
+    def _workflow_vhrs(self, byoc, provider, resolution, bands_name='BANDS', pansharpen=False, otb_path = None, saving_path = None) :
+        '''
+        Workflow to process third party commercial data
+        Parameters
+        ----------
+        eopatch
+        shapefile
+        resample_days
+
+        Returns EOPatch
+        -------
+        '''
+        evalscript_byoc = get_evalscript(provider)
+        input_task = SentinelHubEvalscriptTask(
+            features=[(FeatureType.DATA, 'BANDS'),
+                      (FeatureType.MASK, 'IS_DATA'),
+                      (FeatureType.MASK, 'CLM')],
+            data_collection=byoc,
+            resolution=resolution,
+            config=self.config,
+            time_difference=dt.timedelta(hours=12),
+            evalscript=evalscript_byoc,
+        )
+
+        cloud_mask = utils_sh.ValidDataVHRS()
+        add_polygon_mask = preprocessing.PolygonMask(self.shapefile)
+        pixels_masking = preprocessing.MaskPixels([bands_name])
+
+        if pansharpen :
+            if otb_path is None :
+                raise ValueError('You must provide path to the bin directory of OrfeoToolBox'
+                                 ' https://www.orfeo-toolbox.org/CookBook/Installation.html')
+            pansharpen = cmd_otb.PanSharpening(fname=bands_name,
+                                               otb_path=otb_path)
+            bands_name += '-PAN'
+        else :
+            pansharpen = utils_sh.EmptyTask()
+
+        vis = vegetation_indices.VegetationIndicesVHRS(bands_name)
+
+        if saving_path is None :
+            save = utils_sh.EmptyTask()
+        else :
+            os.makedirs(saving_path, exist_ok=True)
+            save = SaveTask(saving_path, overwrite_permission=OverwritePermission.OVERWRITE_PATCH)
+
+        output_task = OutputTask("eopatch")
+
+        workflow_nodes = linearly_connect_tasks(input_task,
+                                                cloud_mask,
+                                                add_polygon_mask,
+                                                pixels_masking,
+                                                pansharpen,
+                                                vis, save, output_task)
+        workflow = EOWorkflow(workflow_nodes)
+
+        field_bbox = utils.get_bounding_box(self.shapefile)
+
+        result = workflow.execute(
+            {
+                workflow_nodes[0]: {
+                    "bbox": field_bbox,
+                    "time_interval": self.time_stamp
+                }
+            }
+        )
+
+        return result.outputs["eopatch"]
+
+
+    def get_data(self, order_id, collection_id, provider, resolution, pansharpen = False, otb_path = None) :
+        '''
+        Download the data from Sentinelhub using eo-learn package
+        Parameters
+        ----------
+        order_id (str) : order id from the 3rd party import https://apps.sentinel-hub.com/dashboard/#/tpdi
+        collection_id (str) : collection id
+        pansharpen (bool) : perform pansharpenning using OTB
+        otb_path (str) : path where you have your OTB bin installed
+        Returns EOPatch
+        -------
+
+        '''
+        ##########################################
+        # Define the byoc
+        byoc = DataCollection.define_byoc(
+            collection_id=collection_id,
+            name=str(order_id),
+        )
+        eopatch = self._workflow_vhrs(byoc,
+                                      provider,
+                                      resolution,
+                                      bands_name='BANDS',
+                                      pansharpen=pansharpen,
+                                      otb_path = otb_path)
+        return eopatch
+
+
+
+
+def get_evalscript(provider):
+    '''
+    Get evaluation script to download the data
+    Parameters
+    ----------
+    provider (tuple) : choice between ('AIRBUS', 'PHR'), ('AIRBUS', 'SPOT'),('PLANET', 'PSScene4Band')
+     w.r.t the execution order
+
+    Returns    evaluation script
+    -------
+    '''
+    global evalscript_byoc
+    if provider[0]=='PLANET' :
+        evalscript_byoc = """
+        function setup() {
+            return {
+              input: ["B1", "B2", "B3", "B4", "UDM2_Cloud","dataMask"],
+              output: [
+                  {id: "BANDS", bands: 4, sampleType: SampleType.FLOAT32},
+                  {id:"IS_DATA", bands:1, sampleType: SampleType.UINT8 },
+                  {id:"CLM", bands:1, sampleType: SampleType.UINT8 }
+              ],
+            }
+          }
+
+          function evaluatePixel(sample) {
+            return {
+                BANDS: [2.5 * sample.B1 / 10000, 2.5 * sample.B2 / 10000, 2.5 * sample.B3 / 10000, 2.5 * sample.B4 / 10000],
+                CLM : [sample.UDM2_Cloud],
+                IS_DATA :  [sample.dataMask]
+            }
+          }
+        """
+
+    elif provider[0]=='AIRBUS' :
+
+        evalscript_byoc = """
+        function setup() {
+            return {
+              input:  ["B0", "B1", "B2", "B3","PAN", "dataMask", "dataMask"],
+              output: [
+                  {id: "BANDS", bands: 5, sampleType: SampleType.FLOAT32},
+                  {id:"IS_DATA", bands:1, sampleType: SampleType.UINT8},
+                  {id:"CLM", bands:1, sampleType: SampleType.UINT8}
+
+              ],
+            }
+          }
+
+          function evaluatePixel(sample) {
+          v = 4000
+            return {
+                BANDS: [sample.B0/v, sample.B1/v, sample.B2/v, sample.B3/v,sample.PAN/v],
+                IS_DATA :  [sample.dataMask],
+                CLM :  [sample.dataMask]
+            }
+          }
+        """
+
+    return evalscript_byoc
\ No newline at end of file
diff --git a/eo-crops/eocrops/tasks/__init__.py b/eo-crops/eocrops/tasks/__init__.py
new file mode 100644
index 0000000..b9863c0
--- /dev/null
+++ b/eo-crops/eocrops/tasks/__init__.py
@@ -0,0 +1 @@
+name = 'eoflow'
diff --git a/eo-crops/eocrops/tasks/cmd_otb.py b/eo-crops/eocrops/tasks/cmd_otb.py
new file mode 100644
index 0000000..425c105
--- /dev/null
+++ b/eo-crops/eocrops/tasks/cmd_otb.py
@@ -0,0 +1,211 @@
+import numpy as np
+
+from eolearn.core import FeatureType, EOTask, AddFeatureTask
+from pathlib import Path
+from osgeo import gdal
+import os
+import shutil
+
+import subprocess
+import rasterio
+
+from eolearn.io import ExportToTiffTask, ImportFromTiffTask
+
+
+
+class MultitempSpeckleFiltering(EOTask):
+
+    def __init__(self,  otb_path, feature_name = "BANDS-S1-IW", path_in = './', window = 3):
+        '''
+        Multitemporal filtering ONLY for Sentinel-1 data using OTB
+        Parameters:
+            otb_path (str) : Path where bin from Orfeo Toolbox package is installed
+            path_in (str) : Path to write the temporary files (removed at the end of the process)
+            window (int) : window to apply for Quegan filter for SAR data
+        '''
+        self.feature_name = feature_name
+        self.otb_path = otb_path
+        self.path_in = path_in
+        self.window = window
+
+    @staticmethod
+    def _refactor_dates(t):
+        # Add dates as suffix
+        year, d, m = str(t.year), str(t.day), str(t.month)
+        if len(d)==1 :
+            d = '0'+d
+        if len(m)==1 :
+            m = '0'+m
+        return '{0}{1}{2}'.format(year, m, d)
+
+    def _apply_OTB_cmd(self, pol, ram = 8):
+        path_in = os.path.join(self.path_in, 'S1_'+pol)
+        s1_images = os.listdir(path_in)
+        infiles = [os.path.join(path_in, k) for k in s1_images]
+        infiles.sort()
+        cmd = [os.path.join(self.otb_path, "otbcli_MultitempFilteringOutcore"), "-inl"]
+        cmd += infiles
+        cmd += ['-wr', str(self.window), '-oc', os.path.join(path_in, 'outcore.tif'), '-ram', str(8)]
+        outdir = Path(path_in+'_filtered')
+
+        if not outdir.exists() :
+            os.mkdir(outdir)
+        subprocess.call(cmd, shell=False)
+
+        cmd = [os.path.join(self.otb_path, "otbcli_MultitempFilteringFilter"), "-inl"]
+        cmd += infiles
+
+        cmd += ['-enl', os.path.join(outdir, 'enl.tif'),
+                '-wr', str(self.window),
+                '-filtpath', outdir,
+                '-oc', os.path.join(path_in, 'outcore.tif'),
+                '-ram', str(ram)]
+
+        subprocess.call(cmd, shell=False)
+
+        outfiles = [os.path.join(outdir, k.split('.')[0]+'_filtered.tif') for k in s1_images]
+        outfiles.sort()
+        return infiles, outdir, outfiles
+
+    def _save_temporary_geotiff(self, i, date, eopatch):
+        ## TODO : Find a way to write temporary file without writing on disk using ExportToTiffTask to make the process faster
+        export = ExportToTiffTask(feature= (FeatureType.DATA, self.feature_name),
+                                  folder=os.path.join(self.path_in, 'S1_VV/S1_VV_' + date),
+                                  band_indices=[0],
+                                  date_indices=[i])
+        export.execute(eopatch)
+
+        export = ExportToTiffTask(feature= (FeatureType.DATA, self.feature_name),
+                                  folder=os.path.join(self.path_in, 'S1_VH/S1_VH_' + date),
+                                  band_indices=[1],
+                                  date_indices=[i])
+        export.execute(eopatch)
+
+
+    def execute(self, eopatch, ram = 8):
+
+        if os.path.exists(os.path.join(self.path_in, 'S1_VV')):
+            shutil.rmtree(os.path.join(self.path_in, 'S1_VV'))
+            shutil.rmtree(os.path.join(self.path_in, 'S1_VH'))
+
+        os.mkdir(os.path.join(self.path_in, 'S1_VV'))
+        os.mkdir(os.path.join(self.path_in, 'S1_VH'))
+
+        times = list(eopatch.timestamp)
+        for i, t in enumerate(times):
+            date = self._refactor_dates(t)
+            self._save_temporary_geotiff(i, date, eopatch)
+
+        ########################################################################################################
+        for pol in ['VV', 'VH']:
+
+            infiles, outdir, outfiles = self._apply_OTB_cmd(pol,ram)
+            ##########################################################################
+            reference_file = infiles[0]
+            with rasterio.open(reference_file) as src0:
+                meta = src0.meta
+                meta['nodata'] = 0.0
+                meta['dtype'] = 'float32'
+
+            meta['count'] = len(times)
+            year = str(eopatch.timestamp[0].year)
+            path_tif = outfiles[0].split('_' + year)[0] + '.tif'
+            if 'outcore_filtered.tif' in os.listdir(str(outdir)):
+                outfiles.remove(os.path.join(outdir, 'outcore_filtered.tif'))
+            outfiles.sort()
+
+            with rasterio.open(os.path.join(self.path_in, path_tif), 'w', **meta) as dst:
+                for i in range(1, len(times) + 1):
+                    img = gdal.Open(os.path.join(self.path_in, outfiles[i - 1])).ReadAsArray()
+                    dst.write_band(i, img)
+
+            import_tif = ImportFromTiffTask((FeatureType.DATA, pol + '_filtered'), path_tif)
+            eopatch = import_tif.execute(eopatch)
+
+        shutil.rmtree(os.path.join(self.path_in, 'S1_VV_filtered'))
+        shutil.rmtree(os.path.join(self.path_in, 'S1_VH_filtered'))
+        shutil.rmtree(os.path.join(self.path_in, 'S1_VV'))
+        shutil.rmtree(os.path.join(self.path_in, 'S1_VH'))
+
+        return eopatch
+
+
+
+class PanSharpening(EOTask):
+    def __init__(self, fname = 'BANDS',
+                 otb_path =  '/home/s999379/git-repo/OTB-7.4.0-Linux64/bin',
+                 path_temporary_files = './tempo'):
+        '''
+        Multitemporal filtering ONLY for Sentinel-1 data using OTB
+        Parameters:
+            fname (str) : Name of the feature stored in data that gathers the bands
+            otb_path (str) : Path where bin from Orfeo Toolbox package is installed
+            path_temporary_files (str) : path to save the temporary geotiff file to call OTB
+        '''
+        self.fname = fname
+        self.otb_path = otb_path
+        self.path_temporary_files = path_temporary_files
+
+    @staticmethod
+    def _refactor_dates(t):
+        # Add dates as suffix
+        year, d, m = str(t.year), str(t.day), str(t.month)
+        if len(d)==1 :
+            d = '0'+d
+        if len(m)==1 :
+            m = '0'+m
+        return '{0}{1}{2}'.format(year, m, d)
+
+
+    def _extracted_from__save_temporary_geotiff(self, date, i, eopatch, band_indices=None):
+
+        if band_indices is None :
+            band_indices = list(range(4))
+
+        export = ExportToTiffTask(feature=(FeatureType.DATA, self.fname),
+                                  folder=os.path.join(self.path_temporary_files, 'PAN_' + date),
+                                  band_indices=[-1],
+                                  date_indices=[i])
+        export.execute(eopatch)
+
+        export = ExportToTiffTask(feature=(FeatureType.DATA, self.fname),
+                                  folder=os.path.join(self.path_temporary_files, 'BANDS_' + date),
+                                  band_indices=band_indices,
+                                  date_indices=[i])
+        export.execute(eopatch)
+
+
+    def _apply_OTB_cmd(self, date):
+
+        cm = [os.path.join(self.otb_path, 'otbcli_Pansharpening'),
+              '-inp',os.path.join(self.path_temporary_files,'PAN_' + date +'.tif'),
+              '-inxs', os.path.join(self.path_temporary_files,'BANDS_' + date +'.tif'),
+              '-method', 'lmvm',
+              '-out', os.path.join(self.path_temporary_files, 'Pansharpened_' + date +'.tif'),
+              'float']
+
+        subprocess.call(cm, shell=False)
+
+
+    def _clean_temporary_files(self):
+        shutil.rmtree(self.path_temporary_files)
+
+    def execute(self, eopatch, band_indices=None):
+
+        times = list(eopatch.timestamp)
+
+        pan_bands = []
+        for i, t in enumerate(times):
+            date = self._refactor_dates(t)
+            self._extracted_from__save_temporary_geotiff(date, i, eopatch, band_indices)
+            self._apply_OTB_cmd(date)
+            img = gdal.Open(os.path.join(self.path_temporary_files, 'Pansharpened_' + date +'.tif')).ReadAsArray()
+            img = np.moveaxis(img, 0, -1)
+            pan_bands.append(img)
+
+        pan_bands = np.stack(pan_bands, axis =0)
+        self._clean_temporary_files()
+
+        add_pan = AddFeatureTask((FeatureType.DATA, 'BANDS-PAN'))
+
+        return add_pan.execute(eopatch=eopatch, data=pan_bands)
\ No newline at end of file
diff --git a/eo-crops/eocrops/tasks/preprocessing.py b/eo-crops/eocrops/tasks/preprocessing.py
new file mode 100644
index 0000000..99f23fa
--- /dev/null
+++ b/eo-crops/eocrops/tasks/preprocessing.py
@@ -0,0 +1,301 @@
+from eolearn.geometry import VectorToRasterTask
+from eolearn.core import FeatureType, EOTask
+import sentinelhub
+from eolearn.features.interpolation import LinearInterpolationTask, CubicInterpolationTask
+import copy
+
+import eocrops.utils.utils as utils
+from eolearn.geometry.morphology import ErosionTask
+
+from scipy.optimize import curve_fit
+import numpy as np
+from eolearn.core import RemoveFeatureTask
+
+class PolygonMask(EOTask) :
+    """
+    EOTask that performs rasterization from an input shapefile into :
+    - data_timeless feature 'FIELD_ID' (0 nodata; 1,...,N for each observation of the shapefile ~ object IDs)
+    - mask_timeless feature 'polygon_mask' (0 if pixels outside the polygon(s) from the shapefile, 1 otherwise
+
+    Parameters
+    ----------
+    geodataframe : TYPE GeoDataFrame
+        Input geodataframe read as GeoDataFrame, each observation represents a polygon (e.g. fields)
+    new_feature_name : TYPE string
+        Name of the new features which contains clustering_task predictions
+
+    Returns
+    -------
+    EOPatch
+    """
+
+    def __init__(self, geodataframe) :
+        self.geodataframe = geodataframe
+
+    def execute(self, eopatch):
+
+        # Check CRS and transform into UTM
+        self.geodataframe = utils.check_crs(self.geodataframe)
+
+        # Get an ID for each polygon from the input shapefile
+        self.geodataframe['FIELD_ID'] = list(range(1, self.geodataframe.shape[0] + 1))
+
+        if self.geodataframe.shape[0]>1 :
+            bbox = self.geodataframe.geometry.total_bounds
+            polygon_mask = sentinelhub.BBox(bbox=[(bbox[0], bbox[1]), (bbox[2], bbox[3])], crs=self.geodataframe.crs)
+            self.geodataframe['MASK'] = polygon_mask.geometry
+        else :
+            self.geodataframe['MASK'] = self.geodataframe['geometry']
+
+        self.geodataframe['polygon_bool'] = True
+
+        rasterization_task = VectorToRasterTask(self.geodataframe, (FeatureType.DATA_TIMELESS, "FIELD_ID"),
+                                                values_column="FIELD_ID", raster_shape=(FeatureType.MASK, 'IS_DATA'),
+                                                raster_dtype=np.uint16)
+        eopatch = rasterization_task.execute(eopatch)
+
+        rasterization_task = VectorToRasterTask(self.geodataframe,
+                                                (FeatureType.MASK_TIMELESS, "MASK"),
+                                                values_column="polygon_bool", raster_shape=(FeatureType.MASK, 'IS_DATA'),
+                                                raster_dtype=np.uint16)
+        eopatch = rasterization_task.execute(eopatch)
+
+        eopatch.mask_timeless['MASK'] = eopatch.mask_timeless['MASK'].astype(bool)
+
+        return eopatch
+
+
+class MaskPixels(EOTask):
+    def __init__(self, features, fname = 'MASK') :
+        '''
+        Parameters
+        ----------
+        feature (list): of features in data and/or data_timeless
+        fname (str): name of the mask
+        '''
+        self.features = features
+        self.fname = fname
+
+    @staticmethod
+    def _filter_array(patch, ftype, fname, mask) :
+        ivs = patch[ftype][fname]
+
+        arr0 = np.ma.array(ivs,
+                           dtype=np.float32,
+                           mask=(1-mask).astype(bool),
+                           fill_value=np.nan)
+
+        arr0 = arr0.filled()
+        patch[ftype][fname] = arr0
+
+        return patch
+
+    def execute(self, patch, erosion = 0):
+        copy_patch = copy.deepcopy(patch)
+        times = len(patch.timestamp)
+        if erosion:
+            erode = ErosionTask(mask_feature=(FeatureType.MASK_TIMELESS, self.fname),
+                                disk_radius=erosion)
+            erode.execute(copy_patch)
+
+        crop_mask = copy_patch["mask_timeless"][self.fname]
+        # Filter the pixels of each features
+        for index in self.features :
+            if index in list(patch.data.keys()) :
+                ftype = 'data'
+                shape = patch[ftype][index].shape[-1]
+                mask = crop_mask.reshape(1, crop_mask.shape[0], crop_mask.shape[1], 1)
+                mask = [mask for k in range(times)]
+                mask = np.concatenate(mask, axis=0)
+                mask = [mask for k in range(shape)]
+                mask = np.concatenate(mask, axis=-1)
+            else :
+                ftype = 'data_timeless'
+                mask = crop_mask
+            patch = self._filter_array(patch, ftype, index, mask)
+
+        return patch
+
+
+
+class InterpolateFeatures(EOTask):
+    def __init__(self, resampled_range,
+                 features = None,
+                 algorithm = 'linear',
+                 copy_features = None):
+        self.resampled_range = resampled_range
+        self.features = features
+        self.algorithm = algorithm
+        self.copy_features = copy_features
+
+    def _interpolate_feature(self, eopatch, features, mask_feature):
+
+        kwargs = dict(mask_feature=mask_feature,
+                      resample_range=self.resampled_range,
+                      feature = features,
+                      bounds_error=False)
+
+        if self.resampled_range is not None:
+            kwargs['copy_features'] = self.copy_features
+
+        if self.algorithm=='linear' :
+            interp = LinearInterpolationTask(
+                parallel=True,
+                **kwargs
+            )
+        elif self.algorithm=='cubic' :
+            interp = CubicInterpolationTask(
+                **kwargs
+            )
+        eopatch = interp.execute(eopatch)
+        return eopatch
+
+
+    def execute(self, eopatch):
+
+        '''Gap filling after data extraction, very useful if did not include it in the data extraction workflow'''
+
+
+        mask_feature = None
+        if 'VALID_DATA' in list(eopatch.mask.keys()):
+            mask_feature = (FeatureType.MASK, 'VALID_DATA')
+
+        if self.features is None:
+            self.features = [(FeatureType.DATA, fname) for fname in eopatch.get_features()[FeatureType.DATA]]
+
+        dico = {}
+        for ftype, fname in self.features :
+            new_eopatch = copy.deepcopy(eopatch)
+            new_eopatch = self._interpolate_feature(new_eopatch, (ftype, fname), mask_feature)
+            dico[fname] = new_eopatch[ftype][fname]
+
+        eopatch['data'] = dico
+        t, h, w, _ = dico[fname].shape
+        eopatch.timestamp = new_eopatch.timestamp
+        eopatch['mask']['IS_DATA'] = (np.zeros((t, h, w, 1))+1).astype(int)
+        eopatch['mask']['VALID_DATA'] = (np.zeros((t, h, w, 1))+1).astype(bool)
+        if "CLM" in eopatch.mask.keys():
+            remove_feature = RemoveFeatureTask([(FeatureType.MASK, "CLM")])
+            remove_feature.execute(eopatch)
+
+        return eopatch
+
+
+class CurveFitting(EOTask):
+    def __init__(self, range_doy = None):
+        self.range_doy = range_doy
+        self.params = None
+
+    def get_time_series_profile(self,
+                                eopatch,
+                                feature,
+                                feature_mask = 'polygon_mask',
+                                function=np.nanmedian):
+
+        feature_array = eopatch[FeatureType.DATA][feature]
+        if feature_mask not in eopatch[FeatureType.MASK_TIMELESS].keys():
+            raise ValueError('The feature ' + feature_mask + " is missing in MASK_TIMELESS")
+        crop_mask = eopatch[FeatureType.MASK_TIMELESS][feature_mask]
+        # Transform mask from 3D to 4D
+        times, h, w, shape = feature_array.shape
+        mask = crop_mask.reshape(1, h, w, 1)
+        mask = [mask for k in range(times)]
+        mask = np.concatenate(mask, axis=0)
+        #######################
+        mask = [mask for k in range(shape)]
+        mask = np.concatenate(mask, axis=-1)
+        ########################
+        a = np.ma.array(feature_array, mask=np.invert(mask))
+        ts_mean = np.ma.apply_over_axes(function, a, [1, 2])
+        ts_mean = ts_mean.reshape(ts_mean.shape[0], ts_mean.shape[-1])
+        if self.range_doy is not None:
+            _, ids_filter = self.get_doy_period(eopatch)
+            ts_mean = ts_mean[ids_filter]
+        return ts_mean
+
+    def get_doy_period(self, eopatch):
+
+        first_of_year = eopatch.timestamp[0].timetuple().tm_yday
+        last_of_year = eopatch.timestamp[-1].timetuple().tm_yday
+
+        times = np.asarray([time.toordinal() for time in eopatch.timestamp])
+        times_ = (times - times[0]) / (times[-1] - times[0])
+        times_doy = times_ * (last_of_year - first_of_year) + first_of_year
+
+        if self.range_doy is not None:
+            ids_filter = np.where((times_doy > self.range_doy[0]) &
+                                  (times_doy < self.range_doy[1]))[0]
+            return times_doy[ids_filter], ids_filter
+        else:
+            return times_doy
+
+
+    @staticmethod
+    def _doubly_logistic(middle, initial_value, scale, a1, a2, a3, a4, a5):
+        '''
+        α1 is seasonal minimum greenness
+        α2 is the seasonal amplitude
+        α3 controls the green-up rate
+        α4 is the green-up inflection point
+        α5 controls the mid-growing season greenness trajectory.
+        :return:
+        '''
+        return initial_value + scale * np.piecewise(
+            middle,
+            [middle < a1, middle >= a1],
+            [lambda y: np.exp(-(((a1 - y) / a4) ** a5)), lambda y: np.exp(-(((y - a1) / a2) ** a3))],
+        )
+
+    def _fit_optimize_doubly(self, x_axis, y_axis, initial_parameters=None):
+        bounds_lower = [
+            np.min(y_axis),
+            -np.inf,
+            x_axis[0],
+            0.15,
+            1,
+            0.15,
+            1,
+        ]
+        bounds_upper = [
+            np.max(y_axis),
+            np.inf,
+            x_axis[-1],
+            np.inf,
+            np.inf,
+            np.inf,
+            np.inf,
+        ]
+        if initial_parameters is None:
+            initial_parameters = [np.mean(y_axis), 0.2, (x_axis[-1] - x_axis[0]) / 2, 0.15, 10, 0.15, 10]
+
+        popt, pcov = curve_fit(
+            self._doubly_logistic,
+            x_axis,
+            y_axis,
+            initial_parameters,
+            bounds=(bounds_lower, bounds_upper),
+            maxfev=1000000,
+            absolute_sigma=True,
+        )
+        self.params = popt
+
+        return popt
+
+    def execute(self, eopatch, feature, feature_mask = 'polygon_mask', function=np.nanmedian):
+
+        avg_ts = self.get_time_series_profile(eopatch, feature, feature_mask, function)
+        if self.range_doy is not None:
+            times_doy, _ = self.get_doy_period(eopatch)
+        else:
+            times_doy = self.get_doy_period(eopatch)
+
+        y = avg_ts.flatten()
+        x = (times_doy - times_doy[0]) / (times_doy[-1] - times_doy[0])
+
+        initial_value, scale, a1, a2, a3, a4, a5 = self._fit_optimize_doubly(x, y.flatten())
+        fitted = self._doubly_logistic(x, initial_value, scale, a1, a2, a3, a4, a5)
+
+        return fitted
+
+
+
diff --git a/eo-crops/eocrops/tasks/vegetation_indices.py b/eo-crops/eocrops/tasks/vegetation_indices.py
new file mode 100644
index 0000000..fe14434
--- /dev/null
+++ b/eo-crops/eocrops/tasks/vegetation_indices.py
@@ -0,0 +1,358 @@
+import math
+from eolearn.core import   FeatureType, EOTask
+import numpy as np
+from eolearn.core import AddFeatureTask, RemoveFeatureTask
+
+
+class VegetationIndicesVHRS(EOTask):
+    def __init__(self, feature_name) :
+        self.feature_name = feature_name
+
+    def calcul_ratio_vegetation_indices(self):
+        self.NDVI = (self.B4 - self.B3)/(self.B4 + self.B3)
+        self.NDWI = (self.B2 - self.B4)/(self.B2 + self.B4)
+        self.VARI = (self.B2 - self.B3)/(self.B2 + self.B3 - self.B1)
+
+    def execute(self, eopatch, **kwargs):
+        arr0 = eopatch.data[self.feature_name]
+
+        # Raw data
+        self.B1 = arr0[..., 0]
+        self.B2 = arr0[..., 1]
+        self.B3 = arr0[..., 2]
+        self.B4 = arr0[..., 3]
+        # VIS
+        self.calcul_ratio_vegetation_indices()
+        
+        add_NDVI = AddFeatureTask((FeatureType.DATA, 'NDVI'))
+        add_NDVI.execute(eopatch=eopatch, data=self.NDVI[..., np.newaxis])
+
+        add_NDWI = AddFeatureTask((FeatureType.DATA, 'NDWI'))
+        add_NDWI.execute(eopatch=eopatch, data=self.NDWI[..., np.newaxis])
+
+        add_VARI = AddFeatureTask((FeatureType.DATA, 'VARI'))
+        add_VARI.execute(eopatch=eopatch, data=self.VARI[..., np.newaxis])
+
+        return eopatch
+
+
+
+class BiophysicalIndices:
+    def __init__(self,B03, B04,B05, B06, B07,B8A,B11, B12, viewZenithMean, sunZenithAngles, viewAzimuthMean,sunAzimuthAngles):
+        '''EOPatch should contains only 10 and 20m bands + illumination properties, as in eocrops.input.sentinel2'''
+        self.B03 = B03
+        self.B04 = B04
+        self.B05 = B05
+        self.B06 = B06
+        self.B07 = B07
+        self.B8A = B8A
+        self.B11 = B11
+        self.B12 = B12
+        self.viewZenithMean = viewZenithMean
+        self.sunZenithAngles = sunZenithAngles
+        self.viewAzimuthMean = viewAzimuthMean
+        self.sunAzimuthAngles = sunAzimuthAngles
+
+    @staticmethod
+    def _normalize(unnormalized, mini, maxi) :
+        '''Normalize input Neural Network'''
+        return 2*(unnormalized-mini)/(maxi-mini)-1
+
+    @staticmethod
+    def _denormalize(normalized, mini, maxi) :
+        '''Denormalize output Neural Network'''
+        return 0.5*(normalized+1)*(maxi-mini)+mini
+
+    @staticmethod
+    def _funccos(t):
+        return np.vectorize(lambda t : math.cos(t))
+
+    @staticmethod
+    def _neuron(cste, w_b03, w_b04, w_b05, w_b06, w_b07, w_b8A, w_b11, w_b12, w_viewZen_norm, w_sunZen_norm,
+               w_relAzim_norm, b03_norm, b04_norm, b05_norm, b06_norm, b07_norm, b8a_norm, b11_norm, b12_norm,
+               viewZen_norm, sunZen_norm, relAzim_norm) :
+
+        def tansig(input_neuron) :
+            '''Activation function neural network'''
+            funcexp = np.vectorize(lambda t : math.exp(t))
+            return 2/(1+funcexp(-2*input_neuron))-1
+
+        '''Define the neuron, which is a linear combination of the metadata of sentinel2 images'''
+
+        var_sum = cste+w_b03*b03_norm+w_b04*b04_norm+w_b05*b05_norm+w_b06*b06_norm
+        var_sum += w_b07*b07_norm+w_b8A*b8a_norm+w_b11*b11_norm+w_b12*b12_norm
+        var_sum += w_viewZen_norm*viewZen_norm+w_sunZen_norm*sunZen_norm+w_relAzim_norm*relAzim_norm
+
+        return tansig(var_sum)
+
+    @staticmethod
+    def _layer2(cste, w_n1, neuron1, w_n2, neuron2, w_n3, neuron3, w_n4, neuron4, w_n5, neuron5) :
+        '''Define the second layer, which is a linear combination of the neurons => input of the activation function'''
+        return cste+w_n1*neuron1+w_n2*neuron2+w_n3*neuron3+w_n4*neuron4+w_n5*neuron5
+
+    def apply_normalize(self) :
+        self.b03_norm = self._normalize(self.B03, 0, 0.253061520471542)
+        self.b04_norm = self._normalize(self.B04, 0, 0.290393577911328)
+        self.b05_norm = self._normalize(self.B05, 0, 0.305398915248555)
+        self.b06_norm = self._normalize(self.B06, 0.006637972542253, 0.608900395797889)
+        self.b07_norm = self._normalize(self.B07, 0.013972727018939, 0.753827384322927)
+        self.b8a_norm = self._normalize(self.B8A, 0.026690138082061, 0.782011770669178)
+        self.b11_norm = self._normalize(self.B11, 0.016388074192258, 0.493761397883092)
+        self.b12_norm = self._normalize(self.B12, 0, 0.493025984460231)
+
+        degToRad = math.pi/180
+        funccos = np.vectorize(lambda t : math.cos(t))
+
+        self.viewZen_norm = self._normalize(funccos(self.viewZenithMean*degToRad), 0.918595400582046, 1)
+        self.sunZen_norm = self._normalize(funccos(self.sunZenithAngles*degToRad), 0.342022871159208, 0.936206429175402)
+        self.relAzim_norm = funccos((self.sunAzimuthAngles-self.viewAzimuthMean)*degToRad)
+
+
+    def get_LAI(self) :
+        '''Define biophysical vegetation index Leaf Area Index, computed from a trained neural network which has as input the metadata of sentinel2 images'''
+
+        n1 = self._neuron(4.96238030555279, - 0.023406878966470, + 0.921655164636366,
+                    0.135576544080099, - 1.938331472397950, - 3.342495816122680,
+                    0.902277648009576, 0.205363538258614, - 0.040607844721716,
+                    -0.083196409727092, 0.260029270773809, 0.284761567218845,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n2 = self._neuron(1.416008443981500, - 0.132555480856684, - 0.139574837333540,
+                    - 1.014606016898920, - 1.330890038649270, 0.031730624503341,
+                    - 1.433583541317050, - 0.959637898574699, + 1.133115706551000,
+                    0.216603876541632, 0.410652303762839, 0.064760155543506,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n3 = self._neuron(1.075897047213310, 0.086015977724868, 0.616648776881434,
+                    0.678003876446556, 0.141102398644968, - 0.096682206883546,
+                    - 1.128832638862200, 0.302189102741375, 0.434494937299725,
+                    - 0.021903699490589, - 0.228492476802263, - 0.039460537589826,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n4 = self._neuron(1.533988264655420, - 0.109366593670404, - 0.071046262972729,
+                    + 0.064582411478320, 2.906325236823160, - 0.673873108979163,
+                    - 3.838051868280840, 1.695979344531530, 0.046950296081713,
+                    - 0.049709652688365, 0.021829545430994, 0.057483827104091,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n5 = self._neuron(3.024115930757230, - 0.089939416159969, 0.175395483106147,
+                    - 0.081847329172620, 2.219895367487790, 1.713873975136850,
+                    0.713069186099534, 0.138970813499201, - 0.060771761518025,
+                    0.124263341255473, 0.210086140404351, - 0.183878138700341,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        l2 = self._layer2(1.096963107077220, -1.500135489728730, n1, -0.096283269121503, n2, -  0.194935930577094, n3,
+                    - 0.352305895755591, n4, 0.075107415847473, n5)
+
+        return self._denormalize(l2, 0.000319182538301, 14.4675094548151)
+
+    def get_Cab(self) :
+        '''Define biochemical vegetation index Chloro a+b, computed from a trained neural network which has as input the metadata of sentinel2 images'''
+
+        n1 = self._neuron(4.242299670155190, 0.400396555256580, 0.607936279259404,
+                    0.137468650780226, - 2.955866573461640, - 3.186746687729570,
+                    2.206800751246430, - 0.313784336139636, + 0.256063547510639,
+                    -0.071613219805105, 0.510113504210111, 0.142813982138661,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n2 = self._neuron(- 0.259569088225796, - 0.250781102414872, 0.439086302920381,
+                    - 1.160590937522300, - 1.861935250269610, 0.981359868451638,
+                    1.634230834254840, - 0.872527934645577, 0.448240475035072,
+                    0.037078083501217, 0.030044189670404, 0.005956686619403,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n3 = self._neuron(3.130392627338360, 0.552080132568747, - 0.502919673166901,
+                    6.105041924966230, - 1.294386119140800, - 1.059956388352800,
+                    - 1.394092902418820, 0.324752732710706, - 1.758871822827680,
+                    - 0.036663679860328, - 0.183105291400739, - 0.038145312117381,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n4 = self._neuron(0.774423577181620, 0.211591184882422, - 0.248788896074327,
+                    0.887151598039092, 1.143675895571410, - 0.753968830338323,
+                    - 1.185456953076760, 0.541897860471577, - 0.252685834607768,
+                    - 0.023414901078143, - 0.046022503549557, - 0.006570284080657,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n5 = self._neuron(2.584276648534610, 0.254790234231378, - 0.724968611431065,
+                    0.731872806026834, 2.303453821021270, - 0.849907966921912,
+                    - 6.425315500537270, 2.238844558459030, - 0.199937574297990,
+                    0.097303331714567, 0.334528254938326, 0.113075306591838,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        l2 = self._layer2(0.463426463933822, - 0.352760040599190, n1, - 0.603407399151276, n2, 0.135099379384275, n3,
+                    - 1.735673123851930, n4, - 0.147546813318256, n5)
+
+        return self._denormalize(l2, 0.007426692959872, 873.908222110306)/10
+
+    def get_FAPAR(self) :
+        '''Define biophysical vegetation index Fraction of Absorbed Photosynthetically Active Radiation, computed from a trained neural network which has as input the metadata of sentinel2 images'''
+        n1 = self._neuron(- 0.887068364040280, 0.268714454733421, - 0.205473108029835,
+                    0.281765694196018, 1.337443412255980, 0.390319212938497,
+                    - 3.612714342203350, 0.222530960987244, 0.821790549667255,
+                    - 0.093664567310731, 0.019290146147447, 0.037364446377188,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n2 = self._neuron(0.320126471197199, - 0.248998054599707, - 0.571461305473124,
+                    - 0.369957603466673, 0.246031694650909, 0.332536215252841,
+                    0.438269896208887, 0.819000551890450, - 0.934931499059310,
+                    0.082716247651866, - 0.286978634108328, - 0.035890968351662,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n3 = self._neuron(0.610523702500117, - 0.164063575315880, - 0.126303285737763,
+                    - 0.253670784366822, - 0.321162835049381, 0.067082287973580,
+                    2.029832288655260, - 0.023141228827722, - 0.553176625657559,
+                    0.059285451897783, - 0.034334454541432, - 0.031776704097009,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n4 = self._neuron(- 0.379156190833946, 0.130240753003835, 0.236781035723321,
+                    0.131811664093253, - 0.250181799267664, - 0.011364149953286,
+                    - 1.857573214633520, - 0.146860751013916, 0.528008831372352,
+                    - 0.046230769098303, - 0.034509608392235, 0.031884395036004,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        n5 = self._neuron(1.353023396690570, - 0.029929946166941, 0.795804414040809,
+                    0.348025317624568, 0.943567007518504, - 0.276341670431501,
+                    - 2.946594180142590, 0.289483073507500, 1.044006950440180,
+                    - 0.000413031960419, 0.403331114840215, 0.068427130526696,
+                    self.b03_norm, self.b04_norm, self.b05_norm, self.b06_norm,
+                    self.b07_norm, self.b8a_norm, self.b11_norm, self.b12_norm,
+                    self.viewZen_norm, self.sunZen_norm, self.relAzim_norm)
+
+        l2 = self._layer2(- 0.336431283973339, 2.126038811064490, n1, - 0.632044932794919, n2, 5.598995787206250, n3,
+                    1.770444140578970, n4, - 0.267879583604849, n5)
+
+        return self._denormalize(l2, 0.000153013463222, 0.977135096979553)
+
+
+
+
+class VegetationIndicesS2(EOTask) :
+    '''Define a class of vegetation indices, which are computed from the metadata of sentinel2 images extracted'''
+
+    def __init__(self, feature_name, mask_data=True) :
+        self.feature_name = feature_name
+        self.mask_data = mask_data
+
+    def get_vegetation_indices(self) :
+        '''Define vegetation indices which are simply ratio of spectral bands'''
+        self.NDVI = (self.B8A-self.B04)/(self.B8A+self.B04)
+        self.NDWI = (self.B8A-self.B11)/(self.B8A+self.B11)
+        self.GNDVI = (self.B8A-self.B03)/(self.B8A+self.B03)
+
+        biopysicial_parameters = BiophysicalIndices(self.B03, self.B04, self.B05, self.B06, self.B07, self.B8A, self.B11, self.B12,
+                                                    self.viewZenithMean, self.sunZenithAngles, self.viewAzimuthMean, self.sunAzimuthAngles)
+        # Normalized bands
+        biopysicial_parameters.apply_normalize()
+
+        self.fapar = biopysicial_parameters.get_FAPAR()
+        self.LAI = biopysicial_parameters.get_LAI()
+        self.Cab = biopysicial_parameters.get_Cab()
+
+
+    def execute(self, eopatch) :
+        '''Add those vegeation indices to the eo-patch for futur use'''
+
+        bands_array = eopatch.data[self.feature_name]
+        illumination_array = eopatch.data['ILLUMINATION']
+
+        valid_data_mask = eopatch.mask['VALID_DATA'] if self.mask_data else eopatch.mask['IS_DATA']
+
+        if 'polygon_mask' in list(eopatch.mask_timeless.keys()) :
+
+            bands_array = np.ma.array(bands_array,
+                                      dtype=np.float32,
+                                      mask=np.logical_or(~valid_data_mask.astype(np.bool), np.isnan(bands_array)),
+                                      fill_value=np.nan)
+            bands_array = bands_array.filled()
+
+        # Raw data
+        self.B02 = bands_array[..., 0]
+        self.B03 = bands_array[..., 1]
+        self.B04 = bands_array[..., 2]
+        self.B05 = bands_array[..., 3]
+        self.B06 = bands_array[..., 4]
+        self.B07 = bands_array[..., 5]
+        self.B08 = bands_array[..., 6]
+        self.B8A = bands_array[..., 7]
+        self.B11 = bands_array[..., 8]
+        self.B12 = bands_array[..., 9]
+        self.viewZenithMean = illumination_array[..., 0]
+        self.sunZenithAngles = illumination_array[..., 1]
+        self.viewAzimuthMean = illumination_array[..., 2]
+        self.sunAzimuthAngles = illumination_array[..., 3]
+
+        self.get_vegetation_indices()
+        add_fapar = AddFeatureTask((FeatureType.DATA, 'fapar'))
+        add_fapar.execute(eopatch=eopatch, data=self.fapar[..., np.newaxis])
+        
+        add_Cab = AddFeatureTask((FeatureType.DATA, 'Cab'))
+        add_Cab.execute(eopatch=eopatch, data=self.Cab[..., np.newaxis])
+
+        add_LAI = AddFeatureTask((FeatureType.DATA, 'LAI'))
+        add_LAI.execute(eopatch=eopatch, data=self.LAI[..., np.newaxis])
+
+        add_NDVI = AddFeatureTask((FeatureType.DATA, 'NDVI'))
+        add_NDVI.execute(eopatch=eopatch, data=self.NDVI[..., np.newaxis])
+
+        add_NDWI = AddFeatureTask((FeatureType.DATA, 'NDWI'))
+        add_NDWI.execute(eopatch=eopatch, data=self.NDWI[..., np.newaxis])
+
+        add_GNDVI = AddFeatureTask((FeatureType.DATA, 'GNDVI'))
+        add_GNDVI.execute(eopatch=eopatch, data=self.GNDVI[..., np.newaxis])
+
+        remove_illumination = RemoveFeatureTask([FeatureType.DATA, "ILLUMINATION"])
+        remove_illumination.execute(eopatch)
+
+        return eopatch
+
+
+
+
+class EuclideanNorm(EOTask) :
+    """
+    The tasks calculates Euclidian Norm of all bands within an array:
+    norm = sqrt(sum_i Bi**2),
+    where Bi are the individual bands within user-specified feature array.
+    """
+
+    def __init__(self, feature_name, in_feature_name) :
+        self.feature_name = feature_name
+        self.in_feature_name = in_feature_name
+
+    def execute(self, eopatch) :
+        arr = eopatch.data[self.in_feature_name]
+        norm = np.sqrt(np.sum(arr**2, axis=-1))
+        add_ecnorm = AddFeatureTask((FeatureType.DATA, self.feature_name))
+        return add_ecnorm.execute(eopatch=eopatch, data = norm[..., np.newaxis])
+
+
+
+
diff --git a/eo-crops/eocrops/utils/__init__.py b/eo-crops/eocrops/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/eo-crops/eocrops/utils/data_loader.py b/eo-crops/eocrops/utils/data_loader.py
new file mode 100644
index 0000000..4aac948
--- /dev/null
+++ b/eo-crops/eocrops/utils/data_loader.py
@@ -0,0 +1,242 @@
+from eolearn.core import EOPatch, FeatureType, AddFeatureTask
+
+import glob
+import numpy as np
+
+import os
+
+from eolearn.geometry import ErosionTask
+import eocrops.tasks.preprocessing as preprocessing
+import copy
+from scipy import interpolate as interpolate
+###########################################################################################################
+
+class EOPatchDataset:
+    def __init__(self,
+                 root_dir, features_data,
+                 suffix='', resampling = None,
+                 range_doy = (1, 365),
+                 function=np.nanmedian):
+        """
+        root_dir (str) : root path where EOPatch are saved
+        features_data (list of tuples) : features to aggregate in the dataset
+        suffix (str) : suffix of the EOPatch file names to read only a subset of EOPatch (e.g. '_S2'). This is very useful if you have several data sources in the same root_dir.
+        resampling (dict) : resampling period to make EOPatch at the same time scale and timely comparables (e.g. 8-days period)
+        range_doy (tuple) : suset of the time series w.r.t a range of day of the year (e.g. between the 1st day and the 365th day)
+        function (np.functon) : function to aggegate pixels not masked into a single time series
+        """
+
+        import tensorflow as tf
+        import tensorflow_datasets as tfds
+        global tf
+        global tfds
+
+        self.root_dir = root_dir
+
+        self.features_data = features_data
+        self.suffix = suffix
+        self.mask = (FeatureType.MASK_TIMELESS, 'MASK')
+        self.curve_fitting = preprocessing.CurveFitting(range_doy=range_doy)
+
+        if resampling is None:
+            resampling = dict(start = '-01-01', end = '-12-31', day_periods = 8)
+        self.resampling = resampling
+        self.function = function
+
+        try:
+            self.AUTOTUNE = tf.data.AUTOTUNE
+        except:
+            self.AUTOTUNE = tf.data.experimental.AUTOTUNE
+
+    def _instance_tf_ds(self):
+        '''
+        initalize tf.data.Dataset w.r.t the file names in self.root_dir_or_list
+        '''
+        file_pattern = os.path.join(self.root_dir, '*' + self.suffix)
+        files = glob.glob(file_pattern)
+        if len(files) == 0:
+            raise ValueError('No file in the root directory ' + self.root_dir + " ending with " + self.suffix)
+        files.sort()
+        self.dataset = tf.data.Dataset.from_tensor_slices(files)
+        self.vector_dataset = tf.data.Dataset.from_tensor_slices(files)
+
+    @staticmethod
+    def _interpolate_feature(eopatch, features,  **kwargs):
+        '''
+        Perform gapfilling over a new time window or not.
+        '''
+        kwargs['features'] = features
+        interp = preprocessing.InterpolateFeatures( **kwargs)
+        eopatch = interp.execute(eopatch)
+        return eopatch
+
+    def _resamping_timeseries(self, arr, doy):
+        '''
+        Resample time series over a new periods after double logistic curve fitting
+        '''
+
+        xnew = np.arange(0, 365, self.resampling['day_periods'])
+        start = np.where(xnew >= doy[0])[0][0]
+        end = np.where(xnew <= doy[-1])[0][-1]
+
+        flinear_cspline = interpolate.Akima1DInterpolator(doy, arr)
+        ylinear_cspline = flinear_cspline(xnew[start:end])
+
+        before_season = np.repeat(ylinear_cspline[0], xnew[:start].shape[0])
+        before_season = before_season.reshape(before_season.shape[0] // ylinear_cspline.shape[1],
+                                              ylinear_cspline.shape[1])
+
+        after_season = np.repeat(ylinear_cspline[-1], xnew[end:].shape[0])
+        after_season = after_season.reshape(after_season.shape[0] // ylinear_cspline.shape[1],
+                                              ylinear_cspline.shape[1])
+
+        return np.concatenate([before_season, ylinear_cspline, after_season], axis=0)
+
+    def _execute_gap_filling(self, eopatch,
+                             resampled_range,
+                             copy_features,
+                             algorithm = 'linear'):
+
+        '''Gap filling after data extraction, very useful if did not include it in the data extraction workflow'''
+        kwargs = dict(copy_features=copy_features,
+                      resampled_range=resampled_range,
+                      algorithm = algorithm)
+
+        features = []
+        for ftype, fname, _, _, _ in self.features_data:
+            features.append((FeatureType.DATA, fname))
+        new_eopatch = self._interpolate_feature(eopatch=eopatch, features=features, **kwargs)
+
+        return new_eopatch
+
+    def _prepare_eopatch(self, patch, resampled_range, algorithm = 'linear'):
+
+        polygon_mask = (patch.data_timeless['FIELD_ID']>0).astype(np.int32)
+        add_feature = AddFeatureTask(self.mask)
+        add_feature.execute(eopatch=patch, data=polygon_mask.astype(bool))
+        #patch.add_feature(self.mask[0], self.mask[1], polygon_mask.astype(bool))
+
+        erode = ErosionTask(mask_feature=self.mask, disk_radius=1)
+        erode.execute(patch)
+
+        patch = self._execute_gap_filling(eopatch=patch,
+                                          resampled_range=resampled_range,
+                                          algorithm=algorithm,
+                                          copy_features=[self.mask])
+        return patch
+
+
+    def _read_patch(self, path, algorithm = 'linear', doubly_logistic = False):
+        """ TF op for reading an eopatch at a given path. """
+        def _func(path):
+            path = path.numpy().decode('utf-8')
+            # Load only relevant features
+            ################################################################
+            #path = os.path.join(root_dir, os.listdir(root_dir)[0])
+            patch = EOPatch.load(path)
+            if not doubly_logistic:
+                year = str(patch.timestamp[0].year)
+                start, end = year + self.resampling['start'], year + self.resampling['end']
+                resampled_range = (start, end, self.resampling['day_periods'])
+            else:
+                resampled_range = None
+
+            patch = self._prepare_eopatch(patch, resampled_range, algorithm)
+
+            doy, _ = self.curve_fitting.get_doy_period(patch)
+            #################################################################
+            data = []
+            for feat_type, feat_name, _, dtype, _ in self.features_data:
+
+                arr = self.curve_fitting.get_time_series_profile(eopatch=patch,
+                                                                 feature=feat_name,
+                                                                 feature_mask= self.mask[-1],
+                                                                 function = self.function)
+
+                if doubly_logistic:
+                    arr = self.curve_fitting.execute(eopatch = patch, feature=feat_name, feature_mask=self.mask[-1])
+
+                arr = self._resamping_timeseries(arr.reshape(arr.shape[0], 1), doy)
+                data.append(arr)
+
+            return data
+
+        #################################################################
+        out_types = [tf.as_dtype(data[3]) for data in self.features_data]
+        data = tf.py_function(_func, [path], out_types)
+
+        out_data = {}
+        for f_data, feature in zip(self.features_data, data):
+            feat_type, feat_name, out_name, dtype, _ = f_data
+            feature.set_shape(feature.get_shape())
+            out_data[out_name] = feature
+
+        return out_data
+
+    def _read_vector_data(self, path, column_path, vector_data, features_list):
+        """
+        TF op for reading an eopatch at a given path.
+        It must have a column with the corresponding path
+        """
+        def _func(path) :
+            path = path.numpy().decode('utf-8')
+            vector_data_ = vector_data.copy()
+            vector_data_ = vector_data_[vector_data_[column_path] == path]
+
+            data = []
+            for feat, dtype_ in features_list:
+                data.append(np.array(vector_data_[feat].astype(dtype_)))
+            return data
+
+        data = tf.py_function(_func, [path], [feat[1] for feat in features_list])
+        out_data = {}
+        for fname, feature in zip(features_list, data):
+            feature.set_shape(feature.get_shape())
+            out_data[fname] = feature
+        return out_data
+
+    @staticmethod
+    def _format_feature(out_feature):
+        out_df = [np.concatenate([np.expand_dims(value, axis=1)
+                                  if len(value.shape) == 1 else value
+                                  for key, value in dicto.items()], axis=-1)
+                  for dicto in out_feature]
+
+        out_df = [np.expand_dims(k, axis=0) for k in out_df]
+        return np.concatenate(out_df, axis=0)
+
+    def get_eopatch_tfds(self, algorithm = 'linear', doubly_logistic = False):
+        '''
+        Aggregate all the EOPatch files into a single 3D array, where each observation is summarized muiltivariate time series (e.g. median NDVI and NDWI) of one EOPatch
+
+        Parameters
+        ----------
+        algorithm (str): name of the algorithm for gapfilling (linear or cubic)
+        '''
+
+        self._instance_tf_ds()
+        ds_numpy = self.dataset.map(lambda x : self._read_patch(path = x, algorithm=algorithm, doubly_logistic = doubly_logistic),
+                                    num_parallel_calls=self.AUTOTUNE)
+        out_feature = list(ds_numpy)
+        return self._format_feature(out_feature)
+
+    def get_vector_tfds(self, vector_data, features_list, column_path):
+        '''
+        Get ground truth data from a given dataframe into a 2D array. Each observation will match with the aggregation of EOPatch
+        '''
+
+        self._instance_tf_ds()
+        out_labels = list(self.vector_dataset.map(
+            lambda path : self._read_vector_data(
+                path, column_path, vector_data, features_list),
+            num_parallel_calls=self.AUTOTUNE))
+
+        npy_labels = self._format_feature(out_labels)
+        npy_labels = npy_labels.reshape(npy_labels.shape[0], npy_labels.shape[-1])
+
+        return npy_labels
+
+
+
+
+
diff --git a/eo-crops/eocrops/utils/utils.py b/eo-crops/eocrops/utils/utils.py
new file mode 100644
index 0000000..d25490a
--- /dev/null
+++ b/eo-crops/eocrops/utils/utils.py
@@ -0,0 +1,106 @@
+import sentinelhub
+from sentinelhub import CRS
+import math
+from shapely.geometry import *
+
+import rasterio
+import warnings
+
+import numpy as np
+
+
+
+def save_numpy(path, array, name_array):
+    with open(os.path.join(path, name_array + '.npy'), 'wb') as f:
+        np.save(f, array)
+
+
+def MetaInfos(saving_path, N) :
+    with rasterio.open(saving_path) as src0 :
+        meta = src0.meta
+        meta['nodata'] = np.nan
+        meta['dtype'] = 'float32'
+
+    meta.update(count=N)
+    meta.update(nodata=np.nan)
+
+    return meta
+
+
+def WriteTiff(array, saving_path, meta, dim=1) :
+    with rasterio.open(saving_path, 'w', **meta) as dst :
+        if dim>1 :
+            for id in range(dim) :
+                dst.write_band(id+1, array[:, :, id].astype(np.float32))
+        else :
+            dst.write_band(1, array.astype(np.float32))
+
+
+def check_crs(reference_file_) :
+    reference_file = reference_file_.copy()
+    reference_file_crs = reference_file.crs
+    if reference_file_crs is None :
+        reference_file.set_crs(epsg=4326, inplace=True)
+        warnings.warn('Your input GeoDataFrame should have a CRS! By default, it will set to WGS84')
+    elif str(reference_file_crs).split(':')[-1]!='4326' :
+        reference_file.to_crs(epsg=4326, inplace=True)
+
+    xmin, ymin, xmax, ymax = reference_file.geometry.iloc[0].bounds
+    utm_crs = str(CRS.get_utm_from_wgs84(xmin, ymin))
+    reference_file.to_crs(utm_crs, inplace=True)
+
+    return reference_file
+
+
+def get_bounding_box(shapefile):
+    ''' Get the bounding box of a given polygon for sentinelhub request
+    Inputs :
+        - polygon (geometry object) : polygon of a field
+    '''
+    shapefile = check_crs(shapefile)
+    xmin, ymin, xmax, ymax = shapefile.geometry.total_bounds
+    return sentinelhub.BBox(
+        bbox=[(xmin, ymin), (xmax, ymax)], crs=str(shapefile.crs)
+    )
+
+
+def create_polygon_bbox(longitude, latitude, distance) :
+
+
+    r_earth = 6378
+    dx = distance/1000
+    dy = distance/1000
+
+    ic_x = (dx/r_earth)*(180/math.pi)/math.cos(latitude*math.pi/180)
+    ic_y = (dy/r_earth)*(180/math.pi)
+
+
+    return box(longitude-ic_x,
+               latitude-ic_y,
+               longitude+ic_x,
+               latitude+ic_y)
+
+
+
+def get_resampled_periods(start, end, year, days_range=1):
+    '''
+    Get the resampled periods from the resample range
+    '''
+    import dateutil
+    import datetime as dt
+    resample_range_ = (str(year) + start,
+                       str(year) + end,
+                       days_range)
+
+    start_date = dateutil.parser.parse(resample_range_[0])
+    end_date = dateutil.parser.parse(resample_range_[1])
+    step = dt.timedelta(days=resample_range_[2])
+
+    days = [start_date]
+    while days[-1] + step < end_date:
+        days.append(days[-1] + step)
+    days = [str(day).split(' ')[0] for day in days]
+    return days
+
+
+
diff --git a/eo-crops/examples/Sentinel data.ipynb b/eo-crops/examples/Sentinel data.ipynb
new file mode 100644
index 0000000..c4e831b
--- /dev/null
+++ b/eo-crops/examples/Sentinel data.ipynb	
@@ -0,0 +1,947 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5a9eebce",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "# Sentinel 1 and 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "46193fec",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "The aim of this notebook is to guide you how to get Sentinel data using Sentinelhub and eo-learn. Price for subscription is described there https://www.sentinel-hub.com/pricing/.\n",
+    "\n",
+    "The workflow for agriculture purposes is as follows :\n",
+    "\n",
+    "1) Read shapefile that represent you field (boundaries or microplots)\n",
+    "\n",
+    "2) Extract Sentinel-2 data and compute averaged NDVI time series to get a summary of the season vegetation dynamic.\n",
+    "\n",
+    "3) Extract Sentinel-1 data and apply multitemporal speckle filtering"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b394e51",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## Set your working environment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c49c15e",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "### Import the packages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "id": "2714c2f2",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "\n",
+    "import geopandas as gpd\n",
+    "from scipy.signal import savgol_filter\n",
+    "\n",
+    "import os\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from eolearn.core import FeatureType, AddFeatureTask\n",
+    "\n",
+    "from eocrops.input import utils_sh as utils_sh\n",
+    "from eocrops.input import sentinel1 as sentinel1\n",
+    "from eocrops.input import sentinel2 as sentinel2\n",
+    "from eocrops.tasks import cmd_otb as cmd_otb\n",
+    "from eocrops.tasks import preprocessing as preprocessing\n",
+    "from importlib import reload\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59c8b191",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "### Read your vector file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "7f7e1a00",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/johann/Documents/git-repo/eo-crops\n"
+     ]
+    }
+   ],
+   "source": [
+    "dir_path = os.path.dirname(os.getcwd())\n",
+    "print(dir_path)\n",
+    "#read microplot data\n",
+    "shapefile_input = gpd.read_file(os.path.join(dir_path, './examples/layers/POLYGON.shp'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e325fa21",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "api = ''\n",
+    "client_id = ''\n",
+    "client_secret = ''\n",
+    "config = utils_sh.config_sentinelhub_cred(api, client_id, client_secret)\n",
+    "# Provide here your planet API key\n",
+    "config.planet_key = ''"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "6bad372b",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "time_period = ('2020-02-15', '2020-08-15')\n",
+    "kwargs = dict(polygon=shapefile_input,\n",
+    "              time_stamp=time_period,\n",
+    "              config=config)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "32f5f8c1",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## Extract S2 data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "9f923e73",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "warnings.filterwarnings(\"ignore\")\n",
+    "patch = sentinel2.workflow_instructions_S2L2A(**kwargs,\n",
+    "                                              path_out = None, #you can specify here a path to save the EOPatch object\n",
+    "                                              coverage_predicate=0.5,\n",
+    "                                              interpolation={'interpolate' : True})  # you can add period_length in the dictionary to resample\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "ef3b89b7",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#RGB\n",
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(np.clip(patch.data['BANDS-S2-L2A'][4][..., [2, 1, 0]]*2.5, 0, 1), vmin=0, vmax=1);\n",
+    "plt.axis(False);\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "4babe8e5",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "masking = preprocessing.MaskPixels([\"NDVI\", \"LAI\"])\n",
+    "patch = masking.execute(patch, erosion = 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "f0320999",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#NDVI\n",
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(patch.data['NDVI'][10,].squeeze());\n",
+    "plt.axis(False);\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "id": "93f2b9ae",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#LAI Time Series from masked field\n",
+    "variable = 'LAI'\n",
+    "#Subset the time series between doy 30 and 260 => useful for double logistic smoothing\n",
+    "curve_fit = preprocessing.CurveFitting(range_doy=(60, 300))\n",
+    "doy, _ = curve_fit.get_doy_period(patch)\n",
+    "ts_mean = curve_fit.get_time_series_profile(patch,feature=variable, feature_mask = 'MASK').flatten()\n",
+    "fitted = curve_fit.execute(patch, feature=variable, feature_mask = 'MASK')\n",
+    "\n",
+    "plt.plot(patch.timestamp, fitted,  label='Double logistic')\n",
+    "plt.plot(patch.timestamp, ts_mean, label='Original')\n",
+    "plt.legend(loc='upper left')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "f260c1bd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 0.45528363,  0.15000042, 23.16021074,  0.17572339,  9.23138875])"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Parameters from doubly logistic \n",
+    "#α1 is seasonal minimum greenness\n",
+    "#α2 is the seasonal amplitude\n",
+    "#α3 controls the green-up rate\n",
+    "#α4 is the green-up inflection point\n",
+    "#α5 controls the mid-growing season greenness trajectory.\n",
+    "\n",
+    "curve_fit.params[2:]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "0699a68d",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "datetime.datetime(2020, 5, 31, 11, 17, 40)"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Peak of the season is at 31/05 \n",
+    "time_argmax = np.nanargmax(ts_mean)\n",
+    "patch.timestamp[time_argmax]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "8dce547e",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#If you would like to save the data in .tif format (e.g. NDVI on the first date)\n",
+    "from eolearn.io import ExportToTiffTask\n",
+    "index_time = 0\n",
+    "date = str(patch.timestamp[index_time]).split(' ')[0]\n",
+    "\n",
+    "export = ExportToTiffTask(feature=(FeatureType.DATA, 'NDVI'),\n",
+    "                          folder=os.path.join('your_path_'+ date),\n",
+    "                          band_indices=[0],\n",
+    "                          date_indices=[index_time])\n",
+    "patch = export.execute(patch)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8137402a",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## Extract Sentinel-1 data "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "f94d58fc",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "s1_eopatch = sentinel1.workflow_instructions_S1IW(**kwargs,\n",
+    "                                                  speckle_lee_window = 3,\n",
+    "                                                  orbit_direction = 'ASC',\n",
+    "                                                  backCoeff = 'SIGMA0_ELLIPSOID' ) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "id": "8ef78417",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#Compute Radar Vegetation Index\n",
+    "VV = s1_eopatch.data['BANDS-S1-IW'][...,0]\n",
+    "VH =  s1_eopatch.data['BANDS-S1-IW'][...,1]\n",
+    "RVI = (4*VH)/(VH+VV)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "id": "0a9a6be5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Add the feature to the EOPatch\n",
+    "add_rvi = AddFeatureTask((FeatureType.DATA, \"RVI\"))\n",
+    "add_rvi.execute(eopatch = s1_eopatch, data = RVI[..., np.newaxis])\n",
+    "masking = preprocessing.MaskPixels([ \"RVI\"])\n",
+    "s1_eopatch = masking.execute(s1_eopatch)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "id": "3e549f7f",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#Display RVI from SIGMA0 without any speckle filtering\n",
+    "s1_eopatch = masking.execute(s1_eopatch)\n",
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(s1_eopatch.data['RVI'][15,].squeeze());\n",
+    "plt.axis(False);\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "id": "73335e7e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#RVI Time Series from masked field\n",
+    "variable = 'RVI'\n",
+    "\n",
+    "curve_fit = preprocessing.CurveFitting(range_doy=(60, 300))\n",
+    "doy, _ = curve_fit.get_doy_period(s1_eopatch)\n",
+    "\n",
+    "ts_mean = curve_fit.get_time_series_profile(s1_eopatch,feature=variable, feature_mask = 'MASK').flatten()\n",
+    "fitted = curve_fit.execute(s1_eopatch, feature=variable, feature_mask = 'MASK')\n",
+    "\n",
+    "plt.plot(doy, fitted,  label='Double logistic')\n",
+    "plt.plot(doy, ts_mean, label='Original')\n",
+    "plt.legend(loc='upper left')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "844ed4e9",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "You can easily download and install OTB https://www.orfeo-toolbox.org/CookBook/Installation.html#linux, which allows you to apply Quegan multitemporal speckle filtering"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 86,
+   "id": "543160b3",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-08-08 14:38:31 (INFO) MultitempFilteringOutcore: Default RAM limit for OTB is 256 MB\n",
+      "2022-08-08 14:38:31 (INFO) MultitempFilteringOutcore: GDAL maximum cache size is 781 MB\n",
+      "2022-08-08 14:38:31 (INFO) MultitempFilteringOutcore: OTB will use at most 8 threads\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Estimated memory for full processing: 0.376572MB (avail.: 8 MB), optimal image partitioning: 1 blocks\n",
+      "2022-08-08 14:38:31 (INFO): File ./S1_VV/outcore.tif will be written in 1 blocks of 29x23 pixels\n",
+      "Writing ./S1_VV/outcore.tif...: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:31 (INFO) MultitempFilteringFilter: Default RAM limit for OTB is 256 MB\n",
+      "2022-08-08 14:38:31 (INFO) MultitempFilteringFilter: GDAL maximum cache size is 781 MB\n",
+      "2022-08-08 14:38:31 (INFO) MultitempFilteringFilter: OTB will use at most 8 threads\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:31 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Estimated memory for full processing: 0.012722MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200219_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200219_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200225_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200225_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200302_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200302_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200308_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200308_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200314_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200314_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200320_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200320_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200326_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200326_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200401_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200401_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200407_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200407_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200413_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200413_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200419_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200419_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200425_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200425_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200501_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200501_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200507_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200507_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200513_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200513_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200519_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200519_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200525_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200525_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200531_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200531_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200606_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200606_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200612_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200612_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200618_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200618_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200624_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200624_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200630_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200630_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200706_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200706_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200712_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200712_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200718_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200718_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200724_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200724_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200730_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200730_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200805_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200805_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/S1_VV_20200811_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VV_filtered/S1_VV_20200811_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): Estimated memory for full processing: 0.00890541MB (avail.: 8 MB), optimal image partitioning: 1 blocks\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VV_filtered/enl.tif will be written in 1 blocks of 29x23 pixels\n",
+      "Writing S1_VV_filtered/enl.tif...: 100% [**************************************************] (0s)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-08-08 14:38:32 (INFO) MultitempFilteringOutcore: Default RAM limit for OTB is 256 MB\n",
+      "2022-08-08 14:38:32 (INFO) MultitempFilteringOutcore: GDAL maximum cache size is 781 MB\n",
+      "2022-08-08 14:38:32 (INFO) MultitempFilteringOutcore: OTB will use at most 8 threads\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Estimated memory for full processing: 0.376572MB (avail.: 8 MB), optimal image partitioning: 1 blocks\n",
+      "2022-08-08 14:38:32 (INFO): File ./S1_VH/outcore.tif will be written in 1 blocks of 29x23 pixels\n",
+      "Writing ./S1_VH/outcore.tif...: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO) MultitempFilteringFilter: Default RAM limit for OTB is 256 MB\n",
+      "2022-08-08 14:38:32 (INFO) MultitempFilteringFilter: GDAL maximum cache size is 781 MB\n",
+      "2022-08-08 14:38:32 (INFO) MultitempFilteringFilter: OTB will use at most 8 threads\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Loading metadata from official product\n",
+      "2022-08-08 14:38:32 (INFO): Estimated memory for full processing: 0.012722MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200219_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200219_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200225_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200225_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200302_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200302_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200308_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200308_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200314_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200314_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200320_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200320_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200326_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200326_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200401_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200401_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200407_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200407_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200413_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200413_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200419_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200419_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200425_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200425_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200501_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200501_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200507_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200507_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200513_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200513_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200519_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200519_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200525_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200525_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200531_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200531_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200606_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200606_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200612_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200612_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200618_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200618_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200624_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200624_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200630_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200630_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200706_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200706_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200712_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200712_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200718_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200718_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200724_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200724_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200730_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200730_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200805_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200805_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/S1_VH_20200811_filtered.tif will be written in 1 blocks of 29x23 pixels\n",
+      "S1_VH_filtered/S1_VH_20200811_filtered.tif: 100% [**************************************************] (0s)\n",
+      "2022-08-08 14:38:32 (INFO): Estimated memory for full processing: 0.00890541MB (avail.: 8 MB), optimal image partitioning: 1 blocks\n",
+      "2022-08-08 14:38:32 (INFO): File S1_VH_filtered/enl.tif will be written in 1 blocks of 29x23 pixels\n",
+      "Writing S1_VH_filtered/enl.tif...: 100% [**************************************************] (0s)\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Can take around 10 seconds\n",
+    "mutlitemp = cmd_otb.MultitempSpeckleFiltering(otb_path = '/home/johann/Documents/OTB-8.0.1-Linux64/bin',\n",
+    "                                              window = 3)\n",
+    "s1_eopatch = mutlitemp.execute(s1_eopatch)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "id": "f6844f37",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#Compare backscatter values after multitemporal smoothing\n",
+    "VH = s1_eopatch.data['VH_filtered']\n",
+    "VV = s1_eopatch.data['VV_filtered']\n",
+    "RVI_smoothed = (4*VH)/(VH+VV)\n",
+    "#Add the value smoothed to the EOPatch\n",
+    "add_rvi_smoothed = AddFeatureTask((FeatureType.DATA, \"RVI_smoothed\"))\n",
+    "add_rvi_smoothed.execute(eopatch = s1_eopatch, data = RVI_smoothed)\n",
+    "masking = preprocessing.MaskPixels([\"RVI_smoothed\"])\n",
+    "s1_eopatch = masking.execute(s1_eopatch)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "id": "d10c479b",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(s1_eopatch.data['RVI_smoothed'][15,].squeeze().squeeze());\n",
+    "plt.axis(False);\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "id": "226114f1",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#RVI smoothed Time Series from masked field\n",
+    "variable = 'RVI_smoothed'\n",
+    "\n",
+    "curve_fit = preprocessing.CurveFitting(range_doy=(60, 300))\n",
+    "doy, _ = curve_fit._get_ids_period(s1_eopatch)\n",
+    "ts_mean = curve_fit.get_time_series_profile(s1_eopatch,feature=variable, feature_mask = 'MASK').flatten()\n",
+    "fitted = curve_fit.execute(s1_eopatch, feature=variable, feature_mask = 'MASK')\n",
+    "\n",
+    "plt.plot(doy, fitted,  label='Double logistic')\n",
+    "plt.plot(doy, ts_mean, label='Original')\n",
+    "plt.legend(loc='upper left')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d62d985d",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "eo_crops",
+   "language": "python",
+   "name": "eo_crops"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
\ No newline at end of file
diff --git a/eo-crops/examples/VHRS data.ipynb b/eo-crops/examples/VHRS data.ipynb
new file mode 100644
index 0000000..84b7da5
--- /dev/null
+++ b/eo-crops/examples/VHRS data.ipynb	
@@ -0,0 +1,1305 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f564c861",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "# Third party commercial data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a894133",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "The aim of this notebook is to guide you how to get Very High Resolution Satellite (VHRS) data using Sentinelhub and eo-learn. Price for commercial data is described there https://www.sentinel-hub.com/pricing/.\n",
+    "\n",
+    "The workflow for agriculture purposes is as follows :\n",
+    "\n",
+    "1) Read shapefile that represent you field (boundaries or microplots)\n",
+    "\n",
+    "2) Extract Sentinel-2 data and compute averaged NDVI time series to get a summary of the season vegetation dynamic.\n",
+    "\n",
+    "3) Get the index of time when NDVI is maximum (season's peak) and add +/- one month to this date to get the time period for VHRS data extraction.\n",
+    "\n",
+    "4) Extract VHRS data. If provider is Airbus, you can apply pansharpening algorithms to get the spatial resolution from the panchromatic band.\n",
+    "\n",
+    "5) Preprocess and save the data.\n",
+    "\n",
+    "6) Optional : intersects pixels with trial microplots polygons to get a value of NDVI for each microplot."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4e10161",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## Set your working environment"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f988e1d",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "### Import the packages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "0b155914",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "\n",
+    "import glob\n",
+    "import os\n",
+    "\n",
+    "import geopandas as gpd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from importlib import reload\n",
+    "\n",
+    "from eocrops.input import utils_sh as utils_sh\n",
+    "from eocrops.input import sentinel2 as sentinel2\n",
+    "from eocrops.input import vhrs as vhrs\n",
+    "from eocrops.tasks import preprocessing as preprocessing\n",
+    "from eocrops.tasks import vegetation_indices\n",
+    "from eolearn.io import ExportToTiffTask\n",
+    "from eolearn.core import FeatureType\n",
+    "vhrs = reload(vhrs)\n",
+    "vegetation_indices = reload(vegetation_indices)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dca58e15",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "### Read your vector file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1a695f40",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/johann/Documents/git-repo/eo-crops\n"
+     ]
+    }
+   ],
+   "source": [
+    "dir_path = os.path.dirname(os.getcwd())\n",
+    "print(dir_path)\n",
+    "#read microplot data\n",
+    "shapefile_input = gpd.read_file(os.path.join(dir_path, './examples/layers/POLYGON.shp'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "e17bf6ed",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "api = ''\n",
+    "client_id = ''\n",
+    "client_secret = ''\n",
+    "config = utils_sh.config_sentinelhub_cred(api, client_id, client_secret)\n",
+    "# Provide here your planet API key\n",
+    "config.planet_key = ''"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "82604180",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "### Extract S2 data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "294361fe",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "time_period = ('2020-02-01', '2020-10-30')\n",
+    "kwargs = dict(polygon=shapefile_input,\n",
+    "              time_stamp=time_period,\n",
+    "              config=config)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "1f12b506",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "patch = sentinel2.workflow_instructions_S2L2A(**kwargs,\n",
+    "                                              coverage_predicate=0.5,\n",
+    "                                              interpolation={'interpolate' : True})  # you can add period_length in the dictionary to resample pixel wise\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5034136f",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#RGB\n",
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(np.clip(patch.data['BANDS-S2-L2A'][15][..., [2, 1, 0]]*2.5, 0, 1), vmin=0, vmax=1);\n",
+    "plt.axis(False);\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b0584e33",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#Mask out pixels that are oustide the polygon for visualisation and apply a binary erosion with radius = 1 to keep only pure pixels\n",
+    "masking = preprocessing.MaskPixels([\"NDVI\"])\n",
+    "patch = masking.execute(patch, erosion = 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "6c812721",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASUAAADrCAYAAAAv8oAHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAALVUlEQVR4nO3da2zV9R3H8V97egq90Av3tlykFLkoBRHGNWygqGTJYuZEEnU33Vy2mKDJ3OaWPdliZjJ00wUX3ZzJFnVxM0NjnJlOkSm6IEGFikUQRrkUSq9cTu976h7g97NQ4YO+X48/+Z5Dz+HT/4MvX/IGBwcTALjIP99vAAA+ilICYIVSAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmCl4Hy/AWAorcqskQ6EHbttUZjZvuHOvLN+Q/i/8aQEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwAqlBMBKHv8ZJS4U9evuD7+snVMHpFlFR+Lfx4MZaVSacdVuKVea7Q4zFdnT0qzfzHv8U7vYyZMSACuUEgArlBIAK5QSACuUEgArlBIAK5QSACuUEgArlBIAK2x047ybc3u8qZ1SSh0z+8PM1JmHpNf8YHdVHMpq2+EvXvkrKXegryzMTM92SrMePL5Eyu3qGhdmppQcl2Z1D2TDzIbL/3TWm+Y8KQGwQikBsEIpAbBCKQGwQikBsEIpAbBCKQGwQikBsEIpAbDCRjc+MfO+fZ+2qb1Su0u9rHZPmPmwc5Q061BrvF1dM6pDmlWS7ZFy9eUHw8y60VukWTc33iDlWk4Vh5nrJr8tzfrDjsVhJlMQb92nlFLjV356xs1vnpQAWKGUAFihlABYoZQAWKGUAFihlABYoZQAWKGUAFgpON9vABemxWvXh4uRx1dpi3RrZm6Xct0D8dd1fIl2TnZYpi/MHOwol2alESekWGmmO8xsPi2c6U0pTShpl3L1lfHC5httU6RZ18/cFmb2nhotzfo4PCkBsEIpAbBCKQGwQikBsEIpAbBCKQGwQikBsEIpAbBCKQGwwkY3/sfsO++XTth2LY9jP1n2rPSaTT0jpVx7b1GYKc9qp3V3Hh0fZq6c/L40a3Zxk5TbJWxrt/fH52tTSmlk4Ukpt611YpipKzsmzbpoeEuYeeKNRdKs9DGXdXlSAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmCFUgJghVICYIWN7s+Ia2b+SNrUrnpI24i+ddyOMNM7mJFmDaQ8KVdfGm9Ob3hvuTRrQkVHmLm2Ir5JnVJKf2ldIOWWl+8KM9tPTpZmbWycLeVmVTWHmWH58b3ylFK6f8cVYWb/bd/XPsyPwZMSACuUEgArlBIAK5QSACuUEgArlBIAK5QSACuUEgAreYOD0k4djC1euz78EDvWdkmzfj3nSSl3sLcyzIwt0F5zd3d8mjallLZ3xaddVQvL94aZo71l0qzcQFbKVRW2h5kH3l0hzbr24nek3OFc/GfY8mGtNGvP2h+f9WKkgiclAFYoJQBWKCUAViglAFYoJQBWKCUAViglAFYoJQBWKCUAVjiHa2zVkp9J6/aHvxNvFN9at1V6zYbcBCmnnLoty+SkWY/tXSjlfjD9hTDTO6h9pZ9rqQ8zN47bIs3acmKalNvWGZ+6vXfe09Kso33atvlfGy4LM27/qIMnJQBWKCUAViglAFYoJQBWKCUAViglAFYoJQBWKCUAViglAFbY6D5PFnz9vnCPtvfubmnWXXUvhRl103lTq7advHr0jjCz8Xi8TZxSStNGtki5NaUdYWbd4fnSrKtG7QwzDbkaadarzXVS7tqat8NMfhqQZv2zdYaUW1K7J8zs7RgtzTpXeFICYIVSAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmAlb9DtFuYF7pqL75J+oHvvKQ0zt8x6XXrNbF5/mBkY1H7/5Abi07oppbTr5LgwM3dEkzRrdWm8iJlSSgf6ysPM7p7x0qyOvuIw80zTbGnWd2tfkXKnBoYNSSallPLztCXLlSW7wszcSQfypGHnCE9KAKxQSgCsUEoArFBKAKxQSgCsUEoArFBKAKxQSgCsUEoArLDRLZr82L3SD6p20lFp3rcmbg4zMwqPSLN+cWh1mLm96kVp1vOdc6RcRtgovq78LWnW9twEKVeTbQsz7f0l0qw/Hl4cZuZX7pdmLStplHK/a14eZr469jVp1oqinJTLT/GydrZqDxvdAHAmlBIAK5QSACuUEgArlBIAK5QSACuUEgArlBIAKyxPppSuqfpe+EOo2nhKmnX1yHel3NhMV5h5tn2uNKtf+N3SN5CRZtWXHpByk7LHw8zLXTOlWUtLteVD5VTsMy1ztdes/CDMXFR4TJp1sHeklBue1xNmKjLa96wkv1vKzSnsDDNjaw6xPAkAZ0IpAbBCKQGwQikBsEIpAbBCKQGwQikBsEIpAbBCKQGwUnC+38AnaeFN66V19e5HKsPM76ufll6za1Bbjv25cMK2KNMrzWrrKQ4zfQPa758vVWpbzI81LwszuX7t61VV2C7lHty2IszcVP9vadaXS98LM3/uulSa1danneAtzcQnbHedrpZmzS3RTvXu6In/CqyUJp07PCkBsEIpAbBCKQGwQikBsEIpAbBCKQGwQikBsEIpAbBCKQGwckHe6F563S+lN9128wlp3m3T/xVmFhTtlWb1J22j+0VhW/jVY3XSrHFF8b3vicVt0izVzo6qMHP8dLxpnlJKrZ3aRnT1yI4wc0PNVmlWS9+IMHMgF2/6p5TSpn3a5zSssC/MfK3uTWnWzhPa5ndbT1GY+duyDdzoBoAzoZQAWKGUAFihlABYoZQAWKGUAFihlABYoZQAWLE7h7t68h3hYmTBoxlp1h0TtEW0acOOhJl9vaOlWcPztRO2TcJi3sHWcmnW9Ze+FWaebFogzTrZUyjlCgviRcAjH46SZpVWaUuuVcWdYeaVtunSrPLs6TCzozVeEE0ppf4+7fu4Ymp8glddvt28r1bKXTX1fSnnhCclAFYoJQBWKCUAViglAFYoJQBWKCUAViglAFYoJQBWKCUAVs7ZOdxV+ddLL/Sfp2aHmatr483YlFKaV7JPyjXm4s3dZaWN0qyGXI2Ue775kjBTVRyff00ppfae+OxsZ/dwaVY20y/ljnaVhpmudu0cbtGInJSbWNkeZlaM0T6n3EA2zDT3lEmzlpbtHrLXfKNzqjTrZJ+2ef/k4oetTt0qeFICYIVSAmCFUgJghVICYIVSAmCFUgJghVICYIVSAmCFUgJgZUg2uq9YcU84pGOKtlH8xTs2hZl1o+Kb1CmltKNnmJR7qu1zYWbjm/OkWeOnHJdy37hoS5h558REadbfG2fFoTztcx7o1X5PTZtwNMysHKvdh358z3wpd8mY+JZ6SUGPNGvrkfhnO7GiXZo1qbhNyh06HW+IzyqL/4wppXRP/dMX3Ka2iiclAFYoJQBWKCUAViglAFYoJQBWKCUAViglAFYoJQBWCoZiyEsv3z2Ei1x3Dtmkne9/XtoYfO4fC8LMGO0Cb6qff0jKjS3oDDNNpyqkWfkH4sXU6k190qyDX9C+Eldf3hBmsnnaad1F1fuk3Nst8anh5sMV0qzFM/aEmfnl+6VZDzcslXI/rH8hzHzz4tc+tUuRKp6UAFihlABYoZQAWKGUAFihlABYoZQAWKGUAFihlABYoZQAWBmSc7jwt/DG9dIHXXZrkzRvTfXWs3o/H/Xo/iVSrvX18WEmN6VbmnXL5a+Fmc3H6qRZY4pOSLnHFz3ymd/WVvCkBMAKpQTACqUEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwAob3fhM+q1wv73hVLU064HLnmBTewjxpATACqUEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwArLkwCs8KQEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwAqlBMAKpQTACqUEwMp/AVtyQDj5gI7DAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#NDVI\n",
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(patch.data['NDVI'][15].squeeze());\n",
+    "plt.axis(False);\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "b869cbb1",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#NDVI Time Series from masked field\n",
+    "variable = 'NDVI'\n",
+    "#Subset the time series between doy 30 and 260 => useful for double logistic smoothing\n",
+    "curve_fit = preprocessing.CurveFitting(range_doy=(30, 260))\n",
+    "doy, _ = curve_fit.get_doy_period(patch)\n",
+    "\n",
+    "ts_mean = curve_fit.get_time_series_profile(patch,feature=variable, feature_mask = 'MASK').flatten()\n",
+    "fitted = curve_fit.execute(patch, feature=variable, feature_mask = 'MASK')\n",
+    "\n",
+    "plt.plot(doy, fitted,  label='Double logistic')\n",
+    "plt.plot(doy, ts_mean, label='Original')\n",
+    "plt.legend(loc='upper left')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "964d4703",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.37726922, 0.3147344 , 5.91591333, 0.20032278, 1.        ])"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Parameters from doubly logistic \n",
+    "#α1 is seasonal minimum greenness\n",
+    "#α2 is the seasonal amplitude\n",
+    "#α3 controls the green-up rate\n",
+    "#α4 is the green-up inflection point\n",
+    "#α5 controls the mid-growing season greenness trajectory.\n",
+    "\n",
+    "curve_fit.params[2:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "926583fd",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "datetime.datetime(2020, 5, 26, 11, 17, 45)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Peak of the season is at 15/05 \n",
+    "time_max_index = np.nanargmax(fitted)\n",
+    "patch.timestamp[time_max_index]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "8f80db4e",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#If oyu would like to save the data in .tif format (e.g. NDVI on the first date)\n",
+    "index_time = 0\n",
+    "date = str(patch.timestamp[index_time]).split(' ')[0]\n",
+    "\n",
+    "export = ExportToTiffTask(feature=(FeatureType.DATA, 'NDVI'),\n",
+    "                          folder=os.path.join('your_path_'+ date),\n",
+    "                          band_indices=[0],\n",
+    "                          date_indices=[index_time])\n",
+    "patch = export.execute(patch)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20388146",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## VHRS data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "04ac76a8",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#Define the time period\n",
+    "time_period_vhrs = ('2020-04-15', '2020-06-15')\n",
+    "#Define the workflow\n",
+    "download_workflow = vhrs.DownloadVHRSSentinelHub(shapefile=shapefile_input,\n",
+    "                                                 time_stamp = time_period_vhrs,\n",
+    "                                                 config = config,\n",
+    "                                                 maxCloudCoverage=10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff83a5e4",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "### Extract Planetscope data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "974b486e",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "You can retrieve order id and collection ID on your SH account (https://apps.sentinel-hub.com/dashboard/#/tpdi) \n",
+    "\n",
+    "Instead of doing a request again, you can go directly on *download_workflow.get_data* using the following ids :\n",
+    "\n",
+    "**order_id** = '2f900fad-1f5e-4a46-b6da-327012d400e1'\n",
+    "\n",
+    "**collection_id** = '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "4cb2e048",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#Define the provider as follows for Planetscope\n",
+    "provider_planet = ('PLANET', 'PSScene4Band')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "id": "f8246811",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"c7d9ea4c-c797-40d4-9566-586774d82016\",\"exp\":1659969220,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"9d2e0eda-1a03-4aee-9887-c728a31947f3\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n",
+      "353e6fee-76d2-40e9-82d8-da90b13f9c13\n",
+      "1.4870982763449545\n",
+      "CREATED\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n",
+    "order_id, results = download_workflow.execute_query(provider_planet, name_query='Example Planet')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "id": "8c19d2aa",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "24"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#You can access to all the meta data in results.\n",
+    "len(results['features'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "id": "f435d2ad",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RUNNING\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Check the status of the order. Image will not be available \n",
+    "collection_id = download_workflow.confirm_order(order_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "0bac7cab",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "b'{\"sub\":\"6c2887da-a213-462e-a10c-fcb94e066dc9\",\"aud\":\"07ae5fb1-ea68-4da0-9574-ea6978ead834\",\"jti\":\"c385bb4c-343a-4069-ae91-5ebba7dd84b4\",\"exp\":1659969261,\"name\":\" \",\"email\":\"johann.desloires@inrae.fr\",\"given_name\":\"\",\"family_name\":\"\",\"sid\":\"87f697e7-2e19-4479-98e1-850b7a8a9ada\",\"org\":\"3d31397f-770a-4f98-9358-84e918491745\",\"did\":1,\"aid\":\"8f176e67-7f79-41d7-afae-901872621c07\",\"d\":{\"1\":{\"ra\":{\"rag\":7},\"t\":14001}},\"active\":true}'\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'RUNNING'"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. \n",
+    "#The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n",
+    "download_workflow.check_status(order_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "52ab8a3f",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#order_id = '2f900fad-1f5e-4a46-b6da-327012d400e1'\n",
+    "#collection_id = '79a1a2a9-ccf8-4e1f-8f42-9d854bf1dca9'\n",
+    "eopatch_planet = download_workflow.get_data(order_id = order_id,\n",
+    "                                            collection_id = collection_id,\n",
+    "                                            provider = provider_planet,\n",
+    "                                            resolution = 3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "b31542be",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#Reset the download_workflow if you would like to launch new orders. It is a way to prevent to download multiple times the same image and consume credits.\n",
+    "download_workflow.reset_workflow()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "6d9f1d04",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASUAAADqCAYAAADkrlOiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABShElEQVR4nO2925ItSXId5n76zEiPRPdw+jIyEqe7QcoEUaTJZMb//wM9ykSAM0MzkpgGiMEHCOV6yLgsd18emXvX5VTVCTer2pmRkXH3Fcs9IyPVzGTLli1bXot8+NwF2LJlyxaUDUpbtmx5VbJBacuWLa9KNiht2bLlVckGpS1btrwq2aC0ZcuWVyUfVxdVda8X2PLm5ed/81tRURER+U//758+c2m2iIiYmVbXlqC0Zct7EBMRE5NSC7a8KtmgtOXdy0NbILx5/9sQXa3o3ubblrcq/+rnfymqIiptCJuIHj8inTOl0W3jv4nIf/nbf3iBkn6Zss23LV+cmIhImHDn6Xqu3TPx55UNSlvepZgd4KJqk/qgsHkaJu8NTJ9Ptvm25d3I7376rYhzaAMaUVNNJziN65pizV9LDAyT/bvf/+N9Bf8CZZtvW74o8Z4h8cgyVCH7lRQDDEJQfUZ4Byif3JbHywalLe9GLNppJvnYARP3OekALBNRQBtTOU1/y6Nlm29b3rR8/9NvDhAZjGUyHasARNtfGPs42rXTI9VBjgypkVnCIWO/IdLf/3GbeCLbfNvyziWDD56v7KvAfNylg1KZp1Y+GzgoXFL+2pZLskFpyxsXS1pvNDxSpZwMOslNdK5xEhFrphuyJWpl0LLQS1sK2ebbljcnP/z0jYhw88jgf3cxgc9aRERUFUjSBC8Nr6J0WLJp7y1AqedMn/3NsgY81PZPDc5Bfvnjn+U9yjbftrw/IY/4Kx8Pu5VrBJpzGu63ATsDYNhqA8VyELPPQmjLsi7TlycblLa8PemsojuzNQJQB4ZKza2ZZzPONArwaVvM06aLyqa7qpdBpIXh0z2b4OYeADLEVADCL/iDHtt82/Im5Hc/f3PoqQOKyUoMgACd0MNKgHWSw2bq/8eT/7CTgA0sku70HkDUl4ybiHV2NBKDjIZ16JnXMNeiWQl1K0Xdz0jnT394O6beNt+2vHmZrGQGeHzKSrzerASYUY/WQYE4q0wmCLkU4sJKXeOJSGBJwKzWJlx/GuiL7gvzPmSD0pY3Id3B7MAJKJH360ihpP1mzdqv/td6HEN25H9nihpLQEWZadjL2vNKqGSDfKGpqlDG9+aL2ubbllcrP/z8DfhupoPZmWf9gIq6Q0UkGCZQ9ymBKQX+IjETexiHviyQswMl5p/qT/Dijb0o0fRD1HV2H94KZQ91nhYkaZsW/+9+//nMvW2+bXmbgiAQ9DM+jc+qN7VdxbxuKseN/lZJ8m/DL64YD7kBWFY0jAk8zXMYyoHWQjwm0S+WAml7vR7ZoLTl1crBTIALWQSlZEcVfpYDMpAJMWcx3jJTVrG+/YlfMQBmlQsKEpgLpM68YP0nerR4aeGy8uudTbn20hNU+8yyzbctr0rGwsjhv/Fv409Q8oDk1dY/ajsMJ/OP/TsoucdfMtcNATr1J20GBcsm5HHiFSYaVSDg3ppgESONyvpUoukpHWc0JeGsQV40iMNL3/1mf/rD0723t823LW9I9ACi7LTJzuRrriTJthtEwZ0ATAB85uWSuQwsCV7yk2KZi7qa9+O1SfFUIIkBUtm2Y6mzVNOFikK+gGxQ2vKqxK1FCg5nmcHu10tgJwoKrMyUQtalEDZzMxe41s4ES0S507O6gSUzvIK34Q8P5mcFixUAlRYSmKnjIWU0lZ9Ztvm25bPL7378ZpgI3USyzowGU2Gg5JlBNN1QcaMSx7SmaHCiZ1DKzKKAkNJmC8DaqmFB3RiZwiduxy9hTgiuOXdfh1hCA/cUUDsG5+of+4mIyJ9+/z+KlGM+23zb8gZkvl0m07kcj50LuscGnhD05NSla/GQOJtTnEo0+Jtx1wEssSWn+Lg+brBYs/Z70CSEHQcYGgDJAVrxfmBhFQ+MtNk2KgpZ+OWpT/VlvQ1KWz67mNvR0WmR4KsdSyGmmfpLxGwLOcbzKowGTEBSDEG6M7T98JsN/AHk6U2hAFsITP11mCMZ7zyjoAAg108R/I9igU8NbkMuowmpMnuqljHcKhuUtnwW+eGn36CDw7OUZxbnyHaB1xzDIiITM7xqMgf0iB7p0eXCZkC9mZN0P5FPNuXjIl9K1n97+LtPX5dUVT9cK+oGpS2fScCUIApj8dF7dwR3JQ2aX5lsQCxKRczeqna2RCP0XWkApUnNusH2MCmQtzihPh0sR1rwMrErAfWmVzDFPUlgERNAaoYaTBqp8Ry5IvYf1g+fbl5A0w1KWz6LdJIxH3zNDdTS6m28UfMJelhO/UnBP4RKxZWUJQg5OkBSBw9YquP7c41XIBE58ZG79DDQMFZVTgImV8U5vBbMCYNLXETv+blsUNryYvLDT9+UOhLXJZ0BxKVJlzCSnGx5oRQEpBnmWU0ytw5MOvDkKazUC8BGnWMpvAfUrVleibddZEJnskFpy4vJtAYsgc94DSJM7sSf3C6cK1F6shQmfOpbcolMLUtOXfWhfvlBXFltqSzGwNK8Tjtm5MoVkS+0RUI9/7CgbFN3NaJNIDvWCZS5tkgY78y4a5i1QWnLi4q1V+2niTYHs+Fvl2G/hNGufZxzZUj5Xgxle1b6Y/WYoMFkUxGyfEcQERNYknxKylUIc/kc+dRotHJnuydpJ2AyJpQKnODmKyRxg9KWZ5UffvqNxNUx5UdAKhdI2tj6kMhHSh9SYcLJOngpkTndke1p6o+RCvhSnLOsq75qBxOHdF5gadzQGBuUtjyrzKdo7Tc99SH7JAkZ3yf03zmPxT+mLoGOpzSeP+Ur/slXsPBS0tQMPV0XsAZaVv+xzHKFREuzuGZlugITa0wX+6ZXT8ktJuTJYZYNSlueXUxAUcdb/37kzjgquEAP4SUpaNTv5uOYRpIWwBBWWjMHbXOGuIWXDpBmqRSYXHy/NzqtJm5oU+qJFnpFY0c9Y3nZ6y8XJQItOY5MJ+alAnhLzLUO9FdWfW9Q2vLk8sOP8F02OKCzM4ZoJjAaqT/z8Z6ZZSbJsZz8VmWpzoT5pfI5AvPNyWtoghUTe4Qs/UaPTHt23XlKG5S2PIs4diRzKB50n5tGJpzeu22Q8DjeLDKQzRuNcpdWdfNMm93miwZqVvhh3EvEnR0N28ZaHjpexHWuMwRKxz7I+2sGN1yoZ4xSsqPVjZYvnbmNGCFlskFpy5MLdWQDVfEW10QZ9jERnF21oRYz59BVMwDwMhDNm53SDC1yOYGTGzIA8w1vl3SuLY1e82jggK8KUbhfgF9fPXzsr+n/s4rKtMTPsrvQJxuUtjyJ/PDjb0RE0j4999B+5zDFsPC8rfC93iEEkFpAwiQpZnwILAlFBKh7ilmYq9UTTYYRLomLpqtZbKPaOc7k7//zn69FlA1KW55Kwk7+zmSzqa1zaHeeAECTFIu4RZM2BS1134NbGCrNzKt0SjEeEcf3TD1TW7AlntfCgGr+sJF8Aj90mJUZpJQjuLMU1q/7IHttKT4RKdugtOXJJPlxRuChOF43EZi6ydLCmv2CYOWMtnFr9ulEQKLG0Ugq+rfyHtekuEn6E7QOuKd+rDto0rxFgY3ib1HyC0Axax1QiOTvF5diW7JK3YdSG5S2PEp+9+NviJKw0+QBIeMYVA/0hD4qV/HKXzibr7tXc/qsdE59AfGMxrqxBMlTfIZeC6TE9EL+yQTruVUee5LHLa16a+tvUNryKDHBdUFzJo1fsnUmDZgfqId08CrcMO7rM/S0l+IWtpC7aMhJnT1EZn3IK9cX69Lz1wlMwV6rnO0aYCxclN6SGiLELXOd+RvKHq0qTCstEbUa4myU5na4VSkmlYVsUNryOCH+kwFPzhrQOYbdWA70QL3COm+zeqWh+l4Sh6BArbBZXaYWq1aP3zPvCw6XJcfREL9Xj9UtmZ8+YMRJzTmq0iHXRj4x7/K1H1k0Z4qZfWGiJioXd3YD2aC05Wb5Xds18tBr4EkASE6APeT5FkKWDh0mERFXdyq5AD4ljdGib2yuRr6sqH1V+CpqvFjQFVtcZOkvc17m8UTiAPE22aC05Wax8N8tksRPIaXHUMCKxiU/ZFfg5JlEZCcxFWZa9H20QVnYeyRx0gdzEM0dT45mI/TN3hwFaVsHDBOKIgnkbxANQcSZQpbaC0FYDaNzJLIQSjcVGABzDbb6YtOe6+LxAZUNSlvuELI/kBu0+DFJZBhd04hixWA02wagFUoRgjWV5wilLqMTP1Llqlqab/gduXHovT+ZK4ZzAKZxD3Me9Ufz62rUsIDmKDVNseVbKpFdFvW6lSF12aC05ZL88PM3JeUH/HG/SzIjfRZloT6D7PlZJzwvTca09B2JiVXO2Evk4IRFLOjf0gXGwggw3f4VkWmGJqZ0XrKUTj5ThleXZYPSlmtiYTaF39WTNu709SHT9zBHcAaJUICijExp8UdE06eJmFlZmjRcg33GQJQA+1xU+lSubzHAvempemiaHd+D68cBLAZmqq9DmE3qlgXQdWY4a/K4Z/ntqLRBact1Qd8RnB+HlgAprEvEn3Hc52z/2PiGgZwUDJNR/PESXUmVZVgtz7bJNtRdp9l4WrjC1epjdONUHdBRdoLXCFYe+fSw4NC/UMaYi4mMZ2wISPfKBqUtpYwtSMbkbdQ085R/Pd9WIWnGtfLkmnTQCYm67XNPLLbMZiJNKjS+KEsKO61WZJT8l2URgfKMrbLypfVYPWFLUecvM1VvxKcNSltKmWMSdodEs02Q9pvXBBOHCNWMju5fo2o2Z/KV78RDhML/HhQf6Md37notbNRvXM60kJQ453noZ/aRuQjJ3A33h/i9DZLTnLa1J1w4eXh2ZKMBKQxC4yLm8P0aoCjaiN0GpS1PLZE5ICCFGPOYMgGdigaj28QrmQT4wFzmwsMLIz26jvglSJ/wiQRIMU4GA0YWJCSzCCrymcjgW4qDUZ1B/LLJ7K8zNjXq5/r23FC7leduUNri5PtmsokAA4IfRCY/2CYDqXhLdIiyu+cZjnxvIDpkAwzsBxUeJAYRAadfM/+bis18R6XfylKBimzJvXiK/jHeoqOOxGQzEnIKFhWoWw5PQDzY1MJOLmSD0pYkzCE63i/rLIlprPqDoUBOL9M76SelYIysn8HXZnFB5EmKHBWM1HthVxHF9MctUreAQlLnG9DBo340nUQdMEUU9k/WAhR1DFdz/qK6KLNNufmtrhj5zpnHLbJBaYt8/+lrYf4DvwBSmv8DfS5daeK9FSfyfhylJkMlea4PxaWSiE3COkh3VINzQO9DmunjLzuLcmVHzNiMznQqAAmKmfMqzDPWnjMH3GVTwlE8WYTdKBuUtgzJTtH4tC3QAwSwwrdAAYmO7AkOOZ1sjxS7mbRfkkrYhS2v+MZTf01deM5vJXd9LCAk7iHhoi/tkustt4EHWf/fd9sJM73dahuyQWkLAE6fH4E9mAWToF/vpgkqCvHxSDivplqTsKWJ88bmO2KYt5ZGgnMR5vRBWbdDgxgrW2nBzcyS7jkM5fVI+cSKCIBB4V+yEN9lgfeYSH/6mHE3ADDmoXBsOTzlo5NJDiJ966M32aD0xcp3f/n1OGbuz2GuhViJLY1LzJCxFHJNYBnAFaaBWVf2CD+dABKY37VMs3mzzoxH6vtDeUbUCuMwq4R6AjaF04sKrwXFnkVaacLQfnLbCNigtOWQaJ656Z74c/C5cDV52rXBHLN8lHjy5ewnXwtP6YZb2TtVlllUb85bX/dztcCOIbajgh0RCpQw6Py52qR4GuzLaL4t+y+wJNp0d/TpBqUvXPxrFIeSebU9ezqDf+Tyk8iKfSXtFdTyaZIBULCvOUavGMEVXp0BIzk4fVlzZl+1qSlzpuc6TgPUEqP1aXO2OrhReNowQYnXnraB8lVrPsXrskHpC5Lv/nVbgwQfPxySmBIXZ2oM8+3J0OdcTMITqIs39VssaKDFeCXcnaX+eEmMaW2Z9siB+5Vnvj7Bl2Vxarn49hqzr8vCXpMNSl+ikJmafcyxH2d/BVysh/qIUg/uyrTiaR1hyiOAQvej7F6ysBq53YeVv2K/+ULXUaMp6fIM6aiEL+HWaY5bI9MbzJAjgkt+sMVpymHh7ptmQpp3ygalL1AY1bb0H8JRiQg7OnvAspo0K3a2crrOsKlQkRdk9gB1c9Yg0D73HbhzcGLMZG3qktOep8mxU0IHqCLnqp5uuxPt1/KEcQCzBnCaHiTFBkIWREy8aLSluttM+RbZoPTO5ftP3zi6U9v+Unw/bSoyW6/jJuabJ8hrHJ8CktvGlqRq8zeZGIoR870aQpRA1WlCRK7C3PjayoW0ePYIydkfd6nD2Kxwr0l2430blL4QcYwB+P9cG2QUuPK4nWCgMLbnmI2MoTtaryPWMubSZBO+WBHNsxPlcsmTgiAIe27AE2aGkDej1GFmJ23Rbebb82B1B+j66SOTWmuwWq9Gd9hK2tclGMYI92cV+VyUDUpfjDSwMBF7aMeD5mOMLjriM8vjUJpIzg3uYcbNqmxsRvdgNnLTHI9u1gj4qxbqE3AqitvVMYJDuzfDELSE+vxzDDiHKnGTbbaPe70nP6nwzSM9CACpm4YMcCOiFWhStXVKLx1ckw1K71COd9m6sM9ol6dc7NZxdQ/PP9SH51Mg40n20QRVEqdIvZShtyUwrQU9OD1kBUiXUy0KcX+ad5XiSfLboPSOJfmMZELUUpEKJ3b6SCRNJSLYaqiqMDXFq+7YObBm6mmP8CK3dZ2hPGkPb+kWk4tPwV7xYmR5/iifQ0WS6db/d5s19CQyP+eTmtcryJ9RDT7dbfk6kdkm3VgMLGzBuCrZoPQOJZpcY/AW/gB/Mh01AwMUr3QbYTqA0d8RfUnxzCtnNfD9FzoOQIIUNPG/oUylKmF2htWaqu2gEdsPjyP9igIm1Hz+FWsXzLWBA2gIz0LaDPTf1YvGIyY2yqG5KXIVoTrMNvORZzNqKgNmcs+ukyIblN6N/PDpm8Ya/GzrZ1kiFywjxIN+09pxfWbQxKl0Eb8sTM+HlKN6ehWyumRuVBHusVAvpp8mi7M466g0v3vNrEAAizyO9v/lb//xrjw2KL0TQTOmn49P55iUEyBOxZHxj1McyNr5BZ9nQ0pFYdGk6PEtKAzhGFQ5rc3Y59kjJjkrS6xeJR7btBU/xQzK3j1kHs9JzQwPfRsadJpnt/Afm67br8rflBO3Y0KsZD0zMbBDV4C/D+p1p2xQeieSn4hceWnkgiTHDjmON7CxKn0LlGK0K367jGcVDcKugzdVtCNTvNmCWWP9dVu2I2Xw8BAEmCDBDLiq+XqOrljtFyaYFrU/PVUVkQcwjKeFPQAqGHoh31ZLVSGRIVbLFwroAOseW43IBqU3LN//+E3zM/SQyqNTh90WqY/Yk8G3tMhW98ONGKVK66lMqIuy3LCN6XMHhhy1zoMck+5d3Bl9SjP0vBmdQ6wsV3yhuWFfkPsBaoPSG5YIRv1/Di88nT61dq3/BPAARuMDz8y2GWeug2nnEP+Y1W0yFjRrxpvss542djTIeTLYS2RGsQRBgyEdd9zKZfP2In3194gQcMogwh4TlHuFm0xmufKhFdhAmZNNXsj5Hc9iJOhe3rt/xtig9NYFvypiRge2U9NARizoxnGITgr19/YUQbsVHvd5X81p4Z1PKakATsFN+fIq6tslYTL5ZhriugMnp4UukZzPiKeJNbm+Me8TO3Co2A4E/HH9ggfaS1z2KWiz+8K4CGDSpQLUskHpjcn3P37jfA5TXtiWuTffNmj9mK3SYLGmJtCVxZDHeYqSCVJQtMuyVMT100r6vTl2HKJ1n9FxQhKOpHYlJvXL/dQ0M37psYgkG5TepnRU6rN4V9IYBaVPY+cTPLNkJhAOc6TILY1spGJgxkX2FgpTKeJ0lseKzHzcM68OgKFOmvL0DmZPJ+E+YcL9OKl86X2Vqs8s/e/ZeACNDA/aL5qWJuMlZouoa+HXJ5Vk5BVMTmfDbqb05YglemCCQ6P8gGIhkSWs4k2lNcmgQOKXM2yfZRkwRUX1FyJwrEsxGQqaUsl8G4zDUrArm7vsF3iO0EgUWJu6OPGLteInm6Hoixdq41GIaK0zuvnoasppd8rE5QBDcH7E4BS5L8sGpTcg3//49XLs8OCKsfTj1chZ2D/PYSYC0VhJxY3uyOpUaNqpWR6pfRUI1iUgeWv4f1//OJDySS9LEHP75fd/vit/lA1Kb0VwNl0eX3AMDPPpjsxvEGQS/TUQx1uUOJ1bdmtTtP1UPqXBCDRXm/lvOkty5kth4rCCsPwju3KEz5I/bJhqxISqGJJ/etkjK+zSMD8qkF8IsZRdJa6PmhWK/vbj4Z8+2a7IG5TegsAI9mYaqFk/H0oQRtKtWQZTay2VjdJ+rZs60dngNRBf7jwzy2Luj4NY782ZpWxLDm5sPnSZIQPpwBOBqDK9s6uNfGQJwEhbGtr3xS1M4jUaaWyEWQa0JnGoyWKCuUM2KL1S6e+yITCUyvQMFtU1eewonHBiLsyHELKRJUQ6c+ucSlfMJ21bMrlcvnddi8f1RNV4wW8WuubJm6fJBqXXKog3offtAu02ouZjqqvsIVaAKn2ytsfdZxKmfq42nh1MfsKue09YuACOqVm0+U7b2HtaAxxo43AWLovIyh5Zv5Dcy2JYrFhqiMtDz87ZDgDJyY3jwM1hvH/1Qz+ARwTEyT7id9NXl811k2xQeqXihkxbNGjxwk1E6YhVQIMU6p5TIBy9ZDJA9xE3MhcS4keKoCMTQCC/UauJMe54GLiKdz2kfKxvSzvuD46TdpBNqllEjQiEaUBwZRS7T7AtOhX9cqNUBJxiG7r2JZ2mw2Q70qPmGA1raL5B6X2K2+i/f58txCG4BGe3s54zufduZ0L1wb5MrSp/vwzXrypMWTL2CSZIAlH0Uoqo3XJjowWYvrnBF+3G0npKm0tF/vvf/o8nTHCD0uuTMLPO2VX9Bl/VlAr2ByoY7lrhhi+xgvBJzYTFiz4Nl74WkfqpgR72NUVtR+rOGpICtesGT3v0AIUD96D+AwixAGvbN63zcnnQanBTbpCkAFZHFYoMi7VP6bieeBzcRozDg6qecvTL0jxFRvdE7Ahlg9IrFHxc3K15t/npBY7PTCkMV3c7mEXWfAOIMiPTpmmLxyzehAEbYUng+vc2mmKph0EKTk6JNGdBAYli3HxQlS5Of0nMNiotP5t95kG+ujPVmgiJzzq1otPsGKrp/HFo0mu+bV3O+2WD0iuQ7z59M5Boxbafwow6u3opjxNg8mlXvoYbh/aJSZQBaZXbWdlEnKP3JNMI8GW+93TghWaeUJYB6Wy7lXwIwLggyH/3N/ftKnlFNii9CpmwYzi8TMTUr5UZg8wmXV+m61wwfujFEuSwSPP7uYp3AhMmpDNPb5BKePcKIbfVPSnDnNJTcEeE8DQwAfkgIDpMvM7ORovDroka72v1IdUcTeIYpeT2nNHIldjOLLNk3GG7E5MNwQkLAAHquu6gjao2Pz7QmXOow3PKBqVXIgYK6z4ebdFHkBlG+gBsZPg+9pwIkZInNwPxOwzkQt4v06oToXriLLpoPzhrD26AaCXR6vjCbS8IUaeUaS/GZBrq6nRdLpek+jr3tos3WjrIl9039jzoURK5wD0dDZdlNGUoo+vKZ0alD+dRtjy70BFllL1EYTP38qbKtNH6erqfxKG3QdxVkVZwUmZSPJlkKXnGZznCSqiJc5Zn77nYg3NZh2MnWvd09/MUzd5T8AdsMpGQ5wXh7Nmn9ByymdIrkKPzOztAZVvz72RiJMF1NX76m+O35zSfZs3ZOFIwcoLMqHSGtpyi0hSMLq25TF/izTdZMzf4R39Usina67e2TXrOLG9XndhVEfuSdvtPbOPJYCMJhDUkPscCx1wTCW2e5h4HurEDjzxdGb299yyyQekVSDBoxniIM5UWx+zchQXOjePUg9M0C0pg6uEOwEjGQUmzw5XAFjM1MROCITPYksXZv3TSqYmJ9h13ff0Klkj3T0vzRJw+lDcZAEf8pt0IL3CSdjxFwlBQCOM4MpcgOJNbsRhQoKL9n1o2KH0m+fbTX7RxMzu8UH8+xpUNfhIzOHjqFwZySmSLIcmsgXCIQnFvkq4AjFUV0ZfRKMNoZyZ3viLBasf3DV8JI6B1fpX9vQigM9tVe/3lZYPSZxTn0B5HKv1DbX7i1HCvOAfsEa+EsLS3tPlAX4rFxEjZF/Fl9M//iAh3ovdkLN3aTnC6BrMFmALTtVh7RrIoqAJoaX/Xq5eDmE6OxVo89kyIlctFYJEK09YBq6OF88TIvUuwxqp18lgRvnVqTyIblD6bACBF++0is+DzJozwYux4k82XZYCAHgU7TJ6TkQ1YOJXz2nfnLB3wSH51trXdFCHKmfLlz/z6y7EsUbGTY923Ii9+tQULmI3ONAtla2PB4XLKn2ROBoYPwslQnbtxGrxt8WQ0aWl9nlY2KL2gfPfp6znPMoYwzmvGc2Hu9dHO4tABPcsX/R+3ZTCTpCelj+IsJ1DqU+RjLcr556nldC0rLsF9lfJULRY6thvLtrpeBHo/su0+F2UsupjB08gGpReU+HXVtKmZu67+phm1/SC7sRTFf8qaTf2Yns2tPcJlCI25pkj4Ph6x6OBESVjOcMAGtbsw0oI1pDvMp3mlIC4G/Ie+ARwHCyvwk8p5pPO6BQroQNMkv+5R1ReJYTfRCCLi8lGXIS4kTRk/LzJtUHphiQN3MidC9QdQeD9C+h4kOc1DGyGqohhZuS8ziZRLUGJ3ocFNSRsEdlQsMkJxn+6wWlHD/ROkSNJAFyibJUw3teow+xiYkw8YjPxJ/xgEa9xOV8t+yk3hAdnCJVYeB62bKb19+fbT1+h+KOWKB8a5VWJ4Sq/KJ95V51tN7JVEr8sp+yhMkvUGarcJ88dUqZfkqSAJZzWd6YaKLsyjVTnThOYCeIq+/ot2LS4Brp7GfSrZoPTM0h6kuYCBUXSpv9cg5/nAn5vBKc++CXScRiiNd/gcNN2Dn5eeG9fPQgwI7O2RBjqwpzP/yYq6xAJjUJEmr2nOD43S2K3z/rqNq03TLvBWtzwjgqGOEtVwrukA0nDzBKGHKjLeI1oA6lPJfs3kuQVZUrQs1o6XJG1MpHNVPuC50iwSJSOXmh3hfu9riRUlShraJJlzmut6j1xhenUevgQIRwwThw/PeNslS7X12bKOxMxag1fmqiwtldjtfMyVTHAzpbcn33762jOkC26OM7k6DsrhVdkF6FglfqRYikFKcHpP/qIqs2ILs3sHOQKfEWBO6Sb0PUlcfTbj3hCS+pdwH7CBqhd8U9tctA99cmc085o8TSr3yQalZxCnq8UUV64gJlZIet1BJ8moEimISr6x2TVM/WZIQcO67lmn/UWJVMZ330SyUo7Tlmbp20k5tNJhG9N29cCoIS4reeQcFhrt/AGUiqi5uvp6R34jBcFcz2iR3B7Vmk/UEmCx5/3m78ELPetLZvUTyQal55IzpgQz+9BvMvjyN+9jBJZxPiwHNgGoKoMUlfg4+tVk5Dh2NgOd0tIbQn0AwVb6MU1B9JGQ76bNkiyaqKSZF9hlA86m1bgI1E1axX2nUnxuXN1/lu4ErXPjLeZ5rWj3ygalJ5LvfvzavU7B8cDTIB6nclbi6Edng10aJOMJ+8125MXp0Y918aAS/CwKBaLZKb2dsZmyZPFi/1pJLF5Tywq/OYNqRwVWLVvLVulf6RwYKZpep6X5x6bAcwZnTAqS9yyyQemJJDlAO+iAmcP0cPgj0ozbWQRuURKNijbjMlutGDjd5ZPY+ESLcXhc76wHgTAk7yqaajjTBIYUzTQHW9hWGkGjpGcj3LGkC+YgI3ExP/P/kkQsnrxrmovVF13OgYFR6Pbju4VDCvSXjvMZm5amAtkXMOE2KD1Cvv30F/NkgQfNcmChIe4caU5J6XtXxcAl4xcVzQMOj4+loXnihaaotB6oCrj6meRzRFfPICNDujpDh6K6jGCSmNG7ci4MmYoyORDsP1VduSF1nET+pKkVUzKhIbW6AeobCW1VrbQ2iUV6Jtmg9ASyovt5Yqx6FGFojgit1jK51K6NEsfCUiAO11u03wMX26kATYz1JDtj4qZ38411SLczoKA8So6c3FI9Xyx+QUXSs322qEj5OPGvGhVghmWu7DARodsD1CUnCVyTZ8akDUqPkeiYdtt1LBg4GwqU/gdq7sGIDKZLo6V/Hy2HXxUHENMekPyIBoHIAwotq6NuvsHK0iVACrAEr6u4bHtZE8HsAQvTJsj8Zp24jox9OGI7dlnzKpcSTB7Io+bnyGMJw/7gVRV0lt0xQjZ+G+F9Zuttg9Kt8ttPX2c0kt6hoccIR06mFMbtE6/EiySvmwVUlpk2l+RsAzO0jU5Sp74Qr57LekbThRpKmTfFdOs8Fi/+JNu3alBSiwCCt/dl0a6wANWEl54+3V2VIXYnMX2fQzYo3SqkQ9wgP+mwqXxEYQpfQc7rNpZ0/uHEyAdKb0adb7BgRPlKGXYrS6sDdH44AFrtfG/cvnEfx3QmlIW+spHG6RqkQGtVJeMSHmB6x1YAnUdd0nE2vg73W37knz5P5fImmZnI3GmP91Vs2Vt31rxVNijdLEGBbYaz/h4Ho2fnHOk+d5gm22N0+Vk9DIZTzMiDR0XIG/jc1kRwOpggyx8rN5NLCxuSn2XBpuCSf4xftrCgEVJ+RhLoyTxkJtwFwSYcPiWv9aMaESQQdIvk07RlcDwiUANtsR1xtGE9JvkLmtZZotn4nLJB6YJ8++kbQV9AF3ZUh3hJ7EhwAPQRSxT3Tup8y1CKTClUW5xW35ivn7gt5TUjElRasQAx35iXxG6pShIPOJWBSG5avoojxbU4XbV06IMQDlaVOCZk/oARreeGpQ1Kl8ScZkYlrRWLpaUBkE5mdRwyDqQu2xiXBlE5YwfFJ3AlbrgqU6OQgyIYsJzVHU+XcK3w2gqrydmecm/c7hYousGcDZKMysh4LuR3NNesUzZZq7JNFhvdBiUkxs6DpqTM7xlkg9IVsTCIrVLPDhz5/i59WCFk5GHCygC8v0pcZLAFJVEY8DE3wgRdr+Aa1tL4nLt/g8z6jN0wMyIXpTWnTgum16VG8aSAWKfeW4msLMTDO5l4oCyW+ppGW+OczXHio0OHVf0GZxQ7qrFAoqnrrJeTDUqFfPfpm0Pt8HV/SvVhfYlT5Chhpmv/VgP+TGfSs7Bi7PBPJdGYl3Jd338edJeU0/TFVoK+u+VzSktAwv4z9zOOT75XEIt6en2UIoLhlYSujIGQJiFMzy4blArJX1Sd3ADfiK+NCQCzMblNE2emqCNFnxcvFSoHAyTNQaU4M1SB+yTTcZpbRe4kQ+UF0JEcL4+IFC+pzRBKFmJ+YY/ysQLT14XkHs4jpSFmccE4o5TGVsGukrS269hcjpESfLhJn8pSAFMP2U/fPpcMk42BTwwjirMMyDZMDXF9kHWPCgBFSjsPOs59SD4WlC8Bk1S5c5Mx+iYguTGocSMiDalqbl8NyZJqtx7LcGPQwliH3C1+IvFxJvB5k9sjRO5d8SwnZonVwAzBep5P7aFVMFu6dm41QoVe4yPQ5MNprKeTDUog/au1h1TdI+JnYYwbuv6mCWXJHVySV520CSSI4tAQxpRcouU0feMcWpiLdfKnmcUU3fFlM/ZifsS/M1nkpamARGi0iwDTYElX0iIjtOqbxzbLU8sGJZRIEkTCmo8baWu01qoMS4naORmD4Qi9mPpKKXlw3hdJm+LM1yquFYKbN5b1mppmMywTsMCKsL8u2MROWVWEpgzpUDZI5Zqqu1iYP8vzMnqsIzmWGZOO86qG/J/XchORDUpJDp3LxlTs5tX4mIqjcjymPsmvFP8sy3+fi5Vo/uAbL3UenDqtwNdzQq85WCT/1dV5o/80UJDQUDGPCEhV/eg57Uzfz5g7KiIrVQ3jxZVoqcLB6fIqzHIZ1+CIRT6dJV35/RsGUPpnBqYvHpS+/fS19BFT0v7iXsrmU+QjMCrYbXTZ351NhEcOlFQYmyPyQkHLmbywagfwUxQgp30KVw6Xs4VvMZlegcFyCjJrE9ylQwMuZHAl3xeWLx6URNjMiuBxffCWOkb2RUZXASvDzH1u1DodxJBKMDnGFRjA0UTA7TJqR0W/2VObik3kkvtwi0fVqI87RGIWQcf8WjFzO3+KCF0QX8NXyIsW8ZpTh1bNU95LcgYMdTI4ZjAtPw6XVTmdJJ5PvnhQ4jvwYavz0dTZypUZhbFf8F2OOHxwxFcxkPP3c8+kFO6N1Ul+A3zqpiEyq0c7KuutktDA4J9vQQRZAFg1/vZEyLUE8pG0TrMxxKYfNS++decXG10w2wqGOIKg61KUM9Bzk4pg44ZSRG4ubilFOaEA7qbxtKjXU8oXCUrf/fj1MbdCh8Yhu+JItzi8Y8z7+rPiVBdTO6MGVxIYYMOTn8pyxXSAOPQb5ERTyrMWVtSvAi6UhRVJ7qtj3NrMJSCdlOBKWJV0MgfD6SqtX/7wTxdyerx8kaBUz5nzKu/881EzzabZxQ5S4OQ2nAgzIJpgDRWq7cLSZnTI8xzWBUqVTEO/YyWf1JXXDynCYqUhM5n6XuWcWlg5ubCJpvdNgheS9Nyf3OfnbrrBbZPAL96bzFMiifzGWEc9V3VL3Xoqz0yNgnyhoKRtfOYBlwZCtoBqWg4nY0dAli4dyFnFjyQAaAwGnN22iYSDyA4axrevdR8zaJsFaQMHb5QFPo967+IFuAy22ZjFsV2oKQnMyjmQLOVLoSQ8iaC421qkYhTZdPLFokgSGYnVl3u7u2xW6BS6T+N/xXCM1C+EiSiUSW8E3qeQLwaUusmWmVGXakYkvRE66Zz+P9p+Shk/yRhZmGRF5GvR5CzqIi0Emsheiq64TagWj5P0nuC4zj/W2CNYtERp+udlmzsCrCSAetWcZXnmlsjnbv+Xly8GlMakxt62D5Oup0dH/JtBALKg8Jaoeh4YEX7cbEzMmHQO9bp1qw7HIBjQtMI4QkhKsSgwAXPz4T1xlr/vMH/ppLOqnTjduhxgQf7lmjpxZo2lfBYsyYf6yi6myHx3NWHChesvJef2fW75gkDJBJ80eeyJo928tg0g82bKoS/GlSYFaTOXxumCjNUKHM0Nr8C9nhjkH5Un6NIKBHpds/nm0lC41ZXIPAvTADiQ0gQkDxepXAXwOimULQZHBnbGdnG8lPHI9WrHGVe30KkeEy1NcGznAed3w8vhvcTXx4uyvGtQ+vbTvxCRTlGPozyUTrroET1o5QkW5cRgB7PgTLGyJVbwozLLSI3WDLFjfIQbn966Ac9N31guZLj3qdiqTmzSuMvCvZlagynowvJ1li0/54xwJTcX+xnkXYNSF5X+hOYYNfUg81Q1PaMJb2iLSOrFMm3HpjBd8HFF2nMGCuN/oGra+F4wHxNINiWKk3UyG1neJU1QQqWiN8bvol3BGZdJU615xrmhQ+7s9RuM0OqMkOQJ+UowJnhW8CqbOHbwaHal55CuXPE4UadTkEmtVZXpBenVuwalPI8GQIrbdSyFfNvrIieO898oS7LD5sBX4P75qZRLZqSNxCG+sDvqjTM5nXy7uTZtGmwlutiUoh0TaENhShXLcV28+ejbOvK+iSVtkrqQo46v915Tdp83xjaJQQhGlCUVQIQselyjQJlpdPW5JZLli8u7BKVv//IvHKspTZhbmv6KqXWPnEy26gLqYePY1pWVhCUg1eVKaTkQDLed+F8qjD2TW+aRMzPtHsW7/T5W89pAcwfG7oCUXHcpr3BnTKt2u2VufgF5l6AkIsiAB6CYRdOiEk0jIeHCclopACOmrzGRvL0qKUESN7DZjGhS1ht5ywVLxp8Tu7CblBlMQ/0kN+Vp1+iMZW59TbWslTOzSHDPwGsC7z3mJhdqcsKYzWuZ/ISh/mIuy7D2mIlL4vcD0gkG/19C3icowUhD34pv2GvDyClRH6FarXWKeUT+EMFO/VOT8OZ8Uqcx2gwUZeaVwONkHE2F6+WovpiGw7KZPB4TINFp2jEQGKZhCD+sIyvKDfn3ecWgxoQdrsBo1iIU1Gc3M4SaH8EeRisWiEc1KJifQHu/4lBA/xA89VC8Qd2PKwE1CiublbXvC8u7AaVv/3JuQXIIe0XAK3HNDc7NmHvp/yrNW6wnL48ZPJqV9jRzX3vWFmfmWvVEccoNpvKi+hWjSCuzF1nxvuaAVOR8bbwElCyLRSt1/hLUK7HOTuXdgNKxX/Hs+j5kbEATTAHjmpDRwrfOYNMtHWjpS7B++Pr/cXZnmSJX9zEKtyg9z/5Pv0DSm1teMXx5Wm1wv6VMAMMBmG4q8iEWhRSYmgyBGHm+EurlaqB5HQ+2B5i3IwZQioqNRut75pt7MgFMYLqdLfoAf19KI05iZECe++ASbwOm+Kip9255N6A0OkS9eREfi7t3vTTcixHFDwCNAfFWo6HkBk6HNGVcGwUiMn0q5nNCE6sogMsimgj9YvzOXS5H8BsNjQnl1qPNsalxqUUElLXJQCvbasupFxZpAl3qWcEaRyCQeEx2/Rzmb7iksNKxjxO1harjnAZgj6W84l9SE7dsgwxvjL6QlwemNw1K3/30TTvyvZzs83Rn6IqTNl91XAYkH8C+rLGEmwqQroyLQf3Ez3JhXF00im6TBj6rYurIm5fgpqF/NfLNn/Ku0rkngsHQvFzgo7urOW2kFaleyvlS2H2RnlfeNCjh+xNjJgBqhKzBJOomwoUfUG4edbMs5o0/jtTnY28P0CGlGt7XR4AZYZbyW+ChOAiAxU5x5+9YPi8wFVPGlGL7+pm011NseR/KqYpNygKZQEgyH890LfKhuKsB9DMhZKeTljgLMeRImLsL5RPSGv7nbY4hBboUu52X7+XljYNS+0nARDoEflFhvIS3xNMsay6/ZaFouFdZI1kgk8BBGVOdewiFuC6deeIMqKwDLQ0GHMlgoPcy3Rq/xccTepk90LaECuKRAYmWhkuyROKkxqn1WAoQtJiWYOQBKRam1Lw5oFEoYmp7RrcXwkbk6su9n5ssvTlQ+vbTXwiqWAII2qLX7OKaL0HCi2RcP1/o2TweVmbN9aGSUomD+HRAX2c1l6ItrpesKJLPEDEGEXK0yOyOh90ndVziRMW24WZHjItJ4x55FMBAI78kUL05UOrCsGhlh2c1myMg+jm0YEisZxxDodF8+gyINIbDoMTFkN4Vm024+LXrlOZiQuY83kb5WGzKlmiQ1zbGNboLLLLaeZEwhs4SQ0WjacyOeV8WFSjrFe9v15oN6bcHFlo/dTSYm2pIHtk4WXHzam51iWMR44yqq3dFn0feKCiRDbdATxnDZzssznCZSnyJecXA1ZymElbCVUaWOBW2o5YeeuAMzYTwdmz/3lzKxohFigL3OJ9GevkOVatOMJqQCN69/zxoMGD0QbMZQytm+yndW6VNr7GuKaxKkdkF7smayvEWgfi+RGiO66Ui4xutTsClfGJPVIMEL0TF9cY1Q+PJ5E2A0mGyiTxly3A4WMWu8r6tq0/DjKsUZRAq4jZEIlgZS37FzJhliHSL3cNTzIDky5DkFnP3Kewal22rQ9lQa/C9Hifm+4iqXLhxZT1cy/iFKVKTNwFK3nnQWRIQYOhhW/Y231xf3YCcodzz4MOOkjDzIsfrvxUFVzyBFCgg9ZyxKT5wHsaAScTPvnnHApopRJnT+vLJGgWkuWanyqLovnC+MqKKkJ6nxauBcfZGGww6DDLMegCzhcWK2MCBvQIbqfCBsaSZ03kdl/1YZOo1C259wongTN4GKKFALyINZtGiaPiv6VpQmou8lYEM0/GZJ+9hVNQZtsofOX7g+2ercRsOT//ZtO3y7IoNbj4fFyOoWFCmfjCflpLydWsRJIKxN9dYHDzP5m39cCQMrl6WpNxnsEAoKi0n2HzSRt3RKUtWGOfPOG4S3kZRVo158sLWWpJXC0rffvqaa+lCHm9gYUq5a06f2XAdS2Wg1tZqAJ+OEqb9J3KTtVFHPgNallJabpwiiKvzFcOpPB9jaMGqivZ9DDmIr8Gsu+XOnHozLhhnmRX86vB71be8JEi9WlBS6Q2OXdtpv83OwA650HLcuEHxxtK1zjhmuMp8y3mmKJnZs+NoXgTJQX2wMePtuG4FCHAjCLdW0YUutRQsz+qjBBquh2I4NnSDRsxtQE5pio8fPheuPf4FcIzr5GZ4S2AxOJMFis16siAJk/WjNmfn2hPMBMxCbbos4hi449MZd8urBSWRbFJljhqBI69zZfpNQcJiEA6IlVYc09VyrgHLinYtjijNtXLJuDiL4mk4IZ/wjp/XPht3GhgOHmVoDz45lr1KekjI1LDqBQ6cIvQpYoiciFpsC8h5hnp0mv0E4w6AVuGWq8DqAYndmEdaYmJFXmmIi0xUtGOM4DDxBt3LyasCpe9++saP0jBTZam4yVnMmEEcpDAgXP6ZzlzvrjmYKm42j89HcHxK7xTgJiHtLeeU3TEJntoy/JaiXo3L4pX3Jmd1uEETFPl4MQ/GwkIWuGLeJ8PeGrzVaGJ0reLOJJRmx78R/NzyqkAp7po4ZFgDOEsE+s9GPShYD4yDIb+yTRK6pKEiyblMFBaHn8EVI/FTmRyj0lHHObv67GmRV9YqKf6KhGG7WrgaZ+8rA3s1B3ErFlvwJOHGaI929rENhoF717G3LW1ghW8ISvnovVjMMQRf/5l5eU7j2wXqfNKouDBT+3jpqZIPC8Qpt7MkuPVF5FWB0pRMNFOjhJeJRtebjO0i4t2JV/VRkJSZdAGYGgnYyJkVcZKirl8HJzNoGJxXfDtX6VwmgnChF6hBa01BJH51NeIey64HBLzNcYmfZTmnpPAMSEe6gEbqrw+wsHmAH2KYTCk09GKfeMqzNR4sQJdMPlj0RAINyZ9Sd9XaKHk5E+6zg9K3ffuRyIFX0EyIg5fExYklvmpk3j24JsjDDNo8/dM/V2TBwkYddQzukT9O364aDKACMN1QtInXaT4vm4/O5utbUmm9AoUbjUXwuddBsXTeQKnKZyLga1mN0TCZnrU1Q5ClhIF/w10zi7AP/Ene//DHf7otsyeQzw5KiRIj7WmUux9Hd9My1aa4Oo4xLZ9IZjWzt6iOizhti7gwtLklNYe88ZKPJihGCT6yDQN51q/XhdyPU30EwRVYATCJiH8nMCi7nyCCSVNUy/X8SdxcNowYCm+sOqHSimeosiQthZ0M4hhkYwgoNXZXbxucU9Z1dQOI1gbLcKQb/FXDLrWZN5JnE7dh4GxRhQ3qXlZeAShNiWSpB6xIlLd+VrMnmmlIi5kWEErE+Ld1DlERZ0jKxFMtlyxCCYCnG70yXFaeRUA5WRndsVLmcJcAOEfGSrdAWQBTLM5V4kDNbLNlFavlUcccQsqNieAYtJlY6Qp2OMi+5GIj19DVEhuV5sDGvkusN2gHJOwPnddY4qlALyefBZS+//kb+GJtBJYpl1QmgIayUe5Orypin+YW4ESAYH4EkoCTxLjx/3osxGsa/pvQIoWCB9VwnyrKxR130TIt+MiK+S3kNDZT0kRVeUV8aYISd+a1mtfuFTbnLS5PQPJjY5luhacj8OKMICq//PEfqxxfRD4LKOUlM8dA6v85E+JdM4YgPiJoYIIUlSuQ5mM3LoGWWJvT3Jj3g9grysmAKq7aKDvCgh9QHZwcNxtFs7lguiuimw0hPRWPNjrTGUEFSrj9CxK7xYL5YI0BI7+QcYEOZ0TP3L1QRqxmIkII7zeAOgOFGM4DIDULGUPH9aAybRglJbIVZVGMdSNFfWb5rOZbn6AQksaVRJ8gLM008GUSvDySvG2qs5BOZMPH8aIHXYezDPhVhJ9YhiKLHA6MYGyeC9iaBjh723McexV3xWeFJ2GumUicW/QgfXq8yuekWKjMoZfHkVWoEDetWsq12nlux44KC6tC0Qo/q7VXr0xeDJS+//nrNqOjEvimidyCXa3konVRRPBmTDSLpm2keZAmhKwNqJklMS/wsLAiroRF5WST9qXtVFvFo+O3JK5kHmFO99sNulAmg99+cj4/FLkubjwZO6oy1tXlHo9IzNmVw5SAQO4Uxx9ywQsgP3yeaZLz2vbLH/+cE/tM8mKgpI3KIH3v3fUg05mdnIaRoaSEzwdWpQjT4uN7SLs8nUKokF4WHDI40Kp3z2ieyufx1XEtvYwBcAcDCupEv5Iw40RTOj0NbW2TTKxQ2KjMc+9NZMInjAQe1yWTzVXL39tzGlVlrCsUv6hGKE9R1j4QNPRqVATIjOJhkb7KtDZi3KOe/ovEjgXKMVJXpP9zyLOC0vc/fcMVaW3XONP6ilSWSUqajW1tneQSOTLvywpcov06GwVYitUAq4RN+hlXLirHSZSm+HQFF5LZfkdYLViZFqVpN9o3x5ifJmA9WabqY4z6oISzvhISu5QwvJT3ABZx7bVmSCzovHPKmjN9OG2W+L09X4q/+8wO7UpeiClNsNElLBdIVAKUugHvUo6zOkuTnOCqV3duPgI+PQQu4bK4BZAy7RbPmm4A6ZxmR7tAOR3e8n6J2eJizghOI5ClBdp1+mXgY6Dwq6FABkc511kWBcR3U8jKbFoeLQAJ8yn2Fz+nXjK67Vh+QHNK8ecPAU8yd75GeXZQcm3vzDNGc4/w85cA1R+lyEZOYyQYpBMBRnp5S4nO94VcFFFcr0PzS0VPQdrSdq8D9AgdBygQ5HQjyTsS1RTdYTBJeHbL7BXrzKk3SdH+fl1MLqwvY1R3VsumaKSsfp2fucRTXQtJH+jugzdMVKuUQjODG0gFFwLjD0+IHtYlxjLie22K71qC2XZO2j6bPDkofffj8dqI4mA75fRRLtCCaEf32zD5Yh6PUR0gibiVy31V69x3SF3enF5XZa/rlOfTCUi0NWJFaHMGaqAhSlRsBzI+V4u/Ll/o4/j2pmERSE1OGYOz/YAPVWPExlWUCNKpdqVpFNugZpRlKGZG64s8208cpeoUma+a0kTkH/7wOk02lCcHJUcXRdwj6hjv0lavPXbooerVJ9aRbDAdZcIBMNUGBzBbhzvT7PQa7QlGN2wWzqWU044Tc1TBTso9W0gQOyifG+LQEQh441qP2dLGZRrLzRRKmwbYVEtLXRw2s+Q6GQkrhX4eK99n/p8rkqm5Tri0eYfmE9IrrBRlmB+3sy+W72C3O/06t9Mp/lXJs4DSPJjNmoiL+nvKcY2RxyZUPKGusDUw4V2eZw9Qauz3UJ6p1Gnb0aG4nkOkAWwiKg++EG7a9uXXXpY48A70O/BjWCeNOcDG9Q7mQLF8OOQJZcJ+6tt5YLk7oLg6RwpF2FUvq7QSnq2aEAk7YqaUr4t2JtcSC1Pd8dsqbVB5S40fCoNnNG6O7zJe7CDgAxFU0YSewRHo4zIAH/H1y5OA0m9/bvtpw4ujrv4VedCpBGeSBkDYKbCYCxPg9dhkzI/zMQRURfFjkEBXlAASq8f8BAGyqT5o1uVwB4HJDHZWDLRKNZJ6qR/UyMh6yT1X4KBfMRKROLP3BoRTktKt4sBmmNjQLwW78P4//C1aMM9uxXmFAL5Md3OYUsGwBw/5+zdgsqE8IVPynTA4UliGizByW3cELhU0w6SbHf5CHvudWs89Zfg82O6La3eQTpzO+H3eYgqbKT4dz1X6MPnNb93nAk2AFYhD4Nzdmly+bvJIEwlO27H8+TS0RgHLpDNcEUdf55GUlk807zNtStKHp+MyvomPdzmwCWNnsJc5VV7WgaI9+pHf1uZty5OAkrYFc66Bw0kEBxt02RsdEfN9KmHwDUcHMLTOvnC0DSY74UdNYDc+g20aFMaSNzUUBldFvjsE+eoHRsTQ58oMiwpUYkCjcQJrVPoCulY1Z77JaIIA3BOMpsmAOzbgDToVIq2M59VCXHf1O9EqnqbOPnKX6xkngsExjPokqtDOsXV5+Wi4a1Mc+fFmMsOOeOqKEN+JzO13M9y9OrkblL77q+MpW1xDUckaxONnuKPm8QwGO4Io9Wy44kNYQCipNsAcY9uNsitEKcU0kfHoP8epi8ei1XnzabUDkoamHmktEk3BiSndI2yBSM0qlxndwBByKicVP5kwUmhZTDuLMBKcPrVegNgucb2Xr8Pn2JztqeQRTGmyjHbWpG7wdVfADGs5DPNg+nBMNlxTmAE1CT0witj/joH7Oc9CfjNsps9XCmsxtv3OTmd6TjdzmznM48aSHFM6ycN9975gUFNzFG8UZGoh0Vy4EXc1aQVFjBZRK2TZGjS+uzUUM6SEgMSxfiH3onV87QkHZJHrYJl2f7avRB5tvk28xk1HyiWSQyqCFYFjMiBbjABPiSMnQhKk4YK2J3oOmFJJw7ma9G/PuXoETPSEBHccDCaB1uOI8cfqOgZMRqTjiWLPq0zTfF0SEAsqrUNsn/dqi4OFwvQUT4hJvhTjgQXm+EQCIB/ANqY4bvrgMWlFal1mvqX92snQfsOEixNrnEI8OB1djP2kQgbxm5KbQOn7f/svj8Eaes8Tx8ic8Ox5Gmt0HUwUbMAo3BCVc1yv2LLNHwaoNZGOIdVMLH6Mij82esNZeyI8o9nG7+uTC9YPWdPNQhfUnPNl7R10JtWwAvQIsOOPep+W91d5nnPN4z+7bmyArKhiXQxXHpO//8OfryfwiuUmUHJfmTBxj8hnI8M0Aop8BLHecHf5E+iouME7Y0YuezLQjIXHRCJtborl9g73WjvHWZk2ABK2YZwoJTdnDUjzfKlDOKvHBnBAaxgEIcEkWNC1kjncPHPnlI72UjiH8oKjGN9JdMUIpvZ1QGpt7CarC/WhIINUlLRWmreuUkW7CdBeu9xmvmmDhjx9By2zERbJKCIO6uo4DGn6L3Yemfrsc+8jawqHI/78L5Oah8flZnKs7u3scAxkE3lApp5nTqc0M2nKjHypGgWHco/UIRtUT1p3cGhHx7bHU3zK1sPjDo+zXxlPmzrENMNcJRIG0BfZYn1me2BeczS0NguTIIKPO7SYI0EQLMNNmGpxFUwPTTmGbHx+YWywiFew6y3KfT6lpC3xuoYRUTCkOPhYVJZHImMmwnYfINk6MGJlicmkQR1G9MmAVSFFKwbRaNK5ZJtnQxPleMeqg00ai38/p+GVOkuvT1Rnq9aiAs76HQzaNQkFhVtLFvJdlWeZz22y7tUo78dkQ7kJlD5o6/gHGSymo7gas9+DmlwAKpwV+M6jbK5ukQtgspDOYFqKChrfFuonMMeRwZdJEtCzWJBRVFbBjJ6mRtWVzq7tX9xyexII4IqDUcSnbHw272ejx1onlTN1i3jqjXLtGVbgjIHlAdaDbeS/V0AhrXbzZyyBQF3cHThH0b2iSAnCOArzTzipVka9X7kNlD70hYFtmBuYVzaVjW5l0Vp/miYIIsVQgviYFHqXwmcG4Ag8WIteNe3pgDJMa2UqcDANPIJZOCcVGUfrIRahPNL8YcgoltXfMbbPiCYAlLcXG/vSA1S7Hisefzu+qq/6MHt75ET18GwaYjoaIZts8eHE8HFCETXQPw/IJ2wMnxq6jpiJhuWK8yhkYfH+RdZHuS00i5a5jRjvFK00PklzFxdfo/tf/rffiIi4xZP20LVZHMNwA6OkHX7WayXgfQlpsBdg+70rURHwuah8QIYBG7l1X9KsS+APTAFSoV3ivrBu4IfYADi4iwEOVhy6+Ojfg9LsFyyjc26vQCkqHBa3AqWQhxdNxxqu9Hp8UHELPud1P156Pzw8+Amk1xDHoF/ONnOe7AwiqIxzx5VcfX0bjfYZCCuuccoW0T7ij450E5j6O9+62WZW7/Z49zqlrz58EBEboITdNoAKlaDzm9642DPdlhI/4HGycetjQNlw14BjTOW6ruDJmQxwjL/BbvH3w+D0b71khreSdRk1R3KDvDDzbF6fWnQCRCLMCklljf5pS/8JgIdEEmt0QGcYMUViX0tO8xFZTDv6x+VFGAlpckwrfqB3NQ8VSeR4Jpz+vPF1R7fKE4DSRBBro/V4OtVnk957h+r4T9e0w6nJAx0iBmg6snjBA1saFZbGN4mRQtNAPxWoBwlOsXFwIzQOZZnnjlMkfTZ/PSqK+7DhVOxpvinRLJnosyI8dBuONSDNY+x3MOGAOnG+TD4VPoZaczMoMOlYhZEJUEry+Wp3Y2zzVZuwexN6Ql4RezFCzvpdy93mWyWf/vrbo7MeRKYJ1//jA2joVJsD8wHCTZqyiCQzR6Wnj+nhUPJmQRzcvpPD+2CgKFbNtkEoy6Ctl7lfpOYzLIKSjsHda+fqlGb9XBb/EUn0LSnEgdtG865AJkMRruvKLGKW3i3DgCUHqsdxMq0xfcxzPGjRwfpsfienwFUV18ZubNGaSsuquOJi5cNeFN7VAYz9gwQVkV/euMmG8izmWyVffaViDzZY0ygE/A4FsDDeQ6eZ5A50U46qc3IyPjWOh8KyEWHhjsnCmBIwK0qbMqQPDaQTMpRD9ksHZixqaw9Q84oC8rxb/GOPcVr4RE5nrkWao+8txM2Fy9OI0FdhWMn8RHDEMrqIjhSwRYsjtODJPgQAjg7PWNtQHLcpwIK6m8yx8No+g/Sc8gygJGKq3gEOT9lw+4tp+s3vpKkc34E77sOtMkAMVSJzhhi9fxo5mz/nYDH2Y8uXpDOsMb6UgWidvC8jg7p+zNgP1qMesUfxzTGsAbAa9QVngyKxoHCpBRNgxqMgNvtGIS4eY664KBXHhntIOBbv5pFwVCFSHezg2TaxDdIwXNSHCQOjkUascCvTAUy66uJ3J09uvl2Rn//dtwfg4IBqxw8yB9bBlAgN7qfoJ4msq0s026BzpxIVeVRZtxstpgVl8Y+mk9r7G+OY066ocaQq1GEe58kW2VNuw/hKyZwkenyZJ671CuaAx9gmDym6q070l+Gme9SkCTl2VuTAqWuyiJg8wPyFBSMaPopSI1Gsa9kaIfk+xCLuYXHURZ6///CHf8plfQfyoubbFfn41VdiDwAqwJqa+1w6FUeTApfvW6MxQ6EUflE09XOepXAoFjvkZ1bgVlwlgpCfLBX4nhTUJDi4fNlbkdTbrZixROXIpg+wyoE9/ioCEedwgyu6yR+LQ/fiDhVxSx2YchZiIVJ+W6UxTBhjZwnSORjSzdUpEk24FlbbNbdDcpfCQP2CiFGSzwNKHz4eT0Ye+oCxYar1Odz/dtBCEBN+3OJjR7MO7rNT1MlqB+p+NZ6aGCwFgE8kow1SKgQzb6r8NVkjqV79VgLM/edBZZrTwdRQncDPTdHgdRr/QumJmVKX2cK1vCbJF8O3D2MrnqAG7kiZdE7JFZ8UhI4p/B3NkkuP+bpJ9EtGIpDPYr49lfz41789nOrtvINS0klC/03E7b89BzIykIl2qAbhErANRCKRoUCGr2h4l3kak2O2jLRPnaYwQIrrmdhWJcfTzQlKXr2BVUD9xMWJR0HZAe9wxX5kkuTQA7oA/KTKzg5zQBDKnuaQwmwboOQY9GSCJNt2yiARxwOmM/9cqoiT79xkQ3l15ttTya+/+iD24RgcjjHFiMT+wLHrBobzUyHKdRd9c+L31yiQUbDPo7aMkE0VJCKUuUAecq+yOImpGVyddfSmA//EgQtk9AWuz6ZAKurZDTPRcluwzdkMrjE4TUl4hKg+BS6uiSQBlEPGC/tLuXpNpoZN6HfQLOj8FypvGpR+9fEr9xrIAxy7gQOffu2DzM1oMif1+GFJg4E6P2tkYqbt/S4/oHBT/sHPOzCNlObltcTZeyY8h7q4z0D1uHjdmVOdtRmYNCPZsHYq0hQ94lDgCuUbZVZXjRyLXMCXc2dCrlDhONw/aSlkBqvel6gCbHGcfwilPi/DcZVAbWSvsB7JkcsvWN60+fYU8lf/7geJsx+yprlswTOo+CJrIvuocc7GW4CSW+ogAwRybDAEbIYMdicSbKBWwgHGPQ+dCAaPC22URY4naC5Or4OnnMiDfFs2KDCMwSqPLDBctHzS/1uMgmUJY7unO6CXpOvT7/JBvNDRMs5mj3lmiwxp7OjVzt/6u2y3yrs1355Cfv3xKzEJPiNgFfh43LGm9vtgZGynaV7dFEiRHtiAZ3mAOt4AcJdDAVs0hWBtCmvgU5LmVwOQill98BaQV7iDApl1ttZUTeOD9fYUDIlLyigeQ4buSeNcqdTrMZvWmpUWkdqnPRgi3VKA89k8pfh0NbRMzNUDkv//7mf+G+WLB6VfffXhMP3c4OwgZHOtDb7j14MaOD3ABfxyLfPQVN/dGDprPeWus9M89CbZMXsnUOqsqOFWZz2DLBn4Yzp4tDCnzKO8oKbqj3sEt48nbFMw4jfAmssYVFxU2iCz0rj4dpYL1BmAR/ErEH0+kHC7IrOEPF02MIkwayKROWKqLeJj2LbYvHzx5ttj5K///e8cKA1WdWhicVcEqfYL1kNccU1Hd3eqh6eFY13OJFMHVj1gPrBwtatn8J+NYCjkKKL6OPIADwF6mgq63cGygxNtkcgkwcQa+VuaFFzbDZ+YZz8uPfg1MUnsst+W56gsJ2jiGJOGEuj7epftVtnm2zPJrz9+nK/CdBUxUEbmnyADPM7Y/f7+eswUVNzoF7GckM4ga24RQ9ATwDTwe0XyNcy+UL7x0q0+yHgzH8uY0KcVCC+4vYvApKFAMLnn2AJX5FhfJdPQGoTnuAjpedo0iVGHrQlp3KwKIY0KJu0iDGi8Lrxp0alsUHqE/OqrrxoooVmx+jUy0h2KHeL8SPAL7MYzLJsmUchgcAdgG3g84oHPZ66097sIoFvIVMbuktJW5w9fTaj70HAISM0AzO44n4gKVpdrDASPofTG0jgAh4OMpSdi+FA1uenig4RWiJGEAx1/M1mov4XINt/egPyf//Fft6MJMIkg9QvCZ3kHSjKPRxrmjyfoIYgNC+xIp2mtPWSWldghPizobEkBFhGAY/3GvQh4c9saXO0/M/dgPLc2EZ94YWqHh65x8bsv9AKUMFxF5JcvYGHkFdnm2xuXX311dBMyBaegyewKbAnMuvK/zXhmPk33jmILReZnHx4GkFjEBmRfkP5xFE09yHNmPp+yIdh0SDIdS8EiwpkI8CoPHDMtAwpjKfI0EdH084J+v5GzxjjMztvCZIPSG5CPHz7AokzYS9pAgUUCYMwQ1FiLa42ACXTweTBv4o10AS1w3yI7ltU7UPKO+56BePNRsexHej3uUcW2SBVuQEDrhMuZlZ3JmQcLaI2MUP7q4TAfWc73Gc3Fh0o6vLFgps2TjUnXZJtvWx4l/+H/+lfDfDqADRQYkALBxrEwkQYi8SXs+TQTgW6mP823B2fiebbWgbBfw2K542gCDrTWyejCZ8ToTqYK4Q2Qfvn9n2WLl22+bXk2OV71EZlmYDZzHCANltUZTj+2AEzefBymGpiDnel1ZtfZ3mRp1ghl2wZHZzCU+DjpGxMOPqTdbpPx1I6QqiFovrmtbDc/ulU2KG15lHz8yoOSs8mC6TRfnDZ3LHL8PljzTWmP3eHpSMh9PskOsBEz0QeVh0Z0hunZ7bduMuo0Ax/ckwAd+bvN8yIIhadtfq8HEOf0Dp9J2nJJtvm25d3IT//79/Lw0H1XImJjY2UAQ/R92bHw1RBkpoPqeLh4MKWOu1NdJpvrWDa8firyp/+8TbaVbPNtyxchv/74UR4eplln9gH8TjbMxQlQKh+Gv6uv8Na0SR1bDnAQprYyCy7ihzO33CcblLa8G/n41QcxPT6sJM5MPF6/6aCETxe72Yf7YpkI2V7X+6DgQ+/SAubTvo1Kj5Jtvm35ouSv/o/vG5uS8WRvsieRYerJ9Hc9uKd/PaXpiu9g9Ke/+ccXrMnblm2+bdnS5NcfPzamBMsTrDvaxYX3J3k6mNcEKJHJmY6fPX8/lWxQ2vJFycevvpIHO0w45wA3EX14GMsHHh5ERL15Jyby4cE8GIkcF7bJ9mSyzbctW0D+13//u8aawAf10NlTW3LQ4pqI/Nf/55fPWNq3K9t827LlovxPv/rYmNLDMOkePjwcgCQmD2OLlrAx4JYnkw1KW7aAfPzwQcxM/lkOs+6DNSCyYzO//687wWW/y/Zcss23LVtulH/7H353mHUi8jf/93/73MV5k7LNty1bnlD+518dT/D+eTGhb7lfNiht2XKj/OrDB/lnMdGHDUrPIfGDVlu2bNnyWWXpU9qyZcuWl5bNlLZs2fKqZIPSli1bXpVsUNqyZcurkg1KW7ZseVWyQWnLli2vSjYobdmy5VXJ/w/YOmf+w/011AAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(np.clip(eopatch_planet['data']['BANDS'][..., [2, 1, 0]][7,], 0, 1));\n",
+    "plt.axis(False);\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "f8b3d85d",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#NDVI Time Series from masked field\n",
+    "variable = 'NDVI'\n",
+    "\n",
+    "curve_fit = preprocessing.CurveFitting(range_doy=(30, 260))\n",
+    "doy, _ = curve_fit.get_doy_period(eopatch_planet)\n",
+    "\n",
+    "ts_mean = curve_fit.get_time_series_profile(eopatch_planet, feature=variable, feature_mask = 'MASK').flatten()\n",
+    "fitted = curve_fit.execute(eopatch_planet, feature=variable, feature_mask = 'MASK')\n",
+    "\n",
+    "plt.plot(doy, fitted,  label='Double logistic')\n",
+    "plt.plot(doy, ts_mean, label='Original')\n",
+    "plt.legend(loc='upper left')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "a0df6d21",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 0.53688983,  0.26130331, 63.01277785,  0.17811609, 63.46261595])"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#Parameters from doubly logistic \n",
+    "#α1 is seasonal minimum greenness\n",
+    "#α2 is the seasonal amplitude\n",
+    "#α3 controls the green-up rate\n",
+    "#α4 is the green-up inflection point\n",
+    "#α5 controls the mid-growing season greenness trajectory.\n",
+    "\n",
+    "curve_fit.params[2:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "7e381fb0",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "time_peak = np.nanargmax(fitted)\n",
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(eopatch_planet.data['NDVI'][time_peak,].astype(float))\n",
+    "plt.colorbar()\n",
+    "plt.axis(False);\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b22ce6af",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "If you would like to save the EOPatch, you can \n",
+    "- call the method .save (e.g. eopatch_spot.save(your_path)) from your EOPatch to save the corresponding npys\n",
+    "- save .tif images using ExportToTiffTask from eo-learn https://eo-learn.readthedocs.io/en/latest/eolearn.io.local_io.html#eolearn.io.local_io.ExportToTiffTask"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43120ed1",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#If you would like to save the data in .tif format (e.g. NDVI on the first date)\n",
+    "index_time = 0\n",
+    "date = str(eopatch_planet.timestamp[index_time]).split(' ')[0]\n",
+    "\n",
+    "export = ExportToTiffTask(feature=(FeatureType.DATA, 'NDVI'),\n",
+    "                          folder=os.path.join('your_path_'+ date),\n",
+    "                          band_indices=[0],\n",
+    "                          date_indices=[index_time])\n",
+    "export.execute(eopatch_planet)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "916f5473",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "### Extract AIRBUS SPOT data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "434d6383",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#Define the provider as follows for Planetscope\n",
+    "provider_spot = ('AIRBUS', 'SPOT')\n",
+    "#can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c1092c0c",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "Instead of doing a request again, you can go directly on *download_workflow.get_data* using the following ids :\n",
+    "\n",
+    "**order_id_spot** = '222331e9-d8d3-4e2f-959c-e292a665b214'\n",
+    "\n",
+    "**collection_id_spot** = '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4a020238",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#Define the workflow to get your order_id and meta data.  \n",
+    "order_id_spot, results_spot = download_workflow.execute_query(provider_spot, name_query='example spot')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9e6c1824",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "collection_id_spot = download_workflow.confirm_order(order_id_spot)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "34ed65b0",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n",
+    "download_workflow.check_status(order_id_spot)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "1dfea2e7",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-08-08 15:21:37 (INFO) Pansharpening: Default RAM limit for OTB is 256 MB\n",
+      "2022-08-08 15:21:37 (INFO) Pansharpening: GDAL maximum cache size is 781 MB\n",
+      "2022-08-08 15:21:37 (INFO) Pansharpening: OTB will use at most 8 threads\n",
+      "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n",
+      "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n",
+      "2022-08-08 15:21:37 (INFO) Pansharpening: Lmvm algorithm\n",
+      "2022-08-08 15:21:37 (INFO): Estimated memory for full processing: 1.38769MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n",
+      "2022-08-08 15:21:37 (INFO): File ./tempo/Pansharpened_20200415.tif will be written in 1 blocks of 191x151 pixels\n",
+      "Writing ./tempo/Pansharpened_20200415.tif...: 100% [**************************************************] (0s)\n",
+      "2022-08-08 15:21:37 (INFO) Pansharpening: Default RAM limit for OTB is 256 MB\n",
+      "2022-08-08 15:21:37 (INFO) Pansharpening: GDAL maximum cache size is 781 MB\n",
+      "2022-08-08 15:21:37 (INFO) Pansharpening: OTB will use at most 8 threads\n",
+      "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n",
+      "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n",
+      "2022-08-08 15:21:37 (INFO) Pansharpening: Lmvm algorithm\n",
+      "2022-08-08 15:21:37 (INFO): Estimated memory for full processing: 1.38769MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n",
+      "2022-08-08 15:21:37 (INFO): File ./tempo/Pansharpened_20200518.tif will be written in 1 blocks of 191x151 pixels\n",
+      "Writing ./tempo/Pansharpened_20200518.tif...: 100% [**************************************************] (0s)\n",
+      "2022-08-08 15:21:37 (INFO) Pansharpening: Default RAM limit for OTB is 256 MB\n",
+      "2022-08-08 15:21:37 (INFO) Pansharpening: GDAL maximum cache size is 781 MB\n",
+      "2022-08-08 15:21:37 (INFO) Pansharpening: OTB will use at most 8 threads\n",
+      "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n",
+      "2022-08-08 15:21:37 (INFO): Loading metadata from official product\n",
+      "2022-08-08 15:21:37 (INFO) Pansharpening: Lmvm algorithm\n",
+      "2022-08-08 15:21:37 (INFO): Estimated memory for full processing: 1.38769MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n",
+      "2022-08-08 15:21:37 (INFO): File ./tempo/Pansharpened_20200606.tif will be written in 1 blocks of 191x151 pixels\n",
+      "Writing ./tempo/Pansharpened_20200606.tif...: 100% [**************************************************] (0s)\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n",
+    "\n",
+    "#order_id_spot, collection_id_spot = '222331e9-d8d3-4e2f-959c-e292a665b214', '6458a2f4-70fb-4986-bb90-1b3aeaeaca25'\n",
+    "eopatch_spot = download_workflow.get_data(order_id = order_id_spot,\n",
+    "                                          collection_id = collection_id_spot,\n",
+    "                                          provider = provider_spot,\n",
+    "                                          resolution = 1.5,\n",
+    "                                          pansharpen = True, #put false if you do not to apply OTB command\n",
+    "                                          otb_path='/home/johann/Documents/OTB-8.0.1-Linux64/bin')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "9e45f60b",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#Reset the download_workflow method if you would like to execute new queries. \n",
+    "# t is a way to prevent to download multiple times the same image and consume credits for nothing.\n",
+    "download_workflow.reset_workflow()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "8cc20fe3",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(np.clip(eopatch_spot['data']['BANDS'][..., [2, 1, 0]][1,], 0, 1));\n",
+    "plt.axis(False);\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "b81bdd5e",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(eopatch_spot.data['NDVI'][1,].astype(float), vmax = 0.88)\n",
+    "plt.colorbar()\n",
+    "plt.axis(False);\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed05b200",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "### Extract AIRBUS Pleaides data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d0af543",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "Airbus Pleiades have a Panchromatic band at 0.5m and VIS-NIR at 1.5m. On SH, the price is roughly 10€ for 1km2 of order, with a minimal order of 0.25km2 (2€50)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "3404967b",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#Define the provider as follows for Planetscope\n",
+    "provider_pleaides = ('AIRBUS', 'PHR')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e16f39f",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "Instead of doing a request again, you can go directly on *download_workflow.get_data* using the following ids :\n",
+    "\n",
+    "**order_id_pleiades** = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554'\n",
+    "\n",
+    "**collection_id_pleaides** = '9eb3a890-7984-46bb-970d-db30ad5a4209'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2e9894ec",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#Define the workflow to get your order_id and collection_id. It can be also be retrieved in your SH account in https://apps.sentinel-hub.com/dashboard/#/tpdi\n",
+    "order_id_pleiades, results_pleiades = download_workflow.execute_query(provider_pleaides, name_query='example pleaides')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "83fbaecb",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "collection_id_pleaides = download_workflow.confirm_order(order_id_pleiades)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "704771b7",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n",
+    "download_workflow.check_status(order_id_pleiades)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 155,
+   "id": "a6495500",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RUNNING\n"
+     ]
+    }
+   ],
+   "source": [
+    "#While the statut is \"RUNNING\", you should wait that you data is ingested in your SH account. The output of this cell must be \"DONE\" before your get access to the data (~ 2-5 minutes)\n",
+    "download_workflow.check_status(order_id_pleiades)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "5faa08bc",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2022-08-08 15:23:34 (INFO) Pansharpening: Default RAM limit for OTB is 256 MB\n",
+      "2022-08-08 15:23:34 (INFO) Pansharpening: GDAL maximum cache size is 781 MB\n",
+      "2022-08-08 15:23:34 (INFO) Pansharpening: OTB will use at most 8 threads\n",
+      "2022-08-08 15:23:34 (INFO): Loading metadata from official product\n",
+      "2022-08-08 15:23:34 (INFO): Loading metadata from official product\n",
+      "2022-08-08 15:23:34 (INFO) Pansharpening: Lmvm algorithm\n",
+      "2022-08-08 15:23:34 (INFO): Estimated memory for full processing: 13.6552MB (avail.: 256 MB), optimal image partitioning: 1 blocks\n",
+      "2022-08-08 15:23:34 (INFO): File ./tempo/Pansharpened_20200606.tif will be written in 1 blocks of 572x452 pixels\n",
+      "Writing ./tempo/Pansharpened_20200606.tif...: 100% [**************************************************] (0s)\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Apply pansharpenning method to project native bands (VIS + NIR) at 6m into the panchromatic resolution (1.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n",
+    "#order_id_pleiades, collection_id_pleaides = 'e7f5c398-0d23-4f9d-a6a8-03b2b0632554', '9eb3a890-7984-46bb-970d-db30ad5a4209'\n",
+    "eopatch_pleaides = download_workflow.get_data(order_id = order_id_pleiades,\n",
+    "                                          collection_id = collection_id_pleaides,\n",
+    "                                          provider = provider_pleaides,\n",
+    "                                          resolution = 0.5,\n",
+    "                                          pansharpen = True, #Apply pansharpenning method to project native bands (VIS + NIR) at 1.5m into the panchromatic resolution (0.5). You need to have OrfeoToolbox installed in your computer, available for free on https://www.orfeo-toolbox.org/CookBook/Installation.html.\n",
+    "                                          otb_path = '/home/johann/Documents/OTB-8.0.1-Linux64/bin')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "321b7737",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[datetime.datetime(2020, 6, 6, 11, 21, 32, 600000)]"
+      ]
+     },
+     "execution_count": 49,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eopatch_pleaides.timestamp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "b7f8592e",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(np.clip(eopatch_pleaides['data']['BANDS'][..., [2, 1, 0]][0,], 0, 1));\n",
+    "plt.axis(False);\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "c1bd9e6e",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(eopatch_pleaides.data['BANDS-PAN'][0,].astype(float),vmin = 0.2, vmax = 0.9)\n",
+    "plt.colorbar()\n",
+    "plt.axis(False);\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "56e6faf1",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAASAAAAEoCAYAAAD40CztAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABi/UlEQVR4nO29f7Bk110f+Pme292v9WbGMqDKj7W04AU54JgQsloZ1utYcSw8KJbFQrElXEutIUt2KzGhIFDYC9hEOAgRl3cdrx2vTCmkXJXVEmqLFUSL2AS8EMqARIGRNNLIwpvFclKLDQakedPd997z3T/O+Z7zPeee2/3ezLzpeT3nUzU1r/t1n3v7vj6f+/1+vr+ImVFRUVGxDZhtn0BFRcX1i0pAFRUVW0MloIqKiq2hElBFRcXWUAmooqJia6gEVFFRsTVUAqqoqDgUiOgsEZ0noueJ6J2F338pEf0bIvo9Ivo4Ed28cc2aB1RRUbEJRNQAeA7AnQBeAPA4gG9j5nPqNf8SwC8w8z8nojcC+A5m/vZ161YLqKKi4jC4HcDzzPxpZl4BeBjAPdlrXg3gl/3Pv1L4/QCVgCoqKg6DVwD4jHr8gn9O45MAvtn//F8COENEX7Ju0ckVO72Kioqt481/4xT/0R/3R37fb//e8mkAC/XUg8z84BGX+X4A/zMRvR3ArwL4LIC1J1MJqKJih/D5P+7xm49t1H4HmP7F318w821rXvJZALeoxzf75wKY+d/DW0BEdBrAtzDzn6w7biWgioqdAqNnexwLPw7gViJ6JRzx3AvgbfoFRHQTgD9mZgvgXQAe2rRo1YAqKnYIDMCCj/xv47rMHYB3AHgMwDMAfoaZnyai+4jorf5ldwA4T0TPAfjzAP7RpnVrGL6iYofw175mj3/tF//Ckd93+j/6g9/e4IIdC6oLVlGxQ2Aw+hNkVFQCqqjYMRzGpbpWUAmoomKHwAD6SkAVFRXbwkmygGoUrKKiYmuoFlBFxQ6BgSpCV1RUbA/HkoZ4TKgEVFGxQ2BwFaErKiq2BAb6k8M/lYAqKnYJrhTj5KASUEXFToHQg7Z9EodGJaCKih0CA7DVBauoqNgWqgVUUVGxFbhSjEpAFRUVW4LlSkAVFRVbQLWAKioqtgYGoT9BJZ6VgCoqdgzVBauoqNgKqgtWUVGxRRB6ri5YRUXFFuBKMU4OAZ2cM62oqNg5VAuoomLHUDWgioqKrYC5akAVFRVbhK0WUEVFxTbgwvDVAqqoqNgKqgtWUVGxJZy0MHwloIqKHUNfSzEqKiq2gZNWjHpyzrSiouJQsGyO/O8wIKKzRHSeiJ4noncWfv8fE9GvENHvENHvEdFdm9asFlBFxQ7huKJgRNQA+BCAOwG8AOBxInqEmc+pl/0wgJ9h5n9KRK8G8CiAL1u3biWgioodAoOOSwO6HcDzzPxpACCihwHcA0ATEAN4mf/5RgD/ftOilYAqKnYMxxQFewWAz6jHLwB4bfaaHwXwS0T03QBOAXjTpkWrBlRRsUNgBno2R/4H4CYiekL9+zuXcPhvA/DTzHwzgLsAfIyI1nJMtYAqKnYKdKmlGJ9n5tvW/P6zAG5Rj2/2z2n8bQBnAYCZP0FEcwA3AfjDsUWrBVRRsUNgXLIFtAmPA7iViF5JRDMA9wJ4JHvNHwD4mwBARF8FYA7gc+sWrRZQRcWO4TiiYMzcEdE7ADwGoAHwEDM/TUT3AXiCmR8B8A8AfJSIvheOC9/OzGvntFYCqqioOBSY+VG40Lp+7t3q53MAXneUNSsBVVTsEBhUp2JUVFRsDyepFKMSUEXFDoGBQ5dWXAuoBFRRsVOg2hO6oqJiO6gWUEVFxVZRLaCK6xoPnDvL/+/Fm/DE527Bb529/+Tshh0AM1ULqOL6xfufuZMtT2HI4oZpiy996AGe/8EM+/8fw04Jn/wn31sJ6ZhRe0JXXJd44NxZBhoYsnjZZIE/v/8iPvfFp3GhM+j3G1DP+IoH3s9sADbAp//B91UyusJwPaFPzmWtBFRxRXDfU3ezwQQNWUypx9y0+OLZAV5x45/iPxiLC6fn4M6AGaCGAUv4so/dz2bCMMbi5S87wM1n/gQ/9198+OTsnmsSdSpGxXWG+566O6n36UHYNyt88fQC2tMNzswW+NMzN6CzbmP01mDVN7i4mqLr5TnCQTfDd/zWd/DNN3wBN01ewpnmIr7zVb9eCekIcFGwk3PJKgFVXBYeOHeWp2RgyKK1E7TcwLCBJYt9s8LN8y/g5dMDLG+YwBBjSj0MMS72U/xJewNeavfQcYN50+LG6QIvm1yEgeOzng1++rmv54YYPRPe/qpPnJydtUXUTOiK6wLvO/dmnlMPYyxabgADHPR7OLCObOamxX6zxH6zBAA0cAQ0pQ49DA7sDH/a7eNiP4Uhxp7psG9WONMsMKUuOVZDjI996uuCpVUJqYxaC1Zx3WDfLGHIcYJlg5fsFEtvBe2bFabUh/8bWEypQ0OMBhaGLBow2mmDFTewMFjxJLwOcKQDAA1sctweBg1xsI4A4Ntv/Y2Ts+uOGXUwYcVO4wPPvIn3TIspWfQwsEw4sDMs7DQ8BuCtnR4z6mA8iTiC6dGQxYob9xwxGvfOQDo5DEUSims518+ywcPP38YNOCThWTZ4262/dd2RkmvJenI+diWgiiNjSh1m1IVoy4HdQ88GU+phmbA/WWFuWuyZNhKOsmJabrDgaVhLEwqQahg9E3o0aGCC5SQQK6rxhObWcNpRQz0efv42Bq4/MqouWMVO4oFzZ/mMWWBKvWvl6XWc3vchtiDsmQ4NWZxuFjhllgn59DDh7iwuF7CXWkhecBY3QkjOwqIhixn14bWC3OUQMoKEo8kGMmq8wP2tX/HbJ2eX7jAqAVUcGlPqnXXCgCFGy02YrGnAuLG5COOjX3NaBb0HSK2aBc+Su3QPA8mdsxxJR9w5Qwww0JPrXzw1HcTd6tmsJSRxyYR4GrIwsPi53/8adiTY4N6veGJnyMiJ0FUDqtgh3P/0XWzIYu4JxVkyzpXqQZhSjz3TAkAgnxn1ibvkmp8TWk6/cibTfMSyAqIrIcL0KbPEnFonZgsBwQwJhx0J9WozNtRjblaBiOR1DUziqrnfmRMtatdi1Iqdwf1P3+UFZ+dKtTwJG9uRUhfIZ05O+wGAWXDTyndkoyJcDaUWjJCc8YTnNKdeaUUMQ452Gj+MGHAbz7CLkPWw6DnaRmItNdSHNUAWQIcGfjJEcN2Af/Gp29m9z2lPJ0VDqomIFTuD+5++iyWU3nKDA7vn8n3gBOApGGeaiwCAObWYmzZ1h8iLwvAuFBpHNsroadk9l5cPiC7UEAcCmlEfLCCBJq8pnJtm2blWPXWBAJ1Ybf2aQjQTRzqsztWTVHyfE77FSgJwjbts1QWr2AG896m38Nz02DdLZ/nAEY8QhUsYvOjqvsQtylyuuNmd1TQDsFBuTssNGlhcsHsAnMYEOPKJuUO9ry/rMKc2uHWNYjGTkFAP68PzwoWtr1ETEgrvpc6RFgxaNIl7GC2k9FgAEjICrr0oWy1GrTjxmBrnWonYfGBnodTixslBIB/RZYCYn2Oh3Bn/fON/a2CxwgRLO8WCJ+FuvWdaWDbumLAxWdGTj2g+0e1KiUeTREO9s2oMAItAOlNFbAAC+QAIVpDRmlJmSegcIzm+9ZrVxz71dSwRvm1maNc8oIoTjfc8eQ/vN0vMqfOaT4OlnaK1E1gQ9pslzpgFDGwgH7F0tBulkwIBRwLRCnLPHfR7sF7EbvsGN3p3zgnIDON1HAODKTkdaoZU3M4RRGayaJgw84QjBCT6UXg9c4jAgZHoR/I6izg91CqRPETrVNoAAPz0c1+fWEhXm5CqC1ZxYiHkY8hiwVO03ATy2TMtbmwuoiGLU2aVkE8JQkKNtxQAYMHTaP2A0NoGPRnsmxUA+LB7JkqThRWXzWtPQBrt6UHxeBJyBwc3S4hH/64HAWQxCxqQIx8RssMx/O97boLrmEPISM5V5zXpGrbjjq7VWrCKE4v3P3Mn75s+PJY8H8C5SGfMAjPqcMa4JENNPmM9aHo2aNm5bhe8iC1WVQnTEKWSDexIw3g9yLlQWejeE5H+X857qqNe0O4bRzHcW0sgOLfLC9NJeN/nO/VMCdlEobwPlpA8V6ph02Tk1r3yRbVVA6o4cXj/M3dyg5jnI5YP4DbaGbPA3JPQ3KyKbleekRysH1hcsDO/7iQSBZvQoqMhO7B8dOhdXCnrCaJX42di/k5qBYVSjYyw8twjQIjJhs8geUSaQKVoVhOPJpmpsaPkCDj9SyJ02q378LN3cA+D7/7KX75s5qhh+IoTh/edezPve8EZABY2tVBON4589s0Sc7PCFKr2iiTfpizY9n7DAW5jaOtEcoZMaNPh1m3IkYfoMFPvEuZrW59n1PIEK3HPSCw4nSfkSEc25tgG7RHXk/8XdhoIQyAtRSSqpmEyy01ITLKuJXFyxZPkGhuy+MAzb2IA+J6v+teXxSBVA6o4MXBuV4x2iXvk8mEsvmhyAQ2sIx9qE/IZgyafBU+xsFO/qWP0aOp/PzVdCOVryOaeeUJxlg8AWPQ8QQPGn9l5CJ8bWMzgkh/nph1YIiXSESsqEpkrktVWjzwWzE2bJEbGIlgu6mGiJ6181rWFxQXeCzqYvHffpzGUrLMjgasGVHFC8MC5szwnTuq6Wm78HZtwY+M0nzm1mFPr3CC14QbuhbISWp4E3UQE5FAW4SvY983Ku0kx30dC8D0IU2RWj19rwdNoqXAUhVvqccZcTD6jFqXz5/XPshaAcL4LnmLFk1CPNvORQU02+c/AMD1gxUBDhJblOff5XurnrkMkGHvGXePv+ku/dlnsUZvSV5wIOPLpQlaxkINEvL5ociEQz5nm4sDy0VYOEPUfcTkAKOunCdaPkA8A1a6jS5qPiXbjdBjrMpYBtABW3AxcJMC19dg3y+JnHauNEutHXLgWjnwXdpqQTzgvlZs0hpgoaeNn9lHAKXVJRnlrXRfJvF3J5eK4LCAiOgvgA3BJ4z/FzD+R/f5/BPA3/MN9AH+OmV++bs1KQNchhHykhku+sAd2BgvC6ca13DjTXAwkBKgcm4x8gNQCankSQ/iie6i8Gt2kTEotdHIfECNMrp4s5uL0IE8Qs7C+lIG0PMGc2mQzr7OALBus0ATyebG/AT0MLtg9r1dJKUZ0B5OEx8K6per/HIYs5ugwVRHHHgb7VCbQo+C4RGgiagB8CMCdAF4A8DgRPcLM58Kxmb9Xvf67AXztpnUrAV1ncPVd0kbVuRZ6s9zYXPRlD6uQaKg3Wol8tPUj2knLTeiQCCBYWjKyR4u4uki0hNziWfAUlg0WXgtq4Z4/M7mYWCe6Eh4Yuo3BAvLkE9MEYqTOZUf3wfoRyHESVyyzjERbylMU5tTiRZ5jj7qQX3UlcUwW0O0AnmfmTwMAET0M4B4A50Ze/20A3rNp0UpA1xEeOHeW900XSghEvAXcZjzdLNDA4kyziIJzgXwEg8gXmxD1WinROa/xmlMbSiwAV/4g62lLSqweCYFrq2dpnXvnLCVHLC/nAzRYJOebn7+OoInrtbAz5y76JEl5zTQjRZtV0xtEkVy0rJgGYAfXJ7yOrLMqG5drdaVdsGPCKwB8Rj1+AcBrSy8koi8F8EoAv7xp0UpA1wnE7RqEsyUkTi4SJlbP3KyKmg9QTjp0XRGNd72idiKbWHoEhRB2wZoQrhASKpHP0kbXriGLF/s5Glgsvft1yiz9Z7TehRpaVmKZAECLBhd8P2vpb5S7Vjk55A3QhHwOA5kMYowrlk0SI68ALiMT+iYiekI9fpCZH7zE07gXwM8y87hZ61EJ6DrA/U/fFSwfACHaBbiC8X3fOnVu2mLTr03Q7pEWnLXlk5PPOj1JIJEoceWCpuT7T8sxPrc6Hda4ZfZH4f3iPubN6qWR2YKn3u1KrTUdzdK5SRpjJSgxG3v4eRrpP0SuA4AhxhR+AsiVFKEvLQr2eWa+bc3vPwvgFvX4Zv9cCfcC+HuHOWgloB2HNBQTSDhcNoqMzZn7MLBuEp+Tj67t6pW+YWFCwp4QiQ6rryOfnHh0L2ghH2lgLwQkDdKWdoozzQKftS9Hz4QzzSJYTXNfXS+9feT9gXz8+Qr5NLAApRGpPONZPoNORxDkhFNKBnSRRBeWn1OLngiW/DiiAsldEvjYNKDHAdxKRK+EI557AbwtfxERfSWALwLwicMsWglohyENxQS6BqtngzNe8xHycU3k5Y4cSSKP/Ii7lZOPbOaZEpzFkhqzfICUdOR4L9p5SGAUa21ppyF3aEo9lnAW143Ti1jZCabU40V7A06ZJWawWKl9KPpPsKQgSYbuRc4akb5GaYmFIZskHurOjECZbHLLLl7XSG4X7Cy2HoG9IoWqxxUFY+aOiN4B4DG4MPxDzPw0Ed0H4AlmfsS/9F4ADzPzodi0EtCO4oFzZ3nPRHdCrAfZzM7y6QL5zP3jof6RJtdZNknuT4l8tNWjuxCWiEwg5ONC+IQVT9DyBC/2c/d6stgzrbeaGjQ+ec+wxY1+nPPpZoEzxqUOrFRkTs5broOzrGZOq/LWj5Rx5CUWY9nO+rNIqYlAi895lMxZn64z0imzcoTLw8LVy8Fx5QEx86MAHs2ee3f2+EePsmYloB2EaD6AI47gevhNKHk+mnxKHQZ17k6OlReH15FPbvVsglSbv2hvCFEugTQskyTFqW+zccYsfCP8Fl8yeQlf0rzkkhg5Di0EgBWahHzE+okV9ha5QD4tCNi5MC9WYMmdlAiZnC8AgIAZgBV7q4gnsFeQfGo7joqt4r6n7uY9Y0NkRlwO68srTvsQ+75Z4pSyekrWTymvRZL2Wm+hyN1e3C5pTXFU8ulBiSVxYGfueTa4cXLg1jSrsLmkYf3ctPgS8xL2aTmoAdOCs5BPEJ2ZEm1Hd14EULweeQ4RIPPN0tyhaEH1noxVD2sf4WvI1a6V1r5ccCWgim3gvqfuDk3kAQT9RKJe+2YVxua8rFl4KyLdBCXCCFZEQj5N0E/0LHfdH3oT+fRqXav0pAM7gwFjyRPc6LOxhdRAMV9oRn0okj1lloWcH5OQ5gW7h4WdwsIEq0cnRQIY5PYAqqxCiff63CX1IIA6TBGr+PPzcpX+MpbatSvJ279eDmotWMVVx3ufegtDZdVKpjDgdA+xfDT56GF9JWhxtQcF8tEtKkpRonXkk4vPQj6SvCgbuSGL02bhW4C0gYRkDbHapEg2X1+TjxCEWGwiIsv5Ju1FMs2rpM3o9hqyrmhrEsaXso1SU7KSaL2pw8BhwccXBTsWVALaAdz31N1sELUdAIPIkbhd2vIZzuOKUR3ZgKEp1wj5yABCHSU6rOWjJ6BK8qIhi4YZc7PyFeIrnPJJkUIc86wKXdaQ5EP5/CHT2RNQz5TUn+neRpvqunRZhSYfqXmT9iVh3RHrR19TfQ2uJKoLVnHV8J4n7+EpcRhXDETysWxwulkkbpeeq7Uu0VBvuBaNjxo1ISdHNrLxZQX5Jh6tQBfRVkW9dPKiZRMSI0Pvae9SCukAKJKGJooS+QjxaM1rjHxi/6GofTVkQ8V8iXzEGpuiDw308+tx/M3CqghdcZXwI09+E0/JhqZeEvGSTbhn2iL5lMLhOXk04I3ko5Py1lk9+V1ekgxl8woMMfZpGawdIZ/c2tmkU0lJiFgpAIKlJuQzUyH3MeRrSl9rACFHSTBVkT9pHytWpCbY5DpsKG+5VFQLqOLY4cin9z113CaSQkqZr7VvXEV7Xl4BIAlRl3J/RLjV5NP7njbBhSlYPkA5wxlIi0ulubtkIeu+QFpPEpH8UK6d0qlEW3KfZxjpCoWw6jqU1tPuZ9Ip0acIGGLMaRXOf4p+4HpJv+lEqM6uyZVC7Qldcex4z5P38I1K7+lBoUgTQOiup1tq5OSj/wdS12CMfKRcILd89EDCkuuVZzrr3CHLBIsG+2aZ5A+VNKWx89XnHJqLhXanQ3E8z2TWeU9yPYG0DYisKS07RCeb09JF/4wn4w3NyuQYmniuZAge7ITok4JKQCcM9z11N+83MSzt6ppmwbLY8y0vdN8dXb1dqtzuEZP2pMxCT4I4rOWTIx9rI9aZlQ47vunXKbNM8ody8hlLhpRz1oQphAEMySePdpUILReaE8HZWz1CPlN/njIfTdqXHCWrWQ88vFKoYfiKY4OQi4TbF7YJI5MNnBgtrlcIBauNLD1rUrjokb7byz9JmiuRT96WQpBPydCCc+/LLARhuirZoPdokbyUDGnIFslHCBNQmo//l0e78nVDxrh3ucTd0kK5FOHumTZkfUsyp1iEY6SWXx931WNXgis1W55RNaCKY4AkGUoleMhuVtXn+80SL28ORq0fIN3Uuipearx05Ejn+eicmxLxlJpvAUPy0dbJqaYNYq20zsjdo+QYmbWQW2sikosgnwvNhxGcU70nEpr0KJrTKlSthxq6NaH8JO8pyyTXHSOvHGoUrOIYIMST5/n0oBCC1y5BIuAq66cEudNLV0CdWHcY8hGUxOfY+L0JojMAXzYRM5G12Kwx5proaJduBTL1kytmBRFbINaTdjsBhDoxbfVo5NX9JVcx70ctCOkA/hqJlgQMG5xdT6gEdAKgJ1j0MEnbUCGePdPiZeZisqH1XVm7XtqC0PkyOfnIhsvJZ9NEVMBtKskS1m6XZfJ5Pm4DS9g9R6ksRJ7LrQgdodNC9jq3SwvCOt1Amt7rPkG6Un5G49nTgvyxWFRu7Rku+Er8OCnkyhJQFaErrhiksj0fnwO4L7pYRkI+Iojmd3yNvE4qJ58xt2tgnWidJ7N+dHGmbtHqokWuVCEXs9dFg3QWsUSQVspF0hNVc/Ipidg2I1A9cSNcB5LC1JR8dLuOdecqn33FDQ7Y1aH9Sb8fXEVZ+0prxlUDqrgikJ4+MaFNRNEmWD2nfNawhLE3JewJSnVSY26XruYGComFinx0eFnaawgMOY1n6q05g8ORT35cXYMlJJhba+smVejz1iF2Pe4HcNMw5Fw1+eQuk1hmOns6fH5PmPpay+RZcZ2vaDsOrgRUcZl471NvYTeL3Vk3Eq4W8jHBJejDTKxh24fodsSapmj56EzhpDOgJ4gZDVtJAGkEJ68M15aEEJyE3HVv5dCreY0VUSrryGuwBrVdijDXhe/1eetm+kI+og/Nsusw5nbpaRu6qj13FS/YPSz8z0dpVXJUVBG64rLgyGcZet5YxIhXbMbuZncFvWNDWYFAiCGpw1Lkk2w4tWaphSpQJh/RfXSvIFlbyHJMeB37DIml4l0YyZqWiNcm8skLSkU70hNcW99tUch9TE8ag3Y7AYTmZ6Us6HAzWbvi0VE1oIpLwnuevIf3myXm1AfyyadMiEUjs7vmvtK9tDGGUZm8oZgamTxSAqEx1v0vt3w0+RxWTxprhibRs+h2Neo9Q3G4HI1Kq9lLgvOB3QvkIeQuuUmHCbPLtTFwBasAEsFZyC3UjPn6vQaMv/uVH7+iJkt1wSouCU5EdpaHZUILLVZ2SRfAM+ZiSLDT0CHmHG0oqpwk3QfzQs1iC4ksuTBH7nYB0aIyZJ1WtcaFyZ/Lq9q15SPXI9dlNqUb6Ep8PfJH1pVKfLHSwnDGTE8qZU2HxyqJ8YKd4cAXrwIII65b0wTyudJTURlUCajiaJDC0tNNq/rwxCTDqPl0YXOsy+4dRr1MkmjYqwRG7cLoboDJ+3k82qWbivWZ1SMWimQ4b6yaz4TodS01cvIRohO8/st+nwDg1/7dlycHlPVWvqBUxjwDaa6V1HZJ0/rwedeRj//dgqc4sHt+xnxcWyxa6Vh5XK05TpAHVgnoWoBR4XRp/ynjc7TQLGNzSs3ExlDuDOijPJ4Q9OQKrc0M3KwR10vWF2iLKndh1hWU6uPqyJG0UdUCeSndABjPqRGxWY4bomiKIOQ66+Jd7daNkU8Q2zm27HjR+mke/m87p5WyDB1FzMyy/Ee7HNQoWMVRcN9Td/Pc9Jj7DF4g1js14Kwl6eaxObqLn6yldR/pSSzv3dRCVd/h8+dDa42CjhRIzROciOehvzLKrTB0+wuxUnT3RbF8xirl89IGbf1JtvfK6zGGLAwoEZv1lBDt1uXnKISsW3/ICGlpqA8g1I0BzjIMQxCRDkG8ojhBJlAloC3CTbBog7gMxOiJdgUGmyIjjJLL5dZqkg2tSUSH2EuCM1AOtafH8ekB2YSJsXYaYSifIiH3mBOrItSkZeQzluVd0rs+/u9uZUduKQHL5zLE6NnNR5v5DgL5ddbuaF5/lutTYvkc2Fn4PGfMIkQAG+IkJ+pK9YAuoVpAFRsh5DOnbkA+UpyZWz7r+uMItOWTR3wAKIskjXSF3spr8nwEySgalnWH5JNPlyidY2ndvBj2qOSj67tKFpVAkjjz6RjatdPr572cxfJpucGL/Q1hiKIlixubA79mdKt1DyRXzkKYmzL5Xw5qGL5iLe576m7e903X5cuZC86HsXwE2qLQkag8dC1lCnlvnHU4DPkIQQQxuKDNhPWU5aOLQccayK+r7SohyXRmM1p5PqdV0Kr0ZI3DNNbXPYcWPMUfd6fDKCELwo3NImR9i8i/sg1kPpkc55QXo68kajuOirV471Nv4b2QAxLJR+eIzGlVtHw08nCzi7BEFyOfVyUV4kI+pVE2JejC0xKpyTnn5FOyUDQBlKZMlOvR+o25OHpN+Ty5e6QneRRzh9acd55DpPsEvdjfgIWdBvI53SyS6x1C9yMpDPMrTUIMoBJQRQnvfeotPDVdcLv01FKxTmbUFZuxr9N8AKhSjUmIHOkNLySxrgQiaRAPN788L4MQXUaqz4UopbAUWF+DBiiiGBGcgTjkUJPPurXidVhPPvnwxLzndKl2TJOPToq8YPfwYj+H9b/fb5Yhi3qqXGu5ni6rnYIgDwB3/ydPXnG2qC5YxQBCPiI4h0JFju09Y/p/+a6cQ0dUdMbwipuMfLrQGVDC7IftQ5zPwUrIx6TkM5bNrDEQczPB2Z1vWgpyGGLTJRCHIZ9S4W5aNzfMnpZrIeTzUj/H1HRo7QT7vke3ZFGXBGz92YBjFKIrAVVo3P/0XTw1NmS/Rt3D1R3JXfOUD7nrvJx1YiuQhpl1W41et7/QGcYwAB/uy58IuWpNnYuzbizPpmkTueAMxGJY11R/3KoqtTktDQwUHIV83HPWJSlqzcuXbuhQuyMfl89jyJXIlELrQkjSTbFnwjd/+e+cHF/pmFAJ6JghLTXyVH7LJiSpafIplUKsu/OPTQAF9Jc+TTAE1s+h0kmHebV8ki/jCUK7FPL51kF3YIwFsWZAbIJ15JMnBMqaOtoVImhUngdW6pW9Quw4qa2pA7uXlITcODkIel5DUXTO0cMkUcFvv/WJYyKf4yvFIKKzAD4AoAHwU8z8E4XX/FcAfhTODvskM79t3ZqVgI4R7zv3Zp6rAlJxiyQZUNyufHROcJPYrLVU1pGPNOcqWiYwA0LKoWdgSXGpdhFDYWnh/MZmbUm2dCkrO5DPiAUYzqvUAsSTZaxqj90GZ4p4jtKqQ1qWSOP4BU+TNqoNGGeag0DAkoYga+RdBPTvjzMHCMCxuGBE1AD4EIA7AbwA4HEieoSZz6nX3ArgXQBex8xfIKI/t2ndSkDHhPc/c6e3fIZfNv2FHbN8gPEvap7dXI5MRf3kMKFlISU9jmYYPeoG5FMa8VOCDA3URKH1JJ3rM1Y3VszGHhSszkI/HCH4mSJOnZGdXGt1LLH65Fpc8FaPtMKVBnCig50yy3CzaHmCBpmgr/6ODdnjdb2OrxTjdgDPM/OnAYCIHgZwD4Bz6jXfBeBDzPwFAGDmP9y0aCWgY8AHnnkTz7NGXgJdqhCH8ZWTAt3rh/VTspn1xtN5M1JcCiDROgRj1o/ukZNPhBALQo+fKZFrnuUMaDcmRrtixnckH13fdVTysWwcqfnmbbGXc6f+9QNXq3QMbWVJnyAhH9HrGrKBfBxhivVjg0uoz1lI9aroPpdmAd1ERE+oxw8y84Pq8SsAfEY9fgHAa7M1XgUARPTrcG7ajzLzL647aCWgY4C0WJDNINDZwrLh8uZchyEfcV9KCYFJHVa+ltocOcSNkZopfd5JJvIhG5/pdfWsMSEfOTe99mg1fqFKfkA+Mmvek4+2fvTAwFzU19MxwtrZddbNxIR4Q0pDoa2IW0c0JBOiXldPdL6kw3yemW+7zANPANwK4A4ANwP4VSL6amb+k3VvqLhC+OCzb2S5y8pmkEhX3lLjcshHD+HT5Qp6CqheRyM/nhZx9cbOSS1kIhf0k1LXRBn0JxbVgd0LhCkEqcknzAVTxJAjj3Tpa7ziWEMnpRU630f0MJNdm4Z6ZflE61L0ntZ3j5S1Y6sOV8hbEsRl/JCI6zDAle36swHHE4b/LIBb1OOb/XMaLwD4TWZuAfw/RPQcHCE9Prbo8TQkuQ7x/mfu5AapWyKRLl3bdcp3MCy1JR2LTJXIRzSKEvnInVmsHvknKM0wz0cEy+SKvAwirIGx8Piw5YVEjoR8xDLZF/HdE5v+vHG9tCGangcm+szKT90wxJgpgpckxrzqPLdc8uNEdzFaPxKt1JXzY9akEJe4bxfsHr791t+4eiF3voR/m/E4gFuJ6JVENANwL4BHstf8HJz1AyK6Cc4l+/S6RasFdAXwvnNv5j3jvuh65jkQC0vzrGFgOF9LIJsjLy2Qu75YFXoUjZDKJvdobAaX3kwSSpZ2HfmUiZL2k/SMVgmRITFSat08SetG+totWkc+OtNbrB4tvOuq9lTMls8SBzXm5yv/t2hCuw4tZmurKjR+gw1/hyBC20n4+yx4ii90p0J5xlXBMZViMHNHRO8A8BicvvMQMz9NRPcBeIKZH/G/+wYiOgegB/ADzPxH69atBHSZeODcWZbpFZp8RFvQVe2bygrGyEHntsSG7MPq800oWT16jA6ARMAuNeVy52SKJNSA0aoInQ6Ly/HF8imFxEuz1PNZ7UI+UmpiOU5D1eQTG+v3ijg5OVc9zUL6ZS98D+eVD+UL4cqgAJ3EOEUfrNBY7e6SFQ0xDvo9fG51Bojtga4KjqsUg5kfBfBo9ty71c8M4Pv8v0OhEtBlQIYGxkZisUr6sOSzrjn7GPkAaahdC855f2Wd8zPW4TDWX1lMVRQqF7J1r2khIU0WK7EeEDeyXltfj3V9lgWyofUUC633uOsgJSH9MNMZcWpGtLJ4MLZGstJlfW1VAbFyXp93KKcQImbR11xR8YHdw5InmJlubdLnsaCWYuw+7n/6Lt4z7SDipUO1usNeXs2dh2hzaLdLjx8uWT6HSWzTeT46yzmcgxKG1+UN5RNFnRBrUp0qy3DW5BM3bqHTYJZkqBMMJcwuViYg7WpXiValexGFlrNK85H3xtqxmGQoupI7P+laqDSlEeJccYMZ9YnIDgAH/SwI11cVtRp+9yGiJIDE7ZK745xWoao9t3zGyEcXqeaWj2xk3RdZb+Z1kDExMrFBN5IHYqX8Jk1Gn38k0hjtKbldeZ6PTgYUlI6h3S4d8bJ5SYjSkvLe07osYlA75guBo1sXBWcjVlM2TignnwYWIOdh9b52rGch9wZ7xp3flZ58sQlULaDdxQPnzrLoCkBKPoC6Y2ZZvUAkijHCSKqvM/IB3MbQg/0Ok48zEHI5NsWSHBVdKZ9bJqPCsCchXQ4SGr3DJBZVkmSYnXOp0bv+OYTC5RqE1q/dwJ3LyWddMqOcdyhhEdc1zINXInZ2bdIIoCOhlZ1iSl2SkX6mWYQJGFcNh49qXROoBHRE5Ca1/vKGoXMqa/iwVopAXI48epTf7RPLybtMpdldIrbmTeR7JndX9xabNCnTd3dNrMDQisg7L+oK9Jx81tVg6Z5DeRGskE9a2xXdLa1XAeXC0jzilfRN8tfaWa9RL9LJnBK1HJKPIiH1nI6A7pvlaHnK8YCqC7aLeN+5N7MkEwJp32EgHZ8jG27MSikl2w0baUVLYqyDnyBYWGTD3a+Uo6LLK6TboHZd1g31A4YJhzo0roVb2cj5rPYcee/mo5LPWN+kUgsTudYrNIn1o11RPR8tEeLDuiPtUdhgblq8aOfhbzClHnshNeKYi09zVAtot/CBZ97EU4p3QBGbBZKclvdxPmzVc6mLn9R2lQbxiVVVglhCueCsN7Ksqa2IXJfZdNfuOSWfOD46nmPeqKxIvJnbJevl0a515AOUe/qUuiVq3Wcd+QDpZFd9jBKkMb1A36y+81W/fnVNkkpAuwXXXjNqPvqLnYbahy01NMbcj1IXv3zMjW4fKthUsAkM22q496UztsYqxNdBOgPqqJFsYu3SJe8puHN5O414DdLs5iTBMHO7osY27t6JO6nd23WWT77uGPlo3a73bm4y++xqWz8nDJWANuAj59/AU9IaS+yyl5OPCK3AML8n11YEY5bEGPkcJtsZUCOTZYPDDEhtzDVaZ/1o/SSPpIXq8zXJlslaIkAHwXmcfLRYnpNPTg6adIByEe86y8d9nvV9g/LrledoiVV81d0voFpAu4KPnH8DN9kXU6AF57yVhGDQ3ydzD0Qc1uQjQ/70CJ1SJG0M2qXRArEcf11haYl4BgWxqszC9b4ZEuUmkhSLQX7Wbpfk+khd3TrNZ9310LlJSecA0IB8ktykjDBK0bShdteEnKgFpipqVu6OeKyoUzF2Ax89/3qeUSzidJs66hxCPLqbYQm5LqG7Iuo2FfmEUT1CBzgE8ajQtY5OheLSbDOL6LwOA2tN9SGSivmGYonFpqTIQVsNRLczn+ShrbQkATBzkzaN/ZEG8jnBrxP13WcvT8hIrreQnNfcWt5T0bNYe3a1UfOATjgeeu513Ki9ouuloqvRJ9GuHHk+SikHRTaIrkAXotDRl7EJo6UcmvxOr/vj6KTIw24OHY7XepKcbxhBs8EqGW1bESyqyYB88rYlOfGMdWPMO0ZKgqC0lRWCL1lUcv7rhP6EfLylaWFwyixxwe5tx/LRqAR0cvHR86/nhhCiSJp8ZM732KhgXYdVzkeJG9kVLc4Guo+ubAcOOb0iI5+SliTkc9hWqvl4GunjnIvOY8mW+lpsLi6dJBnOM4o9nAdh8UIujiYEeSyurbTE0P21NcGXyk7W5Srpa6VdyTm1WHETcoZKAYGKISoBKTjysTGEnVgQYrIP67BK+SeafGSDyEZIoz1NcAmSBLgsB2Wd9ZOTj5BE0icIXOw2KBi6W9KkrJwzo3WfQV+jZLMOycetOwmaj+5kGAmzTSwrHanbpC9J3ySdS6TLWPKhj4LDtBrRlg8gIngM2zdksbAzd50OGTC40qgu2AlETj5A3ISicegw+1gEKR1ul4aAx2Z3yaYqRZHWmfJyBx4bxCfWlBZa16E0lC8nn7xPUOmcksc8nF6R9DUaWGrDso1SImByDdT5hsJSNR1DLNdQupEnchZyiEotRxIry5NarhVZ/7wuWbnqqCL0ycJDz72Op5Ikh/gFA3QC3DC/Ja+TGhOcteUzOj5HWRKbIjziEpUsH90lUYhCb7ZNPX20yxU0FDVjq5gEOEKSujQktnqNY25Wmeulm7ZpC3NThrYgWD5+eKC7hjaQjzSQz0P4OTn32Q0o/V10u4R8ZvBtXQlBkJ5RHEN0VVFrwU4WPnr+9Qn56N4ts7AhnIaS9y3WKJFPmShS8hm0kFCidcntMuruqmuwRGTVERhtpcXi2bSnjyARm5WGEiZjqM2qc5IOgzwqN0Y+p8yq6N6W2r9q67JV11ZrSoY4WIBCyLlYPmZh6mb1uktBy5O1xNh4QrpgJwP966qhEtDJwEfOv4FnI+ST97AZI59NLtJAHC6QT6nEYsz6yavPc51jTKfSLTTK5zrMm8ndrrGmaqO9rFU+Us+RkIuWjxlaPmnri+Fm1rraKtOTjIoo5nqSrDcmxscJGb5rgIosakLP36sDDNIz+lu3MH65akAnAB9+9g7WrRLyose8sLSU1brOjRm2qWjU+n2agbvhlhUKKVVmc4l8YmLkUGTVx9CJePq5PGlPXqM1r8NaPfo8o/A+bKuhCX7YTCwlH329k9QANMG9je5RnAkm17hk+cTOjmnlv1xr9xqKvZ9BA8dMzk3QgAEq91K6KqgEdG3jo+dfz3OTaT5ryEdv3jTcXg5lH4V89ABBWV+g64zkXMcsn1iNP7RS1mlJuXuRZk7HqNxY3+mS9bOOfHRUsSEe9HAuC8Jxg+e5PkI8CzskH2lfMnZ99d8tr8yX74Vcjym51qp5Emde7nFNoBLQtYsPP3sHz00aaheEosdC9z4dgVlXBLqOfMQlkGiXYFMGMRDJp9TutEQ+h20DIuvkZRtAuU1rDqmR0+epK/DF7dTk4/KcOOkcMEY+7vrGTS7XW65x0HwQ83y0CG9gB1X5g2uriD5viLZiN9dNSi20xZqTT/7+q94LGs79qi7YNQpHPm1CPjk56NKKwxYTilUkrR5kY+hM5LGK61IOTXA5si/0YcinFKEb06lEYJZoV66BravsD+ebkY/+OYTIoVuBpMWwpTaqJSTdIhFJXmbMx8hWJLOxVIGciJOiXUU8WrDP3bjSeckaW0cNw197+OCzb+RTBfKxTInVM0Y+68oLdKsHyZnRBaC66HGQg7Im6zbPnXGaByXkI4l1eUdDoEw8etPpjGSdubyu5UVyniOWj/xOkyUQM8l1rdsm8tHuUdB71GRYIE6v0DqVWJgl8hwrYcm7RjYZ6YQE0YIlqcknuIKH1MuuOKoFdG1BRibLl3GUfHwYeB35aM0EKJcqxEJNHvTIyb+UeelCbrYnVpC3JhLy8ZNFc/IpYXDH5zhxAoh1bochnxIaMFoMXS/3u+jOyd9CV+TPfGh/rJWGtgB161f5W8m5JxG0I7i22uoJxGac6DxVhJlDk26+7jZcMKC6YNcUPvzsHTz1fWWAvKo9JR/dw0XcoFIrBi2K6lKFhZ0myYC66PEwbSrCMdTdVBet9p4w11W25yUV+ryBaPlIgqFUiOfDCI9KPrJ2mnIQLQFNPrlrlJN9sAALbtcY+eg1S5XtOWITMSqSj6yV1KOpXKp1N4yKw2OnCejDz97BEu4FkAqssGvJx71m5IurrJ7cJRAdJE8GXEc+pS+zdo2CO5flDuWV7Zv0qlzE1v2hdWHpYchHR+Zk7WSEjrcydQFvXj9WagliyKLPMojlGuto2tyPulk3HVbOX+tqWl/LtS99PXoYP1c+5g8dpsyk1Iv7qqNaQNvHB599IzeIm1L6C2u3S/STEvmUoMlH3C2xfMTk1kWPuSuzDvJlTudh5U3kuzChc1gIO8xuzs9dqvtbbnDB7vl1LWZoExdjXWmFQAu/eWrASutfGNbR5VnOw9SDeBwpr0gnlnbh/zHyKX1++T8nCiH5RvkuaztGFt6vW4zkx7yqqFGw7cORj4XxdzIgZrXqBDWJeJU2whhiNq8jnwO7l4SYZcOt2xRr76QZ+UgPG52spzdGqawiRyj8ZBNnjanzzdtTCLQ7lFs8PQgrnibh+8TtwrCDgM72TpMB0+vRwCq3dlxwLukyOi1gTJuRY+r2rLn1WHLn8khXUuvGJrGwtopKQNvDh5+9gxsgaSIvVouhONhPxNt1le0aYv30yLsCDvNbgktEaauK0hczTzIUC0VrSbLZ8mS9wyC4QypKp7UZHY3ahHzz5USZR7vmpg3XNw+3x2tS7kMU9aS4vp7PNRZV3EQ62lIJlk9GPoGQ11iEeh096NEidjGomdCbsVME9JHzb2CjOxlmU0uH43PaQ1k+2vXSOoe2qnRkSvf0AdaHsLWGYmEGQrYQTykrexNCTROitZa7R0ad61jpRunck5Yaym3Kx+eEpMBBbVfZcusRrTR3vpF8dFnIoT5/wVoJri7HXkw6VwtAEgnUzeYaiYBmJCbn3TOhh19zi2L0SXLBrgHF7MrgI+ffEC67ZQrRKdmEe6rmaJ+WbmOrMHD+T6CbiemRLlGbsWHdQT1TtqETrQPRnA8aSoF8kpanyu2ybAb/NHR/HGlRIUWglilaP6rcQsN97mzzZv18ZHJr0tExcb3KJRYlsdx6S+LA7uGA94rkM5M6t0KqwGC97Hw1YYgl6D5bapVq1zl3R/Pn4nVOK/IlBUG3MdkFENFZIjpPRM8T0TsLv387EX2OiH7X//tvN625UxaQ0w6aJHmtAWPPtJjTKvSEkU2xrhUDkJJPnvoPSAnFMOM2z74dy/UpbWgnhkZXrlTbtcm0T5qJ2Rku2BkWPEvC14ONpETlEgbJkYFAI/loUhPCXFdika+v0xnEshJrZ92EVTkvILbSHUtj0K/V6RKGUiswv+b68wMIrpe2XEN6B7bTjD7gGCwgImoAfAjAnQBeAPA4ET3CzOeyl/5vzPyOw667EwT00fOv5wYI5BNdI0c+M1+YqMssDut2DWu70n4+2oULoWUVxj6KK7PyeoRsCt17Z915ymctZQy7u/0MibvoibPY+5hNuvGU0DqoceOUfKY+GVLc0BL55GQseUvSUmOVXQsAiZs4+MyZES9RRC2OS68krdeFvw+ljf+FfErXWLvNEkmUyN9Yh4GrjuOLgt0O4Hlm/jQAENHDAO4BkBPQkXCiCUjaqMLfibXeo8lnX4gHfbzTrbF+NPnIxrCIw+fkSzuWgbsO2p3JdRRBQ+z0qUwEXRdd0TlI2lJb2GnovaOT9uQahagRxa1cKrFY2Flyznm0S9dgAdEKKDXnl2Pr6+w2dRT2I0nwgHjCtSxEE1MLxZFP1OxcVTvIZESfRrxK1qAmNV2Ff2BnWPpK/IYs9s0KduR8rxoujYBuIqIn1OMHmflB9fgVAD6jHr8A4LWFdb6FiP46gOcAfC8zf6bwmoATTUAaVvnyieWjtJnZSInFIPNWkU+LaGJrHJZ89JcwvzPnIq5OEdjUfycXOfN19c9AzBqOCXyq+RnFjQekG1FH5vR10ecb+/dEdzTvZli8HsrCjEmGsdm7EEQ4tw0bKx9HFJvex2ZiPQzAFs0RuGF403Czxl7q5zjw+hoAnGkWaLkJ1+L7vur/2g4DXRoBfZ6Zb7vMI/88gP+VmZdE9N8B+OcA3rjuDSeSgD56/vXhEmsRFHB3XHGz9Fwp0XzGrB+tm5SqrgVaL9DkA8SMW7mD6nC3rJdXtUtUSl4Xwu0Y5riUSAdIW57KhmvVOesRx7o4Fij3yZHJFUlB6Rry0UQsIq6upytZMDqqmJex5KUb2q0tZRrryJZ8Fy7YPVimQGzSJAzeUtHu12Atb1WXGpSJ67W0zvo56GewTNgzHRZ2immT1rRdbRCOzQX7LIBb1OOb/XMBzPxH6uFPAfjJTYueSALSkKJSIM6Uij2GYxPydXdjbfkkCWowA/Jx/w/JJ19TBxjzhl/SNF3OWwhCN0IbfM5Cmn8uYot2ovUeKUWRDSztSMJnGnHvxsgHSOejlchnUzO0vIBXi85yTmMalT4/OW+t80ikL4rPTXidI58+vN/AAuT/ZwO5BO7vlRKe7me9VLPGDDEMMVpucNosw/u3iuMhoMcB3EpEr4QjnnsBvE2/gIj+IjP/B//wrQCe2bToiSIgbfkAkXzkjjynVdgUeXOusdyRGPFK3QGdYCbQeSJF8tGCLaIoLc/LXX7BTjfQYWnJUTIYrr2JfOQuL9YPAKXzDNcCRctnLHFPF2fKxpa1dHlFqfq8RPb5Nc/JR+cnCUopAjrKFdeZhe+BWDuSp5WSWhSX3XfGuWPABBY2uE9ydG25BZK3U6+JObdrbloXrTOxKFjObSs4JhGamTsiegeAxwA0AB5i5qeJ6D4ATzDzIwD+PhG9FUAH4I8BvH3TuieKgDQ0+QDwom0auta9hfPSBUBViKNJyCeEw32EJklSG8k9KdcCGbQck950NErOy3jxtlQlnicrujXTTGRdf9XyJDbQCk3Zu/D+taSgzl2snj5YEsNmYmNh8eDCSBvTgtuVtFLNBPgcOqKor7GsczASiVoqzc6oc+xBMJ54JHABdGgx9ZZQE1yzhYqexe/HBAf9Hiwoitf+pmdBaO0EdqRFx1XDMSUiMvOjAB7Nnnu3+vldAN51lDVPBAFJkmFpypJsYkmA0+Ltpg57gCMfrUWIiwQgREvisVRv6JEQttz9Yt+guJHTgsoehjjkJ4kuoS2TMeLRgrPkn2hrTaxBQVgTkveSkVqBePTG027cILkws/IAuA3gSUg379J9fXQfZ63hafHZ9eJJRXI5J3n/gd3DgZ0NNvxY7x4jf3tC2Kg6l6mHQePJSa6p/N1aO8GSJwmhufNV+pl/7daakQG1FONKQyrYBbnuo2ul9OYYs3ziOpR0MlzYaVIl3iSh5PGyCiBvxE4AN4O7pyYfPQM9z5DW55ecryIfLTbrWrcYnePEcsvXyY+Ru1vatXXnHK9xqXRD1nLhaO+CUIc+bOKYEKgFZ4F272Kaw9C6EvLRQrCM45Frq5EncFolRsvlbW3Uk+SY4o6J3nPQz/xrIlntmS6Qz4CsuHS7vDo4SaUY1zwBuYZiElnwLokMnVN35GT2UxbpKrldOvNW53bk0OQzBin2lJapuRiaWz5ALFsYrDNyDE1mPUzQPdLxOWmej0ZS2a5IR65rSDvICA1wovMmUTj/HGIBAWmULs8jkvWjq5X2dA4iOceylQve6lnaKQ76WbLZWzQh1WBwTh4G5IhICdRS4yU4sI5wnGtHuNjPMDGq75JBelz/uqWdJDfIivW4ZglI3K4pRRMfiPk+pXYPIjqPJb8JdERKfpa2GgKdgyLIxdxEl/CbQ3SeMGFUidmlWjM5HxRckeQ1HOuYVpwXw4q1U84bKnV1dMdNdR6to8Rr3CfXomc9nbU8Fy2eb0qcITMZJrF43OeNFlsDNwSxhEDoNp04om9K+TW02pL0RNMmazaJbiO1hPL/0rpt0vYGU3LkY5id5oMmWIudNYn2tDVUC+jyob9IuU4god+xiNc63UeTj5QrXMg0BKmS3+R6DfQYH91a8CTcUeXLbwqV4IC36kQz0cjcJJ03lJv4STvWoG+4EHNxbaTk0wZiiPrVVBG7COPOhfHXEhYNtUnphuTaaPFcu01J4apyt7RuJ/VfmjTTdImYn5PcMIixZ+IYJflfiGWdMNxyg84aTyKOcJa2CceUazwli6ZhR0yeeORaivXjCoMptIO56mBUArpcSImF/sLmmk/e8jRvyp532QMwIB+X0TqDJL8BCEKrXkOTj3ab4gabeEHUE5CdJsQzVhEvkFooDYvY27lEFBJujpGYzMqRELOQUHY8AMEa0VEkQxZ7BfLR5+LalXb+OpUzlOXayNz6vG4s5A1lSZ1To5qt+ZB7WC9EPilcX7cefDQxkk+wfpR1I98hrdcIWXS2wcV+iov9FIYcySx6RygT02Nmemf52AYwwAS9l/Olkt/gYj8Nj6dmewWpVQO6DDz03Ot4SuqLp3SO0OY0hK5jRAZIEwVzJImAarpC+D3H2epjawjyimi5w4dRweqLDXJf02HCostDsZxutBixasKxdDnBmOWTQxPloOeORLkQz7+1co1dBrMI5CGaFzavy5kBgIV1rpJRx5Tz1tdG5+KUrJ6kLKTQ9kI0Nt06ow+WCatkSMbUxLXyAYyddefUcQMDDiS27CY+hO7I6qCdoWPnUgmxG2JM0KNjA1igp5jrs7RNsHxkTdtvUQOqBHRpeOi513G+ceTO7+7MvtBRT4PIROd15CPdDKWwVG9msapy5MQRq6pVBM1OixGZcUk53n0FJkR+0s8v5QRaU3KvL7uZQ+0oHkMTp5DPgZ1F8jGd75vUD6KOYi2F7G1YINtj2lrJi2zzglVNPKHh10iOVUg8ROqCuXX7pEG9Dvtbf53d32eCzgo5Ei7aKQwYLTu3y4Kw6Kbo2KDtG3QFV0oe6+cMGCvbJK8Bhhbp1US1gC4Bzu2Kj2NEJrZeAOQOnbb5XJuyX3S79pKNua4PTrIWZ31mfNOpkNGryCdpUaFroVTkRWqu9MazSEf+SKW15JZol85yLC3QyD+PbkXh3icRwNiwLSYZiltrR9uKyrmElqbqGy/dA8StlHV18S4Qx//I+ZbUGSGeGGFMtZ+5abHn275qvS5PXxBSsCAs+2jtAMBBF92mlW3c75nQe+unZ0JL7mYxYWURKQtKiEmTz2TNzefYUQnoaPjI+TckWRNi9aQCYIc5rXDKLJ1WoERnQPrcZHkjqr5L2j0IScjm0FGY/L0NYmtNXWXtzjFOrzjo97DkCZZ2krgEmnyA9K6sYciiYU4eC/nodhpT02MvC7E7Uptgim5Q4a2JR7enFVdOsnYBF23UuUmyoUNhAlmAAYsmbEKXLc5YoYkFt6orYClz2v2tyu1f884Byf/qukvSprx3zwcNwuuUHS3aT2cbtLZJLJ5V32DhdZvemmD9uPcReiYQMLCESFlBuRW713TueEVKvQqoIvTR4GZ3xcdiZofucv7uuW+WofZoTm2sP1Ihd51IlheVSvJaKUEsuYN7UTWGmmP0RYesxYo4sDMseRIS1QQ5+cTIUBqNcRs7EqKO2EgIOIirKjFSPqMusNTXUI6Zk49YlVZF6Nx8+S7WoyliN/6cxOVKUxEIoNgqI1oslIjMulVt+MxA8vdzWdoxUmmTG0dM7hPCyaN1sgY46mnubyc1YgZL26CzDVbq/96669BZA/btatm/j5lA3goSwumtARH7vCj3u8ZbP4Y4/P7//pvv24oIRBh4xtc0tkpAMrtLQ29O10KDveWzGvSa0aUWOskuudNjONROkAqd6s+mIkc6JT+20mjCZl5kVspYLg5QDgnrn2WT6ZAwAHRosKeS63SSoHxmA+PcM7keGfnkuUmOVCLJiJWZh8BdaL1DAwOgT6JhM+qTHCbtkokLl5OPXjftlDic6Co3kJVPP+hhfHdEAKG1SJx6KxZafH/8ufNC8cpG7U1E47Z311yIBwCYy26c/K4HsBJriRiNcZ+jtQaf+IYHtssB1QLaDOd2paat1imibuD7+phVzI5dU92uCx5b+LaZWY+c5EuLGBUK8OHrvJWnEISk50uKvgjKod8OOHW9kgLSmLgGICS5yXMrOwn6hJDMnun83dbAEqFBSkKx7MQmLou2fHIRW6wtrf2MifANAHgSkes4NSkBave0RD5HqY0SrU27dJYpEA6QZk8HULRg9c2m866XkE/nSX7ZT5wFpKyesFThWoiFBABsRU/zNz1v+TzxjT++dQOkitAbID2cE9FZEYCQQxyjsyrOldLlBbKGnloqGc66YbiEmNcJz9aHxwEMSiokx+fFfh4slVLavQX5KEuTEFAkhZhtK+6Q5JG0tsHU9JgAIZ8kJ2p9LUrDCbXlo/W0oH2FjHEOxDmWPa6vlS6PkF5JQvja8ikNDRSMNpbnVK8LYXyY5KYh7p1Gr/5mMVAgN4yYINhxg1XvW+32TahJzbUcVasazw+uy5MjrWglMROYGL/7ln+0dfIBUC2gdZAkw9DXJYuy6GZX0pwr6TlTcLvcz9HySXrNZKnxm8KjeTsNSa0P4VwvZLsvdTksboNbkobbNVk5V8vdmQEEkbTzrlHPhAlJBnVKPsZrK6KB5HlA+Tw0eZ+QIqBdoJjQaSgte3GamoOuyZK/nfTd0U3bZO3Sdc07Rya/Vy6cHn3Uc1ruISN65Dh5w/jk8/oaLsuEg86lMmjLB4h71SgdR75VpJ4f+9aIVfTk3T92bZAPUAloDB9+9g6em0IRJmJtkI6alGagl5C7XWK2LzgKw1ov0JGvfC6UrJcXGoaEQzsNlgoQiSfPD9EhWh3+jnVD4hZMAvF0Nm6iicqklQ1omWBJZwFz4pZoiEalkwFDtrdE6LLIl54MoaNQeZqDzoXKdRt3/RxxhaJUlEf+OMtvmKUuiaI6Qx1AIpCH51VqhJCOtpwu9lO82O058mGD1jaJK6WRX8ck8pWctz+0kM9b77umyKe6YAV89PzrE/LJc1NKIdvc8gFUzxa/ju7hrDOcpa2GvrPl5FNC6saYhHh0YaJG6JcTIiORcHIXTZOPWD0uKhMr0CdmSNATtYGNL+nQzbXyUdRyzoByu3ym8Dw0vtfXu5y3ImF+Z/NEq1U2eInA5ZigYU2foPWkJESiyce5uVlhcDYCSUMytSV6Kn83R0biejnLp+1TEVr+ftrlYjjC+bd3/iQBwH/+Sz8YkiS0SH3NkY+gElCKj5x/A88ojj+R2iCty5Q67ZUsnxCFUZGuEvno3I28sXlOPjpsDSC5i+qiUhcGTicqCOnoL7U8Lmky8XVuTbGKoivH8fdsk9fIcV2yonPzWsC3WO2Huo+KsOXkM/cZz3mCYLzOqq0o2RDpEstQl7HoHj5y7vIeg9QKkvC6O0ZaqqEtn3zt0d5GEvVEav0s7QQX+xleap31I5GuQCDqWh+FQdiH5/laJR9UCyiBc7ui5aHrkIDYVkOTj+S7jDUTywfwhYJQnuLFfp5YSLL+GErJenm1uWzkBhaWVLhduxWqe6JuGZJGo5wIKi6X/J+7A6nm46wcV47CMOwibK2dwJLFFIAFY8nalYmulxGNx5OPjCvSEzJyhMxjsXA4tinV/Y7EbdafVd7TeLpx6FyVvKoT0/qf7u+sn9cjfzTGOhO0PrNbPrsUlh50k5Dzo/8+GvmeZTjLR/9Oh+Y/eS1pPjkqATl84Jk3sSETzPHYeS4lH93JUMin9MXLq9p1hz0Awe3SyMevSIZrfBzdCTmG5SiwhgQ4fxePyYCcCLOuuTnC59Pko89/2U+SbNw0+jKik3iLqrMGjXEkqKNrLTfButTnLJ9/aqK7JY3Q8nYjqfgumkpMT2htTJTMdZ/8+pYq8S3itcrD9jrdQSC1Y+taosQSjWhtSsP4lZ2E+i+xWMaahOn9qi1n7Xate/+1hmoBAXjg3Flu0GAKYIHpgJUbWMyMVEanDcWA8WLLfHaXfGnF7dKbo9R1UKAtH+1aaJLT7osFeTKLj0OujyenuAYBlJOP6xcTol7e8ok6RBSzBa0nQljAGHaTNtg/Jg5uoQGjpbQKHYjZ2BLpEtJMM7/TWrvSPCtJRVjwNFh5sSYqpgBIvyLBDF2YwNGHRMh0vli4XgoyYCBYsXJt1N8yyXbW7pePTho40raghOjX7c1cGwKi1SMk1FvC777lvSeDiU4Ajo2AllJtTO5uLOnzcqc+3SxgkGbfrot2abcrb/Ep5ANE0bOka4S1MJwfJcSjs57Tavms17D/X9+19RdYF6Uufe5Q51+7CiH8cdfL/c74s3U5QntNB1jAUqzKzkPw2rpsjB0U6/bqb6CTGTXxhMZfkFazsSVKLiyLtaOvqWAFN2ZZk6N2SeV66++FdpfzAYrJ35OB6PLFvKEDOwvEs+jjdR4LpY9aRTrpkCnk/Vzz5HO914K985PfwgBgaBoKGFsbm3pPTY/TzcKJqobTkKpCXoWtNR8hH0ARhtp4Y7k+2tTPySedOhEJRKrP5X9dQgG4u7MNCYVR65Hz79D4SEzUfBZdbFgmx0j7VvsaKyYYpjDj0NjG9aEh1ySrYYsl4jytHmojm1K0yAnZvbfQGtiEhPJWrfKzXCcAsZl7yBZPe+4kfzd/CnFCSHQZNRowFjzBXCUa6ohXKZNai9na7ZS1W9tg3nTotJaXuLs8IJ/c2rEMGIph92uefATXKwH9wCe/la2IpeiDFXGxn4YvwhdPL7j+Mya2rBidtaU2qWyCRWgWHluUSrLgqNuWfdHCnVORTx7tig2vYm6MJP9Zlorr6AZqd0I+67KfhC966/NQVr0Lu+tGV86dQ3h/ElVz1Z4wxOiYMYEbetj2UbOSzz4lpw/t+aZc2tqRYyXXJBHOU/KRotul7m+U1J8Z9KLvKLdVHic/q2uldTMh9hauF1EPCj2fJCmy+L1go9bOM76lj3PMrdLWz6ZEVE0+zITOXsPh9gII16kG9CNPfhNPyWfbUrQWZEMu+wkmpg9f5rlpfWHhMPybQ9cGaeFZml4BhREuMDGhA7HroO6pXGocnxesWhCmGE7ZKLle7mcRbZ1I3FonODvymQQ3LO+2595ni3fmDi472vaEVm3QYGWxwQ1Niw6MU5NldDso9tKxYFifQmCRJgbmgrBu/xqiaT6sHkPykWDk76bLPfT1lKzxeP2c+6jblrjQfR+sv3UQC1isM2lb4pJEZ8Hi1G6uZDXnfy+BLquI5OM+z1MnhHwCrjcCuv/pu3hKTgyVqmADxhITbw25L9yecVEYaZtp2YTXlxDCtSI8K51GvnxASj7SksEQRxJCtHpKOT46Z0Ynp8nmEJSEWiHcYA2ABpGuhTS9Ujk9zJRSL8FZVSNfHklQDOKq11tWdoJ502KJCfaazvUkalwET8TrKToYxIp5IWaZe+audTpOSLowSu2bC/cDYaQNMLAc49/MRaJkSoQI70JQe6bDxPTBWtPFuzoPqgcrEVtF4ZTms2A3Kllaash1110KDwuryKf37TmevucfnizyAUB8chjosgnog8++kfdNWmktaHxo2jaEPdMGEppTF0LzQPTx8+JSIGo/QhRhoqbSAKS2SPQMISEgtmfQLSnEepLOeDpcnjc3H8sQBtLERek33NqYLR0iXf48V30zaPOgoQlKzsU1TDcwZLDKuFru0Auk9W4NcdSNmJ0ITgaWPOF718u5L7H3tLYOQ0TJn/vCOk3PsIFVbpTuXQREi2dlJ1j2k1gzp6KGXWNgesaZ6QKG0w6PLTeYkWv9oV0/F+kyygr2hcFs0Fqpz/OPxfK28XqXarryv4VOMrQnlHyuKxH6I+ffwKdMN7BMgKgD7FEX7sgNWZxpFgAQSgFynUJIKE8ylLlbOsyrozk5dKa0/C+m+tLniOj3ygbZMy0aY7HfrNRdOY0U5UWeMfFtFshjZV23PatM+RL56MiZdg1+6Y7/iQDgzl/5XpZz69gkyXRG9aHpyGtv1lmiPROs7vTmT7nlSXC/ZtSFhEJxuRb++i5VGUcQzJULponJMsXoE8cJEbr/jvxu1nSw/RSnmlUkbjSYNr1KSPTDFkd0QTdZ1c/q8pGvzjcW0w3iO46SQA+sJZ88ZeJEko/HdaEBPfTc63juw6Q9xaiJuAgg18GvMYyGLeZ+FJw0vgqNxVRls0Y6jkV0iXi6aRZy+pyuB9K1XH/WzcPdubVqcoU/rz1fADoxfj6ViZXXJdIRi0Xu+pLdvOgngXyk454p3Jak4558+UO7DlWUerFzY20IbgNJ3xlmckmJeuP4zWb7KW6Aa7Mqrpj/4/i8oUh6PRwBiNisP5v+vO46u4if5EHJayXhT4hHXKCVnSQFtoCzCmemg/FW26nJErAuOmosozEc+l4kbVbDuVAY/ijkE8ov/BidTmlA8jm1BcSl57371VtzYgTnUVwPBLRvluFn558z2hB2ZR+mdWUCun2CiySxE48tYIzTWVbcxA57GbRInNdiaXdLQxPP0k7wUr+HF7s5LnQzHHSz0Pu3MU5bmZkOmKzGs68LOkdr3Qa42LvM2wvdDIt+ilXfhKZiuTs1gNoM0hyrZ8LX/9IPMvljdX0Dy4C1cVSMIcaksZhNOjTszsUQY9FNMWu6ULE/YQM0zhWbco+FnWJqOmeRemtTaz2titDp8/d/WX9t08mhF/sZlp5wpEugkI9O5uzYYJKI+Yw9dnrgQT9Db/y1Ni7hb07upqWzqLU4vvCjmcWija6XCWK/HEfaqrZZOUb8H9d0fddRcFwWEBGdBfABuDS4n2Lmnxh53bcA+FkA/xkzP7FuzUsioI996ut4TvHLq++cQNxsBj0sbKJQSFV67MKXZrsCUH7+JCQeGtigBeiKeieoDiNSYZoCKH5BbYNVP0mqooWAbENeo+qDZtFmd3t3TJ97Yh3BXej2sPTu1sonvrW2wbKbJBuZiWEVCeWRmN76DoxKAHWvi6Jo1yt30TCIGK1vqjVt+kAeEyafrEk4hRVW6jym1KPhSXB/AfjNGzs16sr+5Lpy/Fmq+peeeCXkvfKurb7GSWSvAcgyDDWw3LnePEYsN/eafQCNYbT+6xmDB+7xwke+hHxW3gLTBb6inZWuNREH4gei9nNi8nw24RgIiIgaAB8CcCeAFwA8TkSPMPO57HVnAHwPgN88zLpHJiBxvbSlIqJwiHJQnFIwM2nIWuAS59RYF0YY66ur00OY3d/FtF40FjHS7lIUmeNznbI0TKbBdGxCI3hjnHZQ6mgouU1y5z/oZsmmY7+mPkUXaHcQoVPcq5D454mmlx7F1oC99WOtt6YMg8iGjdMzYeLXW/buTzrxUbO8fYgU08ZrJdZMqoWJpZpD9zESK0vP05Lok1iY7D9bcHf7eJNa+HO9AcBF+Naz6o9qGgt4zUo31G/tJLTCXdppSHkoZZfLtS491iS/S+RzTBbQ7QCeZ+ZPAwARPQzgHgDnstf9GIAHAPzAYRY9MgF956t+nT72qa9jIZUX+zn+tN8PLs8XTS4EwTkkkmV/2nLuj0kmK+js29ALJne9RiBjbpbyfsQkwonpsdd0aKmBCRMOLGZ+/K64CC03ru7KI971TeJ2iOXTWbcBW6V5CAnpnkRAJB+9YXpr0FtC1zfeAgKIgL53xMM2bmILwJg0bNx6UnXlFwYwLurWUaqfdKQbrekC3FQPg3er5X26oZcQ9aqfhFlai87dSELBsU1dICCSL3pvqRmLlR26poYYS54AvcsXk1lq8h17sZ/DMoWcn/HvgUuPEEsxLy5157lDlo/geAjoFQA+ox6/AOC1+gVE9NcA3MLM/4qIjoeAAODbb/0N+uj513PLTSAfKbWQhDKdxSpJgPLzYAaXj670iEmA8n8sfoxisGTrliqz5TV5QmFDcZTKrPFiM9nggpXu+ElLDk4FZ6f7OJfugteU8rtv6bFRa/VKcBby6XqDrmugUzmsNWBv/VjjtDSKHhEsE4gpXNd4Z3ftWzs2sP0Uxk6ykg9NElZ9cdMcmpWdYGY6HHQzb7lMQ1/li+00fI6eOGRoi8AOAEzuZ7EACc4K7ayBQYOVJ+gbwjn7GjfjLCmZfLrw02ctk9J8ojXrPocjNtub5O8pOpCc24mp7ToiLiMT+iYi0nrNg8z84KGPS2QAvB/A249y0EsWob/rL/0aPXDuLAv5SL+alhvsoQ15PpqESgj5QIzE9RLrp9yvJpti4REFXydstzRMRjPEmFAP0zhtZ0I9JsZi3rRuOJ/pw1qaQETzsHDJf0I+C2/9jJn/OUSXCJvWUsi67T359F3jdHVZjlM3wsLANhZGcn0K3ziJROo0APe6VJcJWg/HMT06AnbQuRvLimJUa9FNvcBMWHWNcw9zrccfz4wkmjLH6aQW5IIAAPaaLuhIU+5d8io713zpjy/JjWKV6eNJkqUhC5slI4q+JhrQrpFPwKUlIn6emW9b8/vPArhFPb7ZPyc4A+A1AD5Ozs3/CwAeIaK3rhOiLysP6Adf/Yv0I09+EwNO3HTjY1ToVJVCCPISAMkrWUlCXGZS53fsQS+aLFSr+8IIJEHQNfcSC6hPsm+n3j0T5N0LRfeQ0b5SVpH3GFacoc47DQNbRT6yeZnJuVu9cWKsLEDOhRBrgqg8MkaXdcj/UmOmIz5Sp5bnOE2MDdnEANBJlKtvQN4luthNw2dofVLlqpsEbYrUueo/u54kqpGLxDqPSSaDOFcrTjVZ2UniEqbXwMXvk/XAQSfTJP47f+samWBxDDgmDehxALcS0SvhiOdeAG+TXzLznwK4KZwD0ccBfP+xRME0fuyrf44A4L1PvYWBQk0WpyOQZeRN63vmiX+v9QZ5rKu1tetVniTukFe2t9yEzeQyhOP8qwnZ5Msq6LiJJRxMwfJZes1DBNTeJwbmuS6CUqtWAWcbopSkSIY9AcF9q7xbQ4YHJETZZ4ikF9MHSlnWYKlNQ3htZ81gYqi2eCQqZ4U0E3Hc6VOaNPNrIucSUhB8e5GOTMhjmnjykb+Be0+sfdPPr7v2Ep0LUzCY8Nt37S75HFcmNDN3RPQOAI/B+egPMfPTRHQfgCeY+ZFLWfeKFaP+8Gt+gd537s2sZ0xp5KSR6zetumiujYeN4XXGgHzSDn5pjxlJzxfR0r3PfeemZLHXdIm7IXdU9y+eh3zRJdrjKtkn4fhdwfXQGyzfIFpwluPkkTIAMBMLtuQICN6vJwaMBRHQNBbGiKaVWkT6+JIzFDUn52YlxEByHqqliDWhjETSA1rRp6xx+Uidv9bK+omWf3kHSNKlHmUs1onUDcoNx9gGE2NxoZ8luUPy2RLBPPudlZuGOn8hoJ0mn2MGMz8K4NHsuXePvPaOw6x5RdtxfP+rHyv+cX/6ua8P38hS4yoAUXgsIHe7Yi/haG7n2c95WFasnYnpMVE1Xk5odol+2qTX5CGbWSfXpbrKeqyr/4qvcRYEJn22mb0FBJe0qd2cYn6LOmbPhKW30nT29JT6wXtz4tFpAm3foO1cU/eua1xUjgFwnJ/O4BC5k0F94XdMktzsXxuPGcjEz+tawulAAGBsJKqJ7+goCLlm2efQ0TmJ2Llj7bbbpTHSleaaxFWZivH2V31i9A//4Wfv4HwTR2HaJrO7hLyAGBZ3P6c1X7pVq/HRL8DCkLOAinqECjG7Y+Vf7CZYEbKue53bcLkAy0i76o0lIOroDKDJRjQfTglIvVd3Esg/U+JKFY4JAMwuOZKZBoSto3S9jSK5pATIa0p/2DENVKKAvScmOQ/p0x2uFRgrbwEBziKWdIKY5Boz7LXuJTVh2vrp+ua6IR8A10cpxpXC3/3Kjw++GA8997pwCTX56ETAQdOrkKHsROI4vM+1sNA7xUWIYudC2QC6T7P8Tr7Muqwg13OgXAvRS6zfZLrUAkhDwCVxVKJG2tIB4umXyFOITmI+cs7aitHvDa4ZotgtG1Y+m87Ktl4HCpaPP2Y46yOonoEMvZWkr2UPR6oXWhd5E7dp2qRN1ZpwE2mGxMsuuuYmoDa7r/kUcEwi9LFg6wRUwne+6teLX5gPPvtGzq0djVJVvMsL6UMGrzTX0qJ3Zxv/L5KSZPYCcUO7Y9DAFdAWhmg6ebZtDiEHLUaXRFtBXqP0NT//I+yO5xRBOaYWxPV5jQ1iDOesXqvJp7dCkul7yLuD7rMIYaYW2xjkWK0V95miliWTP+T6AbCdr473nyHkbsFZcAJX69WEnKzeGjzxjT9+XZGP/yJs+ywOjWuSgMbw3V/5y4Mv0/1P38WA6s2j6rY0tPPS2QarECnzLSCEhLQVVIgehfV4KD7r50T7kP81dCZ0Hgk7zAYOx/c/i8ajuywKShZTHi3TlpIWynV/nATBhYuRL50eIP/rcxyefxoJFGfSfX4DQwAbG9bKI4gSnctJOyR2Ml1/5ONRLaCriHf95UeLX7L/4fe+mcMwQJ8DFCNYqmk8x9dIyFY0Efk5h2gYOSnls6Mk+xfqtbpBFqv3pesoMdcf6y//H+9hvdkIOrOa3cYzNlR9S1heF5WGbpWaIDINSs5HXEX5HOIEaqJhjkWx8juNnDRKZCyI+o9/DGcNiVZk9Wv050MqZkspyG+++SeuS/IBUDWgawE//lf+98EX8Dt+6zs46RfsXStJKhSdR8b4CsqV4ZT8Pkde/yT6kEUklxxpFCvd0PmdXijBsivD6C0AmLBZ8/ozyh5rl1JbP9E6S91EQM6HFQlxYrGVNCv3mV26gC7+1NDuVu+1LImkNcZfQ04bsMlrtVjeGJvUoF2PIFQL6JrFP7v9n43eFe/61b/PuQWjw8XAeCRrTBfi7D1iETH5zQWorsxDnSUnoVwrEhKKehNCuNsCId/GpR94KiROUghydzD8X9jIuXuYWj/rxXJNOiXy5eS1migBA2VxSilFdhxDfH1qPjmYqwZ0EvHoX/8nyRf363/pBzlNeCu4XP7/4A4pstHkVbKQwoZlCresMbIJ789csByyWYWEOk96jSIdOSfAkZ9E+HIXkRQ5jYnkJYsH8C6ScreSwtSSplR4fw6tFUk+ERA1Hyc6X9/cI6gW0A7gE9/wwMZv8+2/+K6gy4iWQohtOAR6E5dyciynYmr+/RFLhwq/k/dLVrQ+Zsg01mtZM2jvGn6ndB9JEXA/x/drdys8BySuXv57WS8eY/zS5uu4z4JBxre+ntdjqH0tKgFdH/its/df1pf+r/7CD3MQqhWssoo0tMUFDAtQeytuXhpZ0usn/YoKmoy2ToSoSlqULjjVpJEQ0xrROcraESXyEeSuWEymrOSTo1pAFYfCYdtBvOaRd2/06l1EyiZWUB7izp8HhoJwTho5oeTI3aXc3RrDYT546Xiyvlg+1e3K4MzvbZ/FoVEJ6ATgcidz/qeP/hDnxLLuOxosGZ3R7bGu9q2k+eS/G0O+bonEZCCiRCCvq/KKo+Dk8E8loOsBh3VRvvZf/VDy1RUBe8wiEhSjWhvyfTTWkVpJzB4TsiscqgtWcSJxORbFVz/y7kv+2uf5Suuwi21UrzhqGL7ieoPUqmkiyreBjpYBZWtIo1SmUrEZJ+kyVQKquKLQRbOvOYJVpNMGcjdLiOrJu3+sWj47hkpAFccGEc9f88i7Obd+gDRLXP8v9V2lUH3FBjCqCF1RoZFH8aSViKDU0iT/+el7/mHlokPA1YKdHAaqBFRx1fFJ5Up9zc//COvSFQ2u5HNpqC1ZKyoOByGjkl5ExJedA3U9olpAFRVHRE40r3nk3VzJ5xJQNaCKistHJZ9LRW3HUVFRsUXUPKCKiortoVpAFRUVWwHXwYQVFRXbRLWAKioqtoaTwz+VgCoqdg01D6iiomJ7OEEEdH0PUaqo2DUwXCnGUf8dAkR0lojOE9HzRPTOwu//eyJ6koh+l4j+LRG9etOalYAqKnYIBAbx0f9tXJeoAfAhAN8I4NUAvq1AMP+Cmb+amf8qgJ8E8P5N61YCqqjYNchwwqP824zbATzPzJ9m5hWAhwHckx6W/0w9PIVDyOFVA6qoqDgMXgHgM+rxCwBem7+IiP4egO8DMAPwxk2LVguoomLXcGkW0E1E9IT693cu7dD8IWb+cgA/COCHN72+WkAVFbsEEaGPjs8z821rfv9ZALeoxzf758bwMIB/uumg1QKqqNgxHIcIDeBxALcS0SuJaAbgXgCPJMclulU9/FsAPrVp0WoBVVTsGo4hD4iZOyJ6B4DHADQAHmLmp4noPgBPMPMjAN5BRG8C0AL4AoD/ZtO6lYAqKnYKx9cPiJkfBfBo9ty71c/fc9Q1KwFVVOwSGCcqE7oSUEXFrqG246ioqNgWajFqRUXF9lAJqKKiYitgALYSUEVFxVZQp2JUVFRsE5WAKioqtoZKQBUVFVtB1YAqKiq2Bwb45CQCVQKqqNg1nCAXrFbDV1RUbA3VAqqo2CVUDaiiomKrOEEuWCWgiopdQyWgioqK7aBmQldUVGwLDMDWMHxFRcW2UC2gioqKraESUEVFxXbANQxfUVGxJTDAtRSjoqJia6gWUEVFxdZQNaCKioqtgLmG4SsqKraIagFVVFRsC1wtoIqKiu2glmJUVFRsC7UdR0VFxVZxgvKAakfEioqKraESUEXFDoEBsOUj/zsMiOgsEZ0noueJ6J2F338fEZ0jot8jon9DRF+6ac1KQBUVuwT2UzGO+m8DiKgB8CEA3wjg1QC+jYhenb3sdwDcxsx/BcDPAvjJTetWAqqo2DEckwV0O4DnmfnTzLwC8DCAe5LjMv8KMx/4h78B4OZNi1YRuqJi13A8IvQrAHxGPX4BwGvXvP5vA/g/Ny1aCaiiYofwIr7w2L/mn73pEt46J6In1OMHmfnBSzkHIvqvAdwG4A2bXlsJqKJih8DMZ49p6c8CuEU9vtk/l4CI3gTghwC8gZmXmxatGlBFRcVh8DiAW4nolUQ0A3AvgEf0C4joawH8LwDeysx/eJhFKwFVVFRsBDN3AN4B4DEAzwD4GWZ+mojuI6K3+pf9YwCnAfxLIvpdInpkZLkA4hNUN1JRUbFbqBZQRUXF1lAJqKKiYmuoBFRRUbE1VAKqqKjYGioBVVRUbA2VgCoqKraGSkAVFRVbQyWgioqKreH/B7yF7fBvZrtCAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 360x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(eopatch_pleaides.data['NDVI'][0,].astype(float),vmin = 0.2, vmax = 0.9)\n",
+    "plt.colorbar()\n",
+    "plt.axis(False);\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "eo_crops",
+   "language": "python",
+   "name": "eo_crops"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
\ No newline at end of file
diff --git a/eo-crops/examples/data_loading.py b/eo-crops/examples/data_loading.py
new file mode 100644
index 0000000..9e49914
--- /dev/null
+++ b/eo-crops/examples/data_loading.py
@@ -0,0 +1,55 @@
+import pandas as pd
+from eolearn.core import EOPatch, FeatureType, EOTask
+import numpy as np
+import os
+from eocrops.utils import data_loader
+import matplotlib.pyplot as plt
+#################################################################################
+
+#Aggregate all the EOPatch saved into a root directory into a single 3D np.array, where each observation is an aggregated multiviariate time series
+#The objective is to get a dataset for machine learning project (e.g. yield prediction) where we work at the object level (e.g. averaged time series)
+
+root_dir = '/home/johann/Documents/EOPatch samples'
+os.listdir(root_dir)
+
+#Features of EOPatch to load in the final dataset
+features_data = [
+    (FeatureType.DATA, 'LAI', 'LAI', 'float32', 1),
+    (FeatureType.DATA, 'fapar', 'fapar', 'float32', 1),
+    (FeatureType.DATA, 'Cab', 'Cab', 'float32', 1)]
+
+#Read EOPatch into a 3D np.array, where each observation is the median time series of the field
+#self = pipeline_eopatch_tfds
+pipeline_eopatch_tfds = data_loader.EOPatchDataset(
+    root_dir = root_dir, #root directory where EOPatch are saved
+    features_data=features_data, #features to read in EOPatch
+    suffix='_S2_L2A', #suffix for eopatch file names to filter out only one data source (e.g. S2_L2A). Put '' if you want to read all the files in root_dir
+    resampling = dict(start = '-01-01', end = '-12-31', day_periods = 8), #resample eopatch into 8 days period
+    range_doy=(100,300), #subset in term of doy to apply doubly logistic only on a subset period of the year
+    function=np.nanmedian #get average time series from the field
+)
+
+#Get the 3D array dataset with 'cubic' interpolation over the resampling period
+npy_eopatch = pipeline_eopatch_tfds.get_eopatch_tfds(algorithm='cubic', doubly_logistic=False)
+npy_eopatch.shape
+#Plot Cab
+plt.plot(npy_eopatch[0,20:40,1])
+plt.show()
+
+
+#Create an example of vector dataset with auxilliary data. It must have a column 'path' to match with the corresponding EOPatch
+dict_df = pd.DataFrame(
+    dict(
+        biomass = [np.random.normal(1) for k in range(len(os.listdir(root_dir)))],
+        path = [os.path.join(root_dir, k) for k in os.listdir(root_dir)]
+    )
+)
+#Features from vector file which contains auxilliary data (e.g. labels for crop classification)
+feature_vector = [
+    ('biomass', 'float32'),
+    ('path', 'string')
+]
+#Get corresponding labels from the vector file dict_df
+npy_labels = pipeline_eopatch_tfds.get_vector_tfds(vector_data=dict_df,
+                                                   features_list=feature_vector,
+                                                   column_path='path')
diff --git a/eo-crops/examples/dev_test/curve_fitting.py b/eo-crops/examples/dev_test/curve_fitting.py
new file mode 100644
index 0000000..dfd1d14
--- /dev/null
+++ b/eo-crops/examples/dev_test/curve_fitting.py
@@ -0,0 +1,44 @@
+from eolearn.core import EOPatch
+import numpy as np
+from eocrops.tasks import preprocessing
+import matplotlib.pyplot as plt
+import os
+from scipy import interpolate
+
+list_files = os.listdir('/home/johann/Documents/EOPatch samples')
+f = list_files[1]
+eopatch = EOPatch.load('/home/johann/Documents/EOPatch samples/' + f)
+
+curve_fit = preprocessing.CurveFitting(range_doy=(100, 365))
+ts_mean = curve_fit.get_time_series_profile(eopatch,feature='LAI').flatten()
+fitted = curve_fit.execute(eopatch, feature='LAI')
+doy, _ = curve_fit.get_doy_period(eopatch)
+plt.plot(doy, fitted)
+plt.plot(doy, ts_mean)
+plt.show()
+
+
+flinear = interpolate.interp1d(doy, ts_mean, kind='cubic')
+flinear_fitted = interpolate.interp1d(doy, fitted, kind='cubic')
+flinear_cspline = interpolate.Akima1DInterpolator(doy, fitted)
+
+xnew = np.arange(0, 365, 8)
+len(xnew)
+s = np.where(xnew>=doy[0])[0][0]
+e = np.where(xnew<=doy[-1])[0][-1]
+
+ylinear_ts = flinear(xnew[s:e])
+ylinear_fitted = flinear_fitted(xnew[s:e])
+ylinear_cspline = flinear_cspline(xnew[s:e])
+
+plt.plot(ylinear_ts)
+plt.plot(ylinear_fitted)
+plt.plot(ylinear_cspline)
+plt.show()
+
+before_season = np.repeat(ylinear_cspline[0], xnew[:s].shape[0])
+after_season = np.repeat(ylinear_cspline[-1], xnew[e:].shape[0])
+output = np.concatenate([before_season, ylinear_cspline, after_season],axis = 0)
+
+plt.plot(xnew, output)
+plt.show()
\ No newline at end of file
diff --git a/eo-crops/examples/dev_test/data_download.py b/eo-crops/examples/dev_test/data_download.py
new file mode 100644
index 0000000..f368373
--- /dev/null
+++ b/eo-crops/examples/dev_test/data_download.py
@@ -0,0 +1,87 @@
+
+import warnings
+
+warnings.filterwarnings("ignore")
+
+import geopandas as gpd
+from scipy.signal import savgol_filter
+
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+from eolearn.core import FeatureType
+
+from eocrops.input import utils_sh as utils_sh
+from eocrops.input import sentinel1 as sentinel1
+from eocrops.input import sentinel2 as sentinel2
+from eocrops.tasks import cmd_otb as cmd_otb
+from eocrops.tasks import preprocessing as preprocessing
+
+dir_path = os.path.dirname(os.getcwd())
+print(dir_path)
+# read microplot data
+shapefile_input = gpd.read_file(os.path.join(dir_path, 'eo-crops/examples/layers/POLYGON.shp'))
+
+api = ''
+client_id = ''
+client_secret = ''
+config = utils_sh.config_sentinelhub_cred(api, client_id, client_secret)
+# Provide here your planet API key
+config.planet_key = ''
+
+# %%
+
+time_period = ('2020-02-15', '2020-08-15')
+kwargs = dict(polygon=shapefile_input,
+              time_stamp=time_period,
+              config=config)
+
+
+
+os.getcwd()
+warnings.filterwarnings("ignore")
+patch = sentinel2.workflow_instructions_S2L2A(**kwargs,
+                                              path_out='/home/johann/Documents/patch',  # you can specify here a path to save the EOPatch object
+                                              coverage_predicate=0.5,
+                                              interpolation={'interpolate': True, 'period_length' : 8})
+
+
+
+s1_eopatch = sentinel1.workflow_instructions_S1IW(**kwargs,
+                                                  speckle_lee_window = 3,
+                                                  orbit_direction = 'ASC',
+                                                  backCoeff = 'SIGMA0_ELLIPSOID' )
+
+#%%
+
+#Compute Radar Vegetation Index
+VV = s1_eopatch.data['BANDS-S1-IW'][...,0]
+VH =  s1_eopatch.data['BANDS-S1-IW'][...,1]
+RVI = (4*VH)/(VH+VV)
+
+
+#%%
+from eolearn.core import AddFeatureTask
+#Add the feature to the EOPatch
+add_rvi = AddFeatureTask((FeatureType.DATA, "RVI"))
+add_rvi.execute(eopatch = s1_eopatch, data = RVI[..., np.newaxis])
+masking = preprocessing.MaskPixels([ "RVI"])
+s1_eopatch = masking.execute(s1_eopatch)
+
+#%%
+
+#Display RVI from SIGMA0 without any speckle filtering
+s1_eopatch = masking.execute(s1_eopatch)
+plt.figure(figsize=(5, 5))
+plt.imshow(s1_eopatch.data['RVI'][15,].squeeze());
+plt.axis(False);
+plt.show()
+
+
+#%%
+
+#Can take around 30 seconds
+mutlitemp = cmd_otb.MultitempSpeckleFiltering(otb_path = '/home/johann/Documents/OTB/OTB-8.0.1-Linux64/bin',
+                                             window = 3)
+self = mutlitemp
+s1_eopatch = mutlitemp.execute(s1_eopatch)
diff --git a/eo-crops/examples/layers/POLYGON.dbf b/eo-crops/examples/layers/POLYGON.dbf
new file mode 100644
index 0000000..2690181
Binary files /dev/null and b/eo-crops/examples/layers/POLYGON.dbf differ
diff --git a/eo-crops/examples/layers/POLYGON.prj b/eo-crops/examples/layers/POLYGON.prj
new file mode 100644
index 0000000..a30c00a
--- /dev/null
+++ b/eo-crops/examples/layers/POLYGON.prj
@@ -0,0 +1 @@
+GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]
\ No newline at end of file
diff --git a/eo-crops/examples/layers/POLYGON.shp b/eo-crops/examples/layers/POLYGON.shp
new file mode 100644
index 0000000..4e489ec
Binary files /dev/null and b/eo-crops/examples/layers/POLYGON.shp differ
diff --git a/eo-crops/examples/layers/POLYGON.shx b/eo-crops/examples/layers/POLYGON.shx
new file mode 100644
index 0000000..462d4d3
Binary files /dev/null and b/eo-crops/examples/layers/POLYGON.shx differ
diff --git a/eo-crops/examples/layers/burkina_dataframe.csv b/eo-crops/examples/layers/burkina_dataframe.csv
new file mode 100644
index 0000000..71e7154
--- /dev/null
+++ b/eo-crops/examples/layers/burkina_dataframe.csv
@@ -0,0 +1,193 @@
+Aggregation,Annee,Variable,Id_location,Latitude,Longitude
+cumul,2010,RG,200026,14.0333,-0.0333
+mean,2010,Wind,200026,14.0333,-0.0333
+cumul,2010,Precipitation,200026,14.0333,-0.0333
+min,2010,Min Temperature,200026,14.0333,-0.0333
+mean,2010,Mean Temperature,200026,14.0333,-0.0333
+max,2010,Max Temperature,200026,14.0333,-0.0333
+cumul,2010,RG,200107,11.7333,-2.9167
+mean,2010,Wind,200107,11.7333,-2.9167
+cumul,2010,Precipitation,200107,11.7333,-2.9167
+min,2010,Min Temperature,200107,11.7333,-2.9167
+mean,2010,Mean Temperature,200107,11.7333,-2.9167
+max,2010,Max Temperature,200107,11.7333,-2.9167
+cumul,2010,RG,200140,10.3333,-3.1833
+mean,2010,Wind,200140,10.3333,-3.1833
+cumul,2010,Precipitation,200140,10.3333,-3.1833
+min,2010,Min Temperature,200140,10.3333,-3.1833
+mean,2010,Mean Temperature,200140,10.3333,-3.1833
+max,2010,Max Temperature,200140,10.3333,-3.1833
+cumul,2010,RG,200099,11.1667,-4.3
+mean,2010,Wind,200099,11.1667,-4.3
+cumul,2010,Precipitation,200099,11.1667,-4.3
+min,2010,Min Temperature,200099,11.1667,-4.3
+mean,2010,Mean Temperature,200099,11.1667,-4.3
+max,2010,Max Temperature,200099,11.1667,-4.3
+cumul,2010,RG,200089,12.0667,0.35
+mean,2010,Wind,200089,12.0667,0.35
+cumul,2010,Precipitation,200089,12.0667,0.35
+min,2010,Min Temperature,200089,12.0667,0.35
+mean,2010,Mean Temperature,200089,12.0667,0.35
+max,2010,Max Temperature,200089,12.0667,0.35
+cumul,2010,RG,200133,11.25,0.7
+mean,2010,Wind,200133,11.25,0.7
+cumul,2010,Precipitation,200133,11.25,0.7
+min,2010,Min Temperature,200133,11.25,0.7
+mean,2010,Mean Temperature,200133,11.25,0.7
+max,2010,Max Temperature,200133,11.25,0.7
+cumul,2010,RG,200125,11.4833,-3.5167
+mean,2010,Wind,200125,11.4833,-3.5167
+cumul,2010,Precipitation,200125,11.4833,-3.5167
+min,2010,Min Temperature,200125,11.4833,-3.5167
+mean,2010,Mean Temperature,200125,11.4833,-3.5167
+max,2010,Max Temperature,200125,11.4833,-3.5167
+cumul,2010,RG,200001,12.35,-2.1833
+mean,2010,Wind,200001,12.35,-2.1833
+cumul,2010,Precipitation,200001,12.35,-2.1833
+min,2010,Min Temperature,200001,12.35,-2.1833
+mean,2010,Mean Temperature,200001,12.35,-2.1833
+max,2010,Max Temperature,200001,12.35,-2.1833
+cumul,2011,RG,200026,14.0333,-0.0333
+mean,2011,Wind,200026,14.0333,-0.0333
+cumul,2011,Precipitation,200026,14.0333,-0.0333
+min,2011,Min Temperature,200026,14.0333,-0.0333
+mean,2011,Mean Temperature,200026,14.0333,-0.0333
+max,2011,Max Temperature,200026,14.0333,-0.0333
+cumul,2011,RG,200107,11.7333,-2.9167
+mean,2011,Wind,200107,11.7333,-2.9167
+cumul,2011,Precipitation,200107,11.7333,-2.9167
+min,2011,Min Temperature,200107,11.7333,-2.9167
+mean,2011,Mean Temperature,200107,11.7333,-2.9167
+max,2011,Max Temperature,200107,11.7333,-2.9167
+cumul,2011,RG,200140,10.3333,-3.1833
+mean,2011,Wind,200140,10.3333,-3.1833
+cumul,2011,Precipitation,200140,10.3333,-3.1833
+min,2011,Min Temperature,200140,10.3333,-3.1833
+mean,2011,Mean Temperature,200140,10.3333,-3.1833
+max,2011,Max Temperature,200140,10.3333,-3.1833
+cumul,2011,RG,200099,11.1667,-4.3
+mean,2011,Wind,200099,11.1667,-4.3
+cumul,2011,Precipitation,200099,11.1667,-4.3
+min,2011,Min Temperature,200099,11.1667,-4.3
+mean,2011,Mean Temperature,200099,11.1667,-4.3
+max,2011,Max Temperature,200099,11.1667,-4.3
+cumul,2011,RG,200089,12.0667,0.35
+mean,2011,Wind,200089,12.0667,0.35
+cumul,2011,Precipitation,200089,12.0667,0.35
+min,2011,Min Temperature,200089,12.0667,0.35
+mean,2011,Mean Temperature,200089,12.0667,0.35
+max,2011,Max Temperature,200089,12.0667,0.35
+cumul,2011,RG,200133,11.25,0.7
+mean,2011,Wind,200133,11.25,0.7
+cumul,2011,Precipitation,200133,11.25,0.7
+min,2011,Min Temperature,200133,11.25,0.7
+mean,2011,Mean Temperature,200133,11.25,0.7
+max,2011,Max Temperature,200133,11.25,0.7
+cumul,2011,RG,200125,11.4833,-3.5167
+mean,2011,Wind,200125,11.4833,-3.5167
+cumul,2011,Precipitation,200125,11.4833,-3.5167
+min,2011,Min Temperature,200125,11.4833,-3.5167
+mean,2011,Mean Temperature,200125,11.4833,-3.5167
+max,2011,Max Temperature,200125,11.4833,-3.5167
+cumul,2011,RG,200001,12.35,-2.1833
+mean,2011,Wind,200001,12.35,-2.1833
+cumul,2011,Precipitation,200001,12.35,-2.1833
+min,2011,Min Temperature,200001,12.35,-2.1833
+mean,2011,Mean Temperature,200001,12.35,-2.1833
+max,2011,Max Temperature,200001,12.35,-2.1833
+cumul,2012,RG,200026,14.0333,-0.0333
+mean,2012,Wind,200026,14.0333,-0.0333
+cumul,2012,Precipitation,200026,14.0333,-0.0333
+min,2012,Min Temperature,200026,14.0333,-0.0333
+mean,2012,Mean Temperature,200026,14.0333,-0.0333
+max,2012,Max Temperature,200026,14.0333,-0.0333
+cumul,2012,RG,200107,11.7333,-2.9167
+mean,2012,Wind,200107,11.7333,-2.9167
+cumul,2012,Precipitation,200107,11.7333,-2.9167
+min,2012,Min Temperature,200107,11.7333,-2.9167
+mean,2012,Mean Temperature,200107,11.7333,-2.9167
+max,2012,Max Temperature,200107,11.7333,-2.9167
+cumul,2012,RG,200140,10.3333,-3.1833
+mean,2012,Wind,200140,10.3333,-3.1833
+cumul,2012,Precipitation,200140,10.3333,-3.1833
+min,2012,Min Temperature,200140,10.3333,-3.1833
+mean,2012,Mean Temperature,200140,10.3333,-3.1833
+max,2012,Max Temperature,200140,10.3333,-3.1833
+cumul,2012,RG,200099,11.1667,-4.3
+mean,2012,Wind,200099,11.1667,-4.3
+cumul,2012,Precipitation,200099,11.1667,-4.3
+min,2012,Min Temperature,200099,11.1667,-4.3
+mean,2012,Mean Temperature,200099,11.1667,-4.3
+max,2012,Max Temperature,200099,11.1667,-4.3
+cumul,2012,RG,200089,12.0667,0.35
+mean,2012,Wind,200089,12.0667,0.35
+cumul,2012,Precipitation,200089,12.0667,0.35
+min,2012,Min Temperature,200089,12.0667,0.35
+mean,2012,Mean Temperature,200089,12.0667,0.35
+max,2012,Max Temperature,200089,12.0667,0.35
+cumul,2012,RG,200133,11.25,0.7
+mean,2012,Wind,200133,11.25,0.7
+cumul,2012,Precipitation,200133,11.25,0.7
+min,2012,Min Temperature,200133,11.25,0.7
+mean,2012,Mean Temperature,200133,11.25,0.7
+max,2012,Max Temperature,200133,11.25,0.7
+cumul,2012,RG,200125,11.4833,-3.5167
+mean,2012,Wind,200125,11.4833,-3.5167
+cumul,2012,Precipitation,200125,11.4833,-3.5167
+min,2012,Min Temperature,200125,11.4833,-3.5167
+mean,2012,Mean Temperature,200125,11.4833,-3.5167
+max,2012,Max Temperature,200125,11.4833,-3.5167
+cumul,2012,RG,200001,12.35,-2.1833
+mean,2012,Wind,200001,12.35,-2.1833
+cumul,2012,Precipitation,200001,12.35,-2.1833
+min,2012,Min Temperature,200001,12.35,-2.1833
+mean,2012,Mean Temperature,200001,12.35,-2.1833
+max,2012,Max Temperature,200001,12.35,-2.1833
+cumul,2013,RG,200026,14.0333,-0.0333
+mean,2013,Wind,200026,14.0333,-0.0333
+cumul,2013,Precipitation,200026,14.0333,-0.0333
+min,2013,Min Temperature,200026,14.0333,-0.0333
+mean,2013,Mean Temperature,200026,14.0333,-0.0333
+max,2013,Max Temperature,200026,14.0333,-0.0333
+cumul,2013,RG,200107,11.7333,-2.9167
+mean,2013,Wind,200107,11.7333,-2.9167
+cumul,2013,Precipitation,200107,11.7333,-2.9167
+min,2013,Min Temperature,200107,11.7333,-2.9167
+mean,2013,Mean Temperature,200107,11.7333,-2.9167
+max,2013,Max Temperature,200107,11.7333,-2.9167
+cumul,2013,RG,200140,10.3333,-3.1833
+mean,2013,Wind,200140,10.3333,-3.1833
+cumul,2013,Precipitation,200140,10.3333,-3.1833
+min,2013,Min Temperature,200140,10.3333,-3.1833
+mean,2013,Mean Temperature,200140,10.3333,-3.1833
+max,2013,Max Temperature,200140,10.3333,-3.1833
+cumul,2013,RG,200099,11.1667,-4.3
+mean,2013,Wind,200099,11.1667,-4.3
+cumul,2013,Precipitation,200099,11.1667,-4.3
+min,2013,Min Temperature,200099,11.1667,-4.3
+mean,2013,Mean Temperature,200099,11.1667,-4.3
+max,2013,Max Temperature,200099,11.1667,-4.3
+cumul,2013,RG,200089,12.0667,0.35
+mean,2013,Wind,200089,12.0667,0.35
+cumul,2013,Precipitation,200089,12.0667,0.35
+min,2013,Min Temperature,200089,12.0667,0.35
+mean,2013,Mean Temperature,200089,12.0667,0.35
+max,2013,Max Temperature,200089,12.0667,0.35
+cumul,2013,RG,200133,11.25,0.7
+mean,2013,Wind,200133,11.25,0.7
+cumul,2013,Precipitation,200133,11.25,0.7
+min,2013,Min Temperature,200133,11.25,0.7
+mean,2013,Mean Temperature,200133,11.25,0.7
+max,2013,Max Temperature,200133,11.25,0.7
+cumul,2013,RG,200125,11.4833,-3.5167
+mean,2013,Wind,200125,11.4833,-3.5167
+cumul,2013,Precipitation,200125,11.4833,-3.5167
+min,2013,Min Temperature,200125,11.4833,-3.5167
+mean,2013,Mean Temperature,200125,11.4833,-3.5167
+max,2013,Max Temperature,200125,11.4833,-3.5167
+cumul,2013,RG,200001,12.35,-2.1833
+mean,2013,Wind,200001,12.35,-2.1833
+cumul,2013,Precipitation,200001,12.35,-2.1833
+min,2013,Min Temperature,200001,12.35,-2.1833
+mean,2013,Mean Temperature,200001,12.35,-2.1833
+max,2013,Max Temperature,200001,12.35,-2.1833
diff --git a/eo-crops/examples/weather_data.py b/eo-crops/examples/weather_data.py
new file mode 100644
index 0000000..2fb418b
--- /dev/null
+++ b/eo-crops/examples/weather_data.py
@@ -0,0 +1,80 @@
+
+import pandas as pd
+from eocrops.input.meteoblue import WeatherDownload, WeatherPostprocess
+
+###############################################################################################################
+#Read the file
+input_file = pd.read_csv('./examples/layers/burkina_dataframe.csv')
+input_file['coordinates'] = list(
+    zip(input_file['Longitude'], input_file['Latitude'])
+)
+
+input_file['Id_location'] = input_file['Id_location'].astype(str)
+input_file = input_file[input_file['Aggregation'].isin(['mean'])]
+
+###############################################################################################################
+#Step 1 : Define the query with a backbone (=units, jobs parameters) and your input file features (locations,..)
+###############################################################################################################
+
+queryBackbone = {
+        "units": {
+        "temperature": "C",
+        "velocity": "km/h",
+        "length": "metric",
+        "energy": "watts"
+    },
+    "timeIntervalsAlignment": None,
+    "runOnJobQueue": True,
+    "oneTimeIntervalPerGeometry": True,
+    "checkOnly": False,
+    "requiresJobQueue": False,
+    "geometry": {
+        "type": "GeometryCollection",
+        "geometries": None
+    },
+    "format": "csvIrregular", # best format
+    "timeIntervals":  None
+}
+
+
+pipeline_cehub = WeatherDownload(api_key ='',
+                                 queryBackbone = queryBackbone,
+                                 ids = input_file['Id_location'].values,
+                                 coordinates=  input_file['coordinates'].values,
+                                 years = input_file['Annee'].values)
+
+stat = 'mean'
+
+query = [{"domain": "ERA5", "gapFillDomain": "NEMS4",
+          "timeResolution": "daily",
+          "codes": [
+              {"code": 52, "level": "2 m above gnd", "aggregation": stat},  # Relative Humidity
+              {"code":  11, "level": "2 m above gnd", "aggregation": stat}, # air temperature (°C)
+              {"code":  32, "level": "2 m above gnd", "aggregation": stat}, # Wind Speed
+              {"code": 180, "level": "sfc", "aggregation": stat}, #wind gust
+              {"code":  256, "level": "sfc","aggregation": stat}, # Diffuse Shortwave Radiation
+              {"code":  56, "level": "2 m above gnd","aggregation": stat}, # Vapor Pressure Deficit
+              {"code":  260, "level": "2 m above gnd","aggregation": stat}, # FAO Reference Evapotranspiration,
+              {"code":  261, "level": "sfc", "aggregation": stat}, # Evapotranspiration
+              {"code":  52, "level": "2 m above gnd","aggregation": stat}, # Relative humidity
+          ],
+}]
+
+df_output = pipeline_cehub.execute(query = query,  time_interval = ('01-01', '12-31'))
+df_output.to_csv('./examples/layers/mean_meteoblue.csv', index = False)
+
+###############################################################################################################
+#Step 2 : reformat file given a resampling range (e.g. every 8 days from the 1st of January into 31 of December
+###############################################################################################################
+
+df_output = pd.read_csv('./examples/layers/mean_meteoblue.csv', skiprows=1)
+
+
+pipeline_refactor = WeatherPostprocess(
+    input_file = input_file,
+    id_column = 'Id_location',
+    year_column = 'Annee',
+    resample_range=('-01-01', '-12-31', 1)
+)
+
+df_mean = pipeline_refactor.execute(df_weather=df_output, stat='mean', return_pivot=False)
diff --git a/eo-crops/readme.MD b/eo-crops/readme.MD
new file mode 100644
index 0000000..36c4229
--- /dev/null
+++ b/eo-crops/readme.MD
@@ -0,0 +1,36 @@
+Earth observations for crop monitoring. 
+
+
+Small python module that brings together awesome functionality from Sentinelhub, eo-learn python package and OrfeoToolBox for basic downloading and data processing.
+
+# Installation
+
+To install the package, you must first clone the git repository to the desired folder
+
+```bash
+git clone git@github.com:j-desloires/eo-crops.git
+```
+
+Then, open Anaconda prompt and create the environment from environment.yml
+
+```
+cd eo-crops
+conda env create -f environment.yml
+conda activate eo-crops
+pip install .
+```
+
+
+If you want to run a jupyter notebook, you need to install jupyter on the environment. Then, you will be able to select the kernel.
+
+```
+conda install -c anaconda ipykernel -y
+python -m ipykernel install --user --name=eo-crops
+jupyter notebook
+```
+
+# Dependencies
+
+You should have OrfeoToolBox installed (https://www.orfeo-toolbox.org/CookBook/Installation.html) if you would like to apply pansharpening and multitemporal speckle filtering (Quegan). 
+
+Also, you should have a Sentinelhub account with credentials. The latter can be sponsored using Network of Resources program https://www.sentinel-hub.com/Network-of-Resources/.
diff --git a/eo-crops/requirements.txt b/eo-crops/requirements.txt
new file mode 100644
index 0000000..df64e00
--- /dev/null
+++ b/eo-crops/requirements.txt
@@ -0,0 +1,11 @@
+pathlib
+datetime
+notebook
+aoihttp
+pandas>=0.23.1
+setuptools>=57.0.0
+scipy>=0.19
+matplotlib>=2.2.2
+seaborn>=0.9.0
+protobuf==3.20.0
+fs==2.4.14
diff --git a/eo-crops/setup.py b/eo-crops/setup.py
new file mode 100644
index 0000000..56c1d2a
--- /dev/null
+++ b/eo-crops/setup.py
@@ -0,0 +1,21 @@
+import os
+from setuptools import setup, find_packages
+
+
+def parse_requirements(file):
+    return sorted(set(
+        line.partition('#')[0].strip()
+        for line in open(os.path.join(os.path.dirname(__file__), file))
+    ) - set(''))
+
+
+setup(
+    name='eocrops',
+    python_requires='>=3.7',
+    version='1.0.0',
+    description='Wrapper designed for crop monitoring using Earth Observation data.',
+    author='Johann Desloires',
+    author_email='johann.desloires@gmail.com',
+    packages=find_packages(),
+    package_data={'eocrops': ['environment.yml']}
+)