From 6d1e1c3297e3e756180ae99fcfe2b7e62c9ec7b9 Mon Sep 17 00:00:00 2001
From: Caleb Robinson <calebrob6@gmail.com>
Date: Wed, 21 Jul 2021 01:49:56 +0000
Subject: [PATCH 1/9] temp commit for the SEN12MS trainer

---
 torchgeo/trainers/sen12ms.py | 232 +++++++++++++++++++++++++++++++++++
 1 file changed, 232 insertions(+)
 create mode 100644 torchgeo/trainers/sen12ms.py

diff --git a/torchgeo/trainers/sen12ms.py b/torchgeo/trainers/sen12ms.py
new file mode 100644
index 00000000000..ee3fc7b8f4f
--- /dev/null
+++ b/torchgeo/trainers/sen12ms.py
@@ -0,0 +1,232 @@
+"""SEN12MS trainer."""
+
+from typing import Any, Dict, Optional
+
+import pytorch_lightning as pl
+import torch
+import torch.nn.functional as F
+from sklearn.model_selection import GroupShuffleSplit
+from torch import Tensor
+from torch.nn.modules import Module
+from torch.optim.lr_scheduler import ReduceLROnPlateau
+from torch.utils.data import DataLoader, Subset
+
+from ..datasets import TropicalCycloneWindEstimation
+
+# https://github.com/pytorch/pytorch/issues/60979
+# https://github.com/pytorch/pytorch/pull/61045
+DataLoader.__module__ = "torch.utils.data"
+Module.__module__ = "torch.nn"
+
+
+class SEN12MSSegmentationTask(pl.LightningModule):
+    """LightningModule for training models on the SEN12MS Dataset.
+
+    This allows using arbitrary models and losses from the pytorch_segmentation_models
+    package.
+    """
+
+    def __init__(self, model: Module, **kwargs: Dict[str, Any]) -> None:
+        """Initialize the LightningModule and sets up model and loss.
+
+        Args:
+            model: A model (specifically, a ``nn.Module``) instance to be trained.
+        """
+        super().__init__()
+        self.save_hyperparameters()  # creates `self.hparams` from kwargs
+        self.model = model
+
+    def forward(self, x: Tensor) -> Any:  # type: ignore[override]
+        """Forward pass of the model."""
+        return self.model(x)
+
+    def training_step(  # type: ignore[override]
+        self, batch: Dict[str, Any], batch_idx: int
+    ) -> Tensor:
+        """Training step with an MSE loss. Reports MSE and RMSE."""
+        x = batch["image"]
+        y = batch["wind_speed"].view(-1, 1)
+        y_hat = self.forward(x)
+
+        loss = F.mse_loss(y_hat, y)
+
+        self.log("train_loss", loss)  # logging to TensorBoard
+
+        rmse = torch.sqrt(loss)  # type: ignore[attr-defined]
+        self.log("train_rmse", rmse)
+
+        return loss
+
+    def validation_step(  # type: ignore[override]
+        self, batch: Dict[str, Any], batch_idx: int
+    ) -> None:
+        """Validation step - reports MSE and RMSE."""
+        x = batch["image"]
+        y = batch["wind_speed"].view(-1, 1)
+        y_hat = self.forward(x)
+
+        loss = F.mse_loss(y_hat, y)
+        self.log("val_loss", loss)
+
+        rmse = torch.sqrt(loss)  # type: ignore[attr-defined]
+        self.log("val_rmse", rmse)
+
+    def test_step(  # type: ignore[override]
+        self, batch: Dict[str, Any], batch_idx: int
+    ) -> None:
+        """Test step identical to the validation step. Reports MSE and RMSE."""
+        x = batch["image"]
+        y = batch["wind_speed"].view(-1, 1)
+        y_hat = self.forward(x)
+
+        loss = F.mse_loss(y_hat, y)
+        self.log("test_loss", loss)
+
+        rmse = torch.sqrt(loss)  # type: ignore[attr-defined]
+        self.log("test_rmse", rmse)
+
+    def configure_optimizers(self) -> Dict[str, Any]:
+        """Initialize the optimizer and learning rate scheduler."""
+        optimizer = torch.optim.Adam(
+            self.model.parameters(),
+            lr=self.hparams["learning_rate"],  # type: ignore[index]
+        )
+        return {
+            "optimizer": optimizer,
+            "lr_scheduler": {
+                "scheduler": ReduceLROnPlateau(
+                    optimizer,
+                    patience=self.hparams[
+                        "learning_rate_schedule_patience"
+                    ],  # type: ignore[index]
+                ),
+                "monitor": "val_loss",
+            },
+        }
+
+
+class SEN12MSDataModule(pl.LightningDataModule):
+    """LightningDataModule implementation for the SEN12MS dataset.
+
+    Implements 80/20 random train/val splits and uses the test split from the dataset.
+    See :func:`setup` for more details.
+    """
+
+    def __init__(
+        self,
+        root_dir: str,
+        batch_size: int = 64,
+        num_workers: int = 4,
+        api_key: Optional[str] = None,
+    ) -> None:
+        """Initialize a LightningDataModule for SEN12MS based DataLoaders.
+
+        Args:
+            root_dir: The ``root`` arugment to pass to the SEN12MS Dataset classes
+            batch_size: The batch size to use in all created DataLoaders
+            num_workers: The number of workers to use in all created DataLoaders
+            api_key: The RadiantEarth MLHub API key to use if the dataset needs to be
+                downloaded
+        """
+        super().__init__()  # type: ignore[no-untyped-call]
+        self.root_dir = root_dir
+        self.seed = seed
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+        self.api_key = api_key
+
+    # TODO: This needs to be converted to actual transforms instead of hacked
+    def custom_transform(self, sample: Dict[str, Any]) -> Dict[str, Any]:
+        """Transform a single sample from the Dataset."""
+        sample["image"] = sample["image"] / 255.0  # scale to [0,1]
+        sample["image"] = (
+            sample["image"].unsqueeze(0).repeat(3, 1, 1)
+        )  # convert to 3 channel
+        sample["wind_speed"] = torch.as_tensor(  # type: ignore[attr-defined]
+            sample["wind_speed"]
+        ).float()
+
+        return sample
+
+    def prepare_data(self) -> None:
+        """Initialize the main ``Dataset`` objects for use in :func:`setup`.
+
+        This includes optionally downloading the dataset. This is done once per node,
+        while :func:`setup` is done once per GPU.
+        """
+        do_download = self.api_key is not None
+        self.all_train_dataset = TropicalCycloneWindEstimation(
+            self.root_dir,
+            split="train",
+            transforms=self.custom_transform,
+            download=do_download,
+            api_key=self.api_key,
+        )
+
+        self.all_test_dataset = TropicalCycloneWindEstimation(
+            self.root_dir,
+            split="test",
+            transforms=self.custom_transform,
+            download=do_download,
+            api_key=self.api_key,
+        )
+
+    def setup(self, stage: Optional[str] = None) -> None:
+        """Create the train/val/test splits based on the original Dataset objects.
+
+        The splits should be done here vs. in :func:`__init__` per the docs:
+        https://pytorch-lightning.readthedocs.io/en/latest/extensions/datamodules.html#setup.
+
+        We split samples between train/val by the ``storm_id`` property. I.e. all
+        samples with the same ``storm_id`` value will be either in the train or the val
+        split. This is important to test one type of generalizability -- given a new
+        storm, can we predict its windspeed. The test set, however, contains *some*
+        storms from the training set (specifically, the latter parts of the storms) as
+        well as some novel storms.
+        """
+        storm_ids = []
+        for item in self.all_train_dataset.collection:
+            storm_id = item["href"].split("/")[0].split("_")[-2]
+            storm_ids.append(storm_id)
+
+        train_indices, val_indices = next(
+            GroupShuffleSplit(test_size=0.2, n_splits=2, random_state=self.seed).split(
+                storm_ids, groups=storm_ids
+            )
+        )
+
+        self.train_dataset = Subset(self.all_train_dataset, train_indices)
+        self.val_dataset = Subset(self.all_train_dataset, val_indices)
+        self.test_dataset = Subset(
+            self.all_test_dataset, range(len(self.all_test_dataset))
+        )
+
+    def train_dataloader(self) -> DataLoader[Any]:
+        """Return a DataLoader for training."""
+        return DataLoader(
+            self.train_dataset,
+            batch_size=self.batch_size,
+            num_workers=self.num_workers,
+            shuffle=True,
+            pin_memory=True,
+        )
+
+    def val_dataloader(self) -> DataLoader[Any]:
+        """Return a DataLoader for validation."""
+        return DataLoader(
+            self.val_dataset,
+            batch_size=self.batch_size,
+            num_workers=self.num_workers,
+            shuffle=False,
+            pin_memory=True,
+        )
+
+    def test_dataloader(self) -> DataLoader[Any]:
+        """Return a DataLoader for testing."""
+        return DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            num_workers=self.num_workers,
+            shuffle=False,
+            pin_memory=True,
+        )

From 84b6d014eacecea0e8b089e2cd605e029978ccc6 Mon Sep 17 00:00:00 2001
From: Caleb Robinson <calebrob6@gmail.com>
Date: Wed, 21 Jul 2021 05:34:15 +0000
Subject: [PATCH 2/9] Adding SEN12MS training task

---
 torchgeo/datasets/sen12ms.py  |   7 +-
 torchgeo/trainers/__init__.py |   8 ++-
 torchgeo/trainers/sen12ms.py  | 125 ++++++++++++++++++++--------------
 train.py                      |  58 +++++++++++++---
 4 files changed, 133 insertions(+), 65 deletions(-)

diff --git a/torchgeo/datasets/sen12ms.py b/torchgeo/datasets/sen12ms.py
index 5ab8cb2acb9..d9aa3a06130 100644
--- a/torchgeo/datasets/sen12ms.py
+++ b/torchgeo/datasets/sen12ms.py
@@ -136,7 +136,10 @@ def __init__(
                 raise RuntimeError("Dataset not found or corrupted.")
 
         with open(os.path.join(self.root, self.base_folder, split + "_list.txt")) as f:
-            self.ids = f.readlines()
+            self.ids = [
+                line.rstrip()
+                for line in f.readlines()
+            ]
 
     def __getitem__(self, index: int) -> Dict[str, Tensor]:
         """Return an index within the dataset.
@@ -147,7 +150,7 @@ def __getitem__(self, index: int) -> Dict[str, Tensor]:
         Returns:
             data and label at that index
         """
-        filename = self.ids[index].rstrip()
+        filename = self.ids[index]
 
         lc = self._load_raster(filename, "lc")
         s1 = self._load_raster(filename, "s1")
diff --git a/torchgeo/trainers/__init__.py b/torchgeo/trainers/__init__.py
index 6b6735b67d9..773d9be4c5c 100644
--- a/torchgeo/trainers/__init__.py
+++ b/torchgeo/trainers/__init__.py
@@ -1,8 +1,14 @@
 """TorchGeo trainers."""
 
 from .cyclone import CycloneDataModule, CycloneSimpleRegressionTask
+from .sen12ms import SEN12MSDataModule, SEN12MSSegmentationTask
 
-__all__ = ("CycloneDataModule", "CycloneSimpleRegressionTask")
+__all__ = (
+    "CycloneDataModule",
+    "CycloneSimpleRegressionTask",
+    "SEN12MSDataModule",
+    "SEN12MSSegmentationTask"
+)
 
 # https://stackoverflow.com/questions/40018681
 for module in __all__:
diff --git a/torchgeo/trainers/sen12ms.py b/torchgeo/trainers/sen12ms.py
index ee3fc7b8f4f..e348232a49c 100644
--- a/torchgeo/trainers/sen12ms.py
+++ b/torchgeo/trainers/sen12ms.py
@@ -1,7 +1,6 @@
 """SEN12MS trainer."""
 
 from typing import Any, Dict, Optional
-
 import pytorch_lightning as pl
 import torch
 import torch.nn.functional as F
@@ -11,7 +10,7 @@
 from torch.optim.lr_scheduler import ReduceLROnPlateau
 from torch.utils.data import DataLoader, Subset
 
-from ..datasets import TropicalCycloneWindEstimation
+from ..datasets import SEN12MS
 
 # https://github.com/pytorch/pytorch/issues/60979
 # https://github.com/pytorch/pytorch/pull/61045
@@ -26,8 +25,8 @@ class SEN12MSSegmentationTask(pl.LightningModule):
     package.
     """
 
-    def __init__(self, model: Module, **kwargs: Dict[str, Any]) -> None:
-        """Initialize the LightningModule and sets up model and loss.
+    def __init__(self, model: Module, loss: Module, **kwargs: Dict[str, Any]) -> None:
+        """Initialize the LightningModule with a model and loss function.
 
         Args:
             model: A model (specifically, a ``nn.Module``) instance to be trained.
@@ -45,16 +44,12 @@ def training_step(  # type: ignore[override]
     ) -> Tensor:
         """Training step with an MSE loss. Reports MSE and RMSE."""
         x = batch["image"]
-        y = batch["wind_speed"].view(-1, 1)
+        y = batch["mask"]
         y_hat = self.forward(x)
 
-        loss = F.mse_loss(y_hat, y)
-
+        loss = F.cross_entropy(y_hat, y)
         self.log("train_loss", loss)  # logging to TensorBoard
 
-        rmse = torch.sqrt(loss)  # type: ignore[attr-defined]
-        self.log("train_rmse", rmse)
-
         return loss
 
     def validation_step(  # type: ignore[override]
@@ -62,29 +57,23 @@ def validation_step(  # type: ignore[override]
     ) -> None:
         """Validation step - reports MSE and RMSE."""
         x = batch["image"]
-        y = batch["wind_speed"].view(-1, 1)
+        y = batch["mask"]
         y_hat = self.forward(x)
 
-        loss = F.mse_loss(y_hat, y)
+        loss = F.cross_entropy(y_hat, y)
         self.log("val_loss", loss)
 
-        rmse = torch.sqrt(loss)  # type: ignore[attr-defined]
-        self.log("val_rmse", rmse)
-
     def test_step(  # type: ignore[override]
         self, batch: Dict[str, Any], batch_idx: int
     ) -> None:
-        """Test step identical to the validation step. Reports MSE and RMSE."""
+        """Test step identical to the validation step."""
         x = batch["image"]
-        y = batch["wind_speed"].view(-1, 1)
+        y = batch["mask"]
         y_hat = self.forward(x)
 
-        loss = F.mse_loss(y_hat, y)
+        loss = F.cross_entropy(y_hat, y)
         self.log("test_loss", loss)
 
-        rmse = torch.sqrt(loss)  # type: ignore[attr-defined]
-        self.log("test_rmse", rmse)
-
     def configure_optimizers(self) -> Dict[str, Any]:
         """Initialize the optimizer and learning rate scheduler."""
         optimizer = torch.optim.Adam(
@@ -108,13 +97,40 @@ def configure_optimizers(self) -> Dict[str, Any]:
 class SEN12MSDataModule(pl.LightningDataModule):
     """LightningDataModule implementation for the SEN12MS dataset.
 
-    Implements 80/20 random train/val splits and uses the test split from the dataset.
-    See :func:`setup` for more details.
+    Implements 80/20 geographic train/val splits and uses the test split from the
+    classification dataset definitions. See :func:`setup` for more details.
+
+    Uses the Simplified IGBP scheme defined in the 2020 Data Fusion Competition. See
+    https://arxiv.org/abs/2002.08254.
     """
 
+    # Mapping from the IGBP class definitions to the DFC2020, taken from the dataloader
+    # here https://github.com/lukasliebel/dfc2020_baseline.
+    DFC2020_CLASS_MAPPING = torch.tensor([
+        0,  # maps 0s to 0
+        1,  # maps 1s to 1
+        1,  # maps 2s to 1
+        1,  # ...
+        1,
+        1,
+        2,
+        2,
+        3,
+        3,
+        4,
+        5,
+        6,
+        7,
+        6,
+        8,
+        9,
+        10
+    ])
+
     def __init__(
         self,
         root_dir: str,
+        seed: int,
         batch_size: int = 64,
         num_workers: int = 4,
         api_key: Optional[str] = None,
@@ -123,28 +139,28 @@ def __init__(
 
         Args:
             root_dir: The ``root`` arugment to pass to the SEN12MS Dataset classes
+            seed: The seed value to use when doing the sklearn based ShuffleSplit
             batch_size: The batch size to use in all created DataLoaders
             num_workers: The number of workers to use in all created DataLoaders
-            api_key: The RadiantEarth MLHub API key to use if the dataset needs to be
-                downloaded
         """
         super().__init__()  # type: ignore[no-untyped-call]
         self.root_dir = root_dir
         self.seed = seed
         self.batch_size = batch_size
         self.num_workers = num_workers
-        self.api_key = api_key
 
     # TODO: This needs to be converted to actual transforms instead of hacked
     def custom_transform(self, sample: Dict[str, Any]) -> Dict[str, Any]:
         """Transform a single sample from the Dataset."""
-        sample["image"] = sample["image"] / 255.0  # scale to [0,1]
-        sample["image"] = (
-            sample["image"].unsqueeze(0).repeat(3, 1, 1)
-        )  # convert to 3 channel
-        sample["wind_speed"] = torch.as_tensor(  # type: ignore[attr-defined]
-            sample["wind_speed"]
-        ).float()
+
+        sample["image"] = sample["image"].float()
+
+        # scale to [0,1] separately for the S1 channels and the S2 channels
+        sample["image"][:2] = sample["image"][:2].clip(-25, 0) / -25
+        sample["image"][2:] = sample["image"][2:].clip(0, 10000) / 10000
+
+        sample["mask"] = sample["mask"][0, :, :].long()
+        sample["mask"] = torch.take(self.DFC2020_CLASS_MAPPING, sample["mask"])
 
         return sample
 
@@ -154,21 +170,18 @@ def prepare_data(self) -> None:
         This includes optionally downloading the dataset. This is done once per node,
         while :func:`setup` is done once per GPU.
         """
-        do_download = self.api_key is not None
-        self.all_train_dataset = TropicalCycloneWindEstimation(
+        self.all_train_dataset = SEN12MS(
             self.root_dir,
             split="train",
             transforms=self.custom_transform,
-            download=do_download,
-            api_key=self.api_key,
+            checksum=False
         )
 
-        self.all_test_dataset = TropicalCycloneWindEstimation(
+        self.all_test_dataset = SEN12MS(
             self.root_dir,
             split="test",
             transforms=self.custom_transform,
-            download=do_download,
-            api_key=self.api_key,
+            checksum=False
         )
 
     def setup(self, stage: Optional[str] = None) -> None:
@@ -177,21 +190,31 @@ def setup(self, stage: Optional[str] = None) -> None:
         The splits should be done here vs. in :func:`__init__` per the docs:
         https://pytorch-lightning.readthedocs.io/en/latest/extensions/datamodules.html#setup.
 
-        We split samples between train/val by the ``storm_id`` property. I.e. all
-        samples with the same ``storm_id`` value will be either in the train or the val
-        split. This is important to test one type of generalizability -- given a new
-        storm, can we predict its windspeed. The test set, however, contains *some*
-        storms from the training set (specifically, the latter parts of the storms) as
-        well as some novel storms.
+        We split samples between train and val geographically with proportions of 80/20.
+        This mimics the geographic test set split.
         """
-        storm_ids = []
-        for item in self.all_train_dataset.collection:
-            storm_id = item["href"].split("/")[0].split("_")[-2]
-            storm_ids.append(storm_id)
+        season_to_int = {
+            "winter": 0,
+            "spring": 1000,
+            "summer": 2000,
+            "fall": 3000,
+        }
+
+        # A patch is a filename like: "ROIs{num}_{season}_s2_{scene_id}_p{patch_id}.tif"
+        # This patch will belong to the scene that is uniquelly identified by its
+        # (season, scene_id) tuple. Because the largest scene_id is 149, we can simply
+        # give each season a large number and representing a `unique_scene_id` as
+        # `season_id + scene_id`.
+        scenes = []
+        for scene_fn in self.all_train_dataset.ids:
+            parts = scene_fn.split("_")
+            season_id = season_to_int[parts[1]]
+            scene_id = int(parts[3])
+            scenes.append(season_id + scene_id)
 
         train_indices, val_indices = next(
             GroupShuffleSplit(test_size=0.2, n_splits=2, random_state=self.seed).split(
-                storm_ids, groups=storm_ids
+                scenes, groups=scenes
             )
         )
 
diff --git a/train.py b/train.py
index c94bdea91b5..cee74510b53 100755
--- a/train.py
+++ b/train.py
@@ -8,9 +8,12 @@
 import pytorch_lightning as pl
 from pytorch_lightning import loggers as pl_loggers
 from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint
+from pytorch_lightning.core.datamodule import LightningDataModule
+from pytorch_lightning.core.lightning import LightningModule
 from torchvision import models
 
 from torchgeo.trainers import CycloneDataModule, CycloneSimpleRegressionTask
+from torchgeo.trainers import SEN12MSDataModule, SEN12MSSegmentationTask
 
 
 def set_up_parser() -> argparse.ArgumentParser:
@@ -23,7 +26,9 @@ def set_up_parser() -> argparse.ArgumentParser:
         description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter
     )
 
+    ###########################
     # Add _program_ level arguments to the parser
+    ###########################
     parser.add_argument(
         "--batch_size",
         type=int,
@@ -78,10 +83,24 @@ def set_up_parser() -> argparse.ArgumentParser:
     # See https://pytorch-lightning.readthedocs.io/en/latest/common/hyperparameters.html
     # for best practices here
 
+    ###########################
     # Add _trainer_ level arguments to the parser
+    ###########################
     parser = pl.Trainer.add_argparse_args(parser)
 
+    ###########################
     # TODO: Add _task_ level arguments to the parser for each _task_ we have implemented
+    ###########################
+    parser.add_argument(
+        "--task",
+        choices=[
+            "cyclone",
+            "sen12ms"
+        ],
+        type=str,
+        default="cyclone",
+        help="Task to perform",
+    )
     parser.add_argument(
         "--learning_rate",
         type=float,
@@ -127,19 +146,36 @@ def main(args: argparse.Namespace) -> None:
     ######################################
     # Choose task to run based on arguments or configuration
     ######################################
-    # TODO: Logic to switch between tasks
-
-    model = models.resnet18(pretrained=False, num_classes=1)
-    datamodule = CycloneDataModule(
-        args.data_dir,
-        seed=args.seed,
-        batch_size=args.batch_size,
-        num_workers=args.num_workers,
-    )
-
     # Convert the argparse Namespace into a dictionary so that we can pass as kwargs
     dict_args = vars(args)
-    task = CycloneSimpleRegressionTask(model, **dict_args)
+
+    datamodule: LightningDataModule = None
+    task: LightningModule = None
+    if args.task == "cyclone":
+        datamodule = CycloneDataModule(
+            args.data_dir,
+            seed=args.seed,
+            batch_size=args.batch_size,
+            num_workers=args.num_workers,
+        )
+        model = models.resnet18(pretrained=False, num_classes=1)
+        task = CycloneSimpleRegressionTask(model, **dict_args)
+    elif args.task == "sen12ms":
+        import segmentation_models_pytorch as smp
+
+        datamodule = SEN12MSDataModule(
+            args.data_dir,
+            seed=args.seed,
+            batch_size=args.batch_size,
+            num_workers=args.num_workers,
+        )
+        model = smp.Unet(
+            encoder_name="resnet18",
+            encoder_weights=None,
+            in_channels=15,
+            classes=11,
+        )
+        task = SEN12MSSegmentationTask(model, None, **dict_args)
 
     ######################################
     # Setup trainer

From 288131b6f77ef6b85fbb0f67257c3888dc2b7ab0 Mon Sep 17 00:00:00 2001
From: Caleb Robinson <calebrob6@gmail.com>
Date: Wed, 21 Jul 2021 05:39:09 +0000
Subject: [PATCH 3/9] Formatting updates

---
 torchgeo/datasets/sen12ms.py  |  5 +---
 torchgeo/trainers/__init__.py |  2 +-
 torchgeo/trainers/sen12ms.py  | 47 +++++++++++++++++++----------------
 train.py                      | 13 +++++-----
 4 files changed, 34 insertions(+), 33 deletions(-)

diff --git a/torchgeo/datasets/sen12ms.py b/torchgeo/datasets/sen12ms.py
index d9aa3a06130..9ed9ef83f04 100644
--- a/torchgeo/datasets/sen12ms.py
+++ b/torchgeo/datasets/sen12ms.py
@@ -136,10 +136,7 @@ def __init__(
                 raise RuntimeError("Dataset not found or corrupted.")
 
         with open(os.path.join(self.root, self.base_folder, split + "_list.txt")) as f:
-            self.ids = [
-                line.rstrip()
-                for line in f.readlines()
-            ]
+            self.ids = [line.rstrip() for line in f.readlines()]
 
     def __getitem__(self, index: int) -> Dict[str, Tensor]:
         """Return an index within the dataset.
diff --git a/torchgeo/trainers/__init__.py b/torchgeo/trainers/__init__.py
index 773d9be4c5c..32d6d987379 100644
--- a/torchgeo/trainers/__init__.py
+++ b/torchgeo/trainers/__init__.py
@@ -7,7 +7,7 @@
     "CycloneDataModule",
     "CycloneSimpleRegressionTask",
     "SEN12MSDataModule",
-    "SEN12MSSegmentationTask"
+    "SEN12MSSegmentationTask",
 )
 
 # https://stackoverflow.com/questions/40018681
diff --git a/torchgeo/trainers/sen12ms.py b/torchgeo/trainers/sen12ms.py
index e348232a49c..b834ffa6dd2 100644
--- a/torchgeo/trainers/sen12ms.py
+++ b/torchgeo/trainers/sen12ms.py
@@ -1,6 +1,7 @@
 """SEN12MS trainer."""
 
 from typing import Any, Dict, Optional
+
 import pytorch_lightning as pl
 import torch
 import torch.nn.functional as F
@@ -106,26 +107,28 @@ class SEN12MSDataModule(pl.LightningDataModule):
 
     # Mapping from the IGBP class definitions to the DFC2020, taken from the dataloader
     # here https://github.com/lukasliebel/dfc2020_baseline.
-    DFC2020_CLASS_MAPPING = torch.tensor([
-        0,  # maps 0s to 0
-        1,  # maps 1s to 1
-        1,  # maps 2s to 1
-        1,  # ...
-        1,
-        1,
-        2,
-        2,
-        3,
-        3,
-        4,
-        5,
-        6,
-        7,
-        6,
-        8,
-        9,
-        10
-    ])
+    DFC2020_CLASS_MAPPING = torch.tensor(
+        [
+            0,  # maps 0s to 0
+            1,  # maps 1s to 1
+            1,  # maps 2s to 1
+            1,  # ...
+            1,
+            1,
+            2,
+            2,
+            3,
+            3,
+            4,
+            5,
+            6,
+            7,
+            6,
+            8,
+            9,
+            10,
+        ]
+    )
 
     def __init__(
         self,
@@ -174,14 +177,14 @@ def prepare_data(self) -> None:
             self.root_dir,
             split="train",
             transforms=self.custom_transform,
-            checksum=False
+            checksum=False,
         )
 
         self.all_test_dataset = SEN12MS(
             self.root_dir,
             split="test",
             transforms=self.custom_transform,
-            checksum=False
+            checksum=False,
         )
 
     def setup(self, stage: Optional[str] = None) -> None:
diff --git a/train.py b/train.py
index cee74510b53..3a71b681065 100755
--- a/train.py
+++ b/train.py
@@ -12,8 +12,12 @@
 from pytorch_lightning.core.lightning import LightningModule
 from torchvision import models
 
-from torchgeo.trainers import CycloneDataModule, CycloneSimpleRegressionTask
-from torchgeo.trainers import SEN12MSDataModule, SEN12MSSegmentationTask
+from torchgeo.trainers import (
+    CycloneDataModule,
+    CycloneSimpleRegressionTask,
+    SEN12MSDataModule,
+    SEN12MSSegmentationTask,
+)
 
 
 def set_up_parser() -> argparse.ArgumentParser:
@@ -93,10 +97,7 @@ def set_up_parser() -> argparse.ArgumentParser:
     ###########################
     parser.add_argument(
         "--task",
-        choices=[
-            "cyclone",
-            "sen12ms"
-        ],
+        choices=["cyclone", "sen12ms"],
         type=str,
         default="cyclone",
         help="Task to perform",

From 60321cea4f4618b4c849332be62ab235a2705920 Mon Sep 17 00:00:00 2001
From: Caleb Robinson <calebrob6@gmail.com>
Date: Wed, 21 Jul 2021 05:55:22 +0000
Subject: [PATCH 4/9] Adding example notebook for SEN12MS

---
 docs/notebooks/SEN12MS Dataset.ipynb | 329 +++++++++++++++++++++++++++
 1 file changed, 329 insertions(+)
 create mode 100644 docs/notebooks/SEN12MS Dataset.ipynb

diff --git a/docs/notebooks/SEN12MS Dataset.ipynb b/docs/notebooks/SEN12MS Dataset.ipynb
new file mode 100644
index 00000000000..b2608be7e07
--- /dev/null
+++ b/docs/notebooks/SEN12MS Dataset.ipynb	
@@ -0,0 +1,329 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "going-comparative",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "import sys\n",
+    "sys.path.append(\"../..\")\n",
+    "import os\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from torch.utils.data import DataLoader\n",
+    "\n",
+    "from torchgeo.datasets import SEN12MS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "proper-marsh",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ROOT_DIR = os.path.expanduser(\"~/mount/data/\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "forty-birmingham",
+   "metadata": {},
+   "source": [
+    "## Visualization example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cutting-national",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "DFC2020_CLASS_MAPPING = np.array([\n",
+    "    0,  # maps 0s to 0\n",
+    "    1,  # maps 1s to 1\n",
+    "    1,  # maps 2s to 1\n",
+    "    1,  # ...\n",
+    "    1,\n",
+    "    1,\n",
+    "    2,\n",
+    "    2,\n",
+    "    3,\n",
+    "    3,\n",
+    "    4,\n",
+    "    5,\n",
+    "    6,\n",
+    "    7,\n",
+    "    6,\n",
+    "    8,\n",
+    "    9,\n",
+    "    10,\n",
+    "])\n",
+    "\n",
+    "DFC2020_CLASS_CMAP = matplotlib.colors.ListedColormap([\n",
+    "    '#ffffff',\n",
+    "    '#009900',\n",
+    "    '#c6b044',\n",
+    "    '#fbff13',\n",
+    "    '#b6ff05',\n",
+    "    '#27ff87',\n",
+    "    '#c24f44',\n",
+    "    '#a5a5a5',\n",
+    "    '#69fff8',\n",
+    "    '#f9ffa4',\n",
+    "    '#1c0dff',\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "south-racing",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = SEN12MS(\n",
+    "    ROOT_DIR,\n",
+    "    split=\"train\",\n",
+    "    checksum=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "understanding-alaska",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def show_image_pair(sample, scale_factor=4, title=None):\n",
+    "    im = sample[\"image\"]\n",
+    "    im = np.rollaxis(im.numpy(),0,3).copy() # convert to HxWxC format\n",
+    "    im = im[:,:,[5,4,3]] # select the RGB bands\n",
+    "    im = np.clip(im*scale_factor, 0, 1) # scale up the values for better pictures and make sure they are in [0,1]\n",
+    "    \n",
+    "    mask = sample[\"mask\"][0,:,:].numpy()\n",
+    "    mask = DFC2020_CLASS_MAPPING[mask] # convert the IGBP labels to DFC2020\n",
+    "    \n",
+    "    fig, axs = plt.subplots(1,2,figsize=(9,4))\n",
+    "    axs[0].imshow(im)\n",
+    "    axs[0].axis(\"off\")\n",
+    "    axs[1].imshow(mask, vmin=0, vmax=10, cmap=DFC2020_CLASS_CMAP, interpolation=\"none\")\n",
+    "    axs[1].axis(\"off\")\n",
+    "    if title is not None:\n",
+    "        plt.suptitle(title)\n",
+    "    plt.show()\n",
+    "    plt.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "painful-layout",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfkAAAEECAYAAAAruk0jAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAByMElEQVR4nO293ct337cWNMZ2V0K6TbOTsG1RgZGQRaAYBRGFER2UHYhFb9CZIhhJxM4Uig78AyIkk0AjAoUkyA0lhXqSJ1vYJEFYRG9a7q3t9s6T7+hgzZdrXGOMudbnfu7P8/t9n8b1cN/3WvNlzDHnXM+8xhhrrbnUzKTRaDQajca3hx/5QSvQaDQajUbjPWiSbzQajUbjG0WTfKPRaDQa3yia5BuNRqPR+EbRJN9oNBqNxjeKJvlGo9FoNL5RNMk3Go1Go/GNokm+0fgBQVV/m6r+GVX9q6r6BynvH1HVP6eqP6+qf0JVfzXl/32q+t+o6s+p6v+hqr8D8v5HVf2FkfdzqvqTkPdPqOqfVNWfVdX/XVV/v6r+Usj/61T1D6jqXxn5v/ONQ9BoNN6MJvlG4weH/1VE/m0R+QOYqKq/UkT+iIj8myLyK0Tkz4jIf0L5/4WI/Psi8jeKyN8hIj8pHv+kmf2S8fOPQfovG23+zSLyd4nIrxKR3wf5v0dE/k4R+dUi8g+LyO9S1d/0Rb1sNBo/MPzoD1qBRuP/rzCzPyIioqp/v1xkO/FPi8hPm9l/OvJ/j4j8n6r6a8zsz4nI7xSRP25mf2iU/6si8t89bPMPw+nPq+rvF5HfC2n/vIj8S2b2MyLyMyP/X5TLqGg0Gt8ztCffaPzw4e8WkZ+aJ2b2/4jI/zDSRUR+g4j8JVX906r6F1T1j6nqj5OMP6Sqf1FVf1JV/55DW/+QiPy0iIiq/nK5PPyfgvyfgnYbjcb3DE3yjcYPH36JiPxlSvvLIjLvnf8qEfkXROR3iMiPi8ifF5H/GMr+syLyt8oVcv8TIvLHVfVv4EZU9R8dcn43tDvbytptNBrfMzTJNxo/fPg5EfkxSvsxEfm/x/EviMgfNbP/1sz+X7nC7b9RVX+ZiIiZ/Skz+wUz+3kz+3dF5GdF5B9EYar6G0TkD4vIP2Nm/z20O9vK2m00Gt8zNMk3Gj98+GkRWSF2Vf3rReRvH+kiIn9WRPDzkfNYC3mGear694rIfyYi/7KZ/Zer0HUf/n/DtsfxT0uj0fheokm+0fgBQVV/VFV/sYj8IhH5Rar6i1X1R0Xkj4rIr1XV3zzyf7eI/Nnx0J2IyH8oIv+Uqv46Vf1r5HoK/0+a2c+q6o+r6j+gqn/tkPevicivFJE/Ndr8tXI9RPfbzeyPJWr9RyLyE6r6y1X114jIvyIif/Btg9BoNN6KJvlG4weHn5Ar9P6vi8g/N45/wsz+ooj8ZhH5d0TkZ0Tk14vIb5mVzOy/EpF/Q0T+cxH5C3K9QvdbR/YvFZF/b9T7X0TkN4nIP25m/9fI/1dF5G8Skf8A3qNHT/3fkushv/9JRP5rEfl9ZtZP1jca31Oomd2XajQajUaj8b1De/KNRqPRaHyjaJJvNBqNRuMbRZN8o9FoNBrfKJrkG41Go9H4RtEk32g0Go3GN4om+Uaj0Wg0vlE0yTcajUaj8Y2iSb7RaDQajW8UTfKNRqPRaHyjaJJvNBqNRuMbRZN8o9FoNBrfKJrkG41Go9H4RtEk32g0Go3GN4om+Uaj0Wg0vlE0yTcajUaj8Y2iSb7RaDQajW8UTfKNRqPRaHyj+NFT5q/4236jXUfjjygcz3M6NaG0KYLKMtK6V5Ja1T4LQFR6GsnRkWrj7BU9vYyYxjpw+Z1vI03LOic9WObdOBV5c45U0jJTsm8vz411oYcmotwGXh+a6GcyKiUXiSsEf0ZxvZnSHE/HM6v3ZOy3Un/pz//pD2n4fcHf8mOPB6/RaHwQ//NfyRfgI8nvZRvr4uIHC7tCNv+XDgSP9ciOQGFWtG+jnuPKavG3lXe1mo2DUXq2JillWUJrVhyfBseXqHMMfqsbtlj3tKYejJBb+2bW2QXNrCBRr4ObQa1yzJ26lsAoyA0ianZ2Z/06GWTYSDZ2oMm89kzHtcvyaiNtGTrOoEmaazQajU/CTbieFy0ErU6hGJJ3tXBOOUlE4NTkXLhN3YJZ0+f1c/bSeXFmvSzQlroyltS5aysrW5HQJLbZCwulo5yTPl/iXO3rQpXHANvPas66tlJE5lTCBBvOVmYk+vquKNtjB31yZP0xn8XRBiNDIFFCw0Gj0Wi8F0eS3yR2IntAGj6upUcvXi83LxgGo32r9NBdN1dGYh94Ic/66YlbT+QSoh25f23uLEOmd4aTJfQ0784QeKXdCexlLFsbWjy2VVQkqVZcnysKlF4KWQwkj4t4FeCazQzbguBjxGJGLTqS3Wg03ocHnnyWdvBEw6KbeUWy8xzBn9qlRhw3GVR/RkLXb/AcUzeLiT9691E2H8+gsolCoHnLVtCDpOmuWxOgJOmZQZMZNVmouZrbkxHDxhrXoxi8oXFRhMjDkFxlnXaP+DEJny/j8jSOhXBTMYM+TcPTRZlsy1Y/17f9bjQajU/EkeQj+aCnc1qgMo+R8yV65svDwoRKPul0DDb4BTZ1sFa7kSBzKsg84KzPJorPDyRGxIwQXP8wciCH+9fYN0/MO8XCj6X1MtmnSEOSN2+bUNbs1Y62AMmKLI+ab0NwM/hg5Bodza+zoF32IN+rmOSNzbrmk+thWSIU/WlubzQaXwk34Xo+uODW35uI717PtEh7QpQFzJcx+B013UQ3qV5XeDWW8PTnPS//OyE9djNDkegtbhokAgz1TudbX8WJgecWzk+a3xlw3H/oQ3ENqGCIflB16EYSLZmK0jMX/GSEDxIYJG3X2oLxCHVN6+6eLuyTAbqq+T6tcdCjRdpoNBqfhgfvyTPR8MI9SsViqywekE9TtQhHibepseQ8T730eCJZCBuXYuqd03wH2C0tHQkltsUEUnPviZVPJLSUIc+5KAMyjwGRMPPn0DOXDU41BHXcvJtcRL+mHEZ6kfb8qSIc19/MvNw2gN0PoSsA10JlgNUX4Wl0G41G49Px4mY4xWIOzlyeGf35dOGVGbBmb54IcjDCXcD55AXnWmEO+qt3Hh2WzxbxzHNjzTNDIKvB5SY7UlraJraH7eSzEcqHMABabugRk+fuyHV66aSfghbO3S888JkFP6XJVE1fScZ3EaYMd+X5OZBGo9F4Pz6w4x0tgCXBW3kaSZzlT2qIC29M2w1EOmDyxJzMw8OAuSbl2BiYSZVOD7zsTGYog2cH0iskvEJaMUpz6gOwq5UXgvh9EojcTROCn8dzfBRqcjQHKmWk/chxBuOVowRsKwX7iYwu99R+JPoqktNoNBrvwIskf/JG+fy0wNUe5t3uZEq/9/If4VOZ8KuFeJKc1zfee0cSyULDz7GeDyA9OdIQ+xsjAFlv4rnRMTMX5K/krQ0aQV5uFiFQmfegY6h65rG6GZETLWYkm1oKTvBN6IcbEQkPCiocZPZZ4G66ziw0kCjRaDQan4OP7V2vIsELDR7tl+O5tCqOkIWtkchoAU9C3HvtHovzcviyqEJm2NCxcdloPuwn0rFv1Wh48rU8S3y/09JZpaEqm0uki1kkw9DGHC/19bKyKuJfPTvoN9Nur7+TS89jXZXB631eYXyvAIwJMo58E49CDI1Go/FFOG5ruzE9JfRoNK6N2ZocPMcJDlWPtJqlkvI+z/uRlVc99VFoj3SEU6RizyP4zvtJZyrzYJH3EpNypslQXH0K3nI2zI9RzFGi5VUUx/EBic1rKCPoNPyfyCTDwhbfswExowpZH8z9qTdVMn+4puFwXRtOF0c6mugbjcZ7cevJuyArvm50doCThDsv6Y6NJik/WRjNLafs6/owOHnKi6fU1cqX8Tt977zRIpQO7ZsrP9IVbx/UOvhPBmSRBtYh02fXNUmeCJi6qi+baLN/AnFn4+PlGM17HoewFQDwtiKTayZFIYJQqB9EZHLJoFMhw8vPfdN8o9F4J25Jfi7vDhSGrCKTXooTKJOszsZA4lEFTzh9U30VxG1WamqGhTcs4kxeGKwG4mI5mexQM/f6py3ljZFdMyO3UdOV5cgD90NcyYrgZ5tGqcNFdd7xNMLmXN0RJhM+ZJ7UCRof9A9Z+UXqRpWnNdOj0nseHiM2W8jtVw8bjUbjC3ATrs9CnhO4xGbkpkmdROSth1+ll6vtKGGkQeVNR7nxNb6k2ZCXEVZdefv36OnPFPb+/blvxlwZF6ew+avSZ+pded67Nf8FuoKIuRdrfgsd7sh3WClxnKq6ZOCEa7D2m33QgwwintsQIUHZtvR+ds01Go3G+3D25NdiNcKx4T4nFsTFrgpHI6rFtwh9ljLw+Pq5W9Irr3+fXQu72SZNExkedhE54CBAGYbmVqd89v4zz/TeIHJ++irO9V4hH4OhZeKCPnLUG/I5BpA3O/LD0+cz4GP1nRrjAx77GWXgevm4+OiPJHNLTS5jhqIk2UVC+j26+9RoNBofxJnk16Jua5Gvw8w3wJBuoMOMvNhT5zCz92yZz640/lypYhFISwhZ5+t8U9J+OoGXaqSGj4OfFfCa7hbTqgeePskYxtudWTTnTrNRnwNeR2w4krJGMnjjuttCFlV+Lp/nKlVYYl+LYkkCNh83Q5oe/jbRjC/tMJQz04/33SujjUaj8SV4+Aod0iJv5ZoTd0BY1X3AOrbFq2UVOYg65udRRm6wGBGUf4e9ot8o/y7VY5oStd6H/jvXPSP1SS5VlKSav0jimnjaKRQJjQ21vA0fIzFxe926S+6kw66QR2yqmdsWDAcYsp1vd4/GNcyFsv8ilaqNRqPxJjwg+cLTdfnJeXkvGFe+J27MaWH2/iH+8cYHe1FXnzyxImmmz5ELj4GvyeFh36qvVSHTuSp3Sj+1ccc+eT+uAySyB8Zd+PDMdY6xEWzHaa0iuHd9IhwKrgpOSm6MQlkzV3I9COquoXiYGp4mW976M/q4DDDqYLvxjUbjzbj9njwH1nMknmVaPnPLMC8LaZ5QhGWPHnHW5ugpLMbPifmkWxbA/yz3rfLK79JO5JynLSNGZxkmWL99T5SX3Iqwgx3o6qs/xWZDdMK3eWvEVNOqWA5khHv4k6izqAhul6SSbrpkpE+j0Wh8Mm5Ivoo/ihwX0ZX8JIR+apObzQKwHJ69I3yWcXl017ru2/ZRghf78tBRe2WJf1Y28TJvcQqno2QOgXtPmL4I7wZAUa9Fbjx3rE9U0z+oBp7zkLmugUDIKDcZm9RTn9W0vtMgJqb0MKa73Pz/kWdGc6PRaHwOHr0nz2Q/+TsJshJi6Hcfs4GQLMDpnYKdoM5DLD4pCrn+Aaodts8fGlNyXJ9ENVTW+JgxI6VA+4WL7/FF3c+3L2rdKu+9Ks9a8o6CW+QeGQ5vs74wPiuMPb3eCj76k3+hUF3K1bQlXb67HlnmyUD0sYl1Z+HGFlz/nzK7sdFoND4Zz74nnyZnT5PzQslpN+FTXlQtK+PTXOS2LDVpcvp5/CKckRrTI/Ue3P0NgNzseeKv2WQKIqwotyJr8qKTvLLt4EljvcwAGocjWylf1z6uhdT5kBruoMikmr7eZpu8fYMuHB6uiWqnRqcUNZW1HQwXNmokmR42FmY/srKNRqPxuXi4d71HpBOlv8+lbFyujQ/gVnJ5ZZxxXFpIRURhj32D3xxI1vQGcU2mc9F3269DP9jTq4B2jEZ2An39J2vqqELMvcPZi/bsh0GP6wH60d46Rn324NgsP9MX72F96sck+mkwJN3CMfFH5utytkM2ZtSHkJ6f+vYTy6HcYrfRaDQ+H2eSn95WRuguuVjQHDKjANvhnCdklblDvAhbKO1bn8YFb1cbe6R05P/c9R81iKmejHZIe5L79gU33RczQ51EWZl+VXz5FHHhU3DnC2NJV14i34r20GgIKlO/XJ/P1000DOr5MoGRC33LDIpzS1UAoNFoNN6Bl9+T92ngaScLtYXyBaq1s9Tl5A1VpFWd4ctcl8GwfWek1pUtOUlinMDDjrmLAlM9M6NEQxq3dlf+LjJyJ3PIWF+dwx+qlxIflcumU6msC+okGymXA6K+WTtfPVeByhhBr56Iu2o3/L2uMBtJvXd9o9F4J86evCM08lTnKkVe7TpZHstcXU/UlHmJdwQ+vayDFz/Ssh6kMkfUQkOXRme4jxJJWLF82kruzXs56KNm/npBylbl8wjg+dljX5/YLRvMQtJDdvoBory4JmNbGQNho9zw6d2kX7oqjxKZZbnT1gjZ/IXZiQlWEj257WHTnPblG43G+/Dgnnyy4OJ92JG3/eGx8Lm1LPMcbwhfZZGuX6C3HnfEuXOB1FToU+UVEeX07XSUbLlng+b0XfuMbKqyMXqQ7wo/B74ak7PJk813mC0TMbWx+53FqjxUN03FbBrDOe9weXlOT4wNuDa9HZddP6sREGliOqIV4dv22bVhoGcZmpB5Peyrrj35RqPxPrzw4B2ulHQe/NcTkWSrvl/2ppHg22M9doQgJzskIPbiWM8r1RQ2Lwk6Y3pcxE+Ekcuq0lDvO0JOcnSPSimvIEDW5dQLdb+e9OlOYgbb1xrouTk9k5u0Ad74/sAcxk0SQ0xP+vrryUVQckFb8XkNOoOh0Wg03oPbHe+eLkJXyaqswY96RzcgMwDuWr4ptbh5Nsx3QilQ7uwZI9ojY8SJYC/+Tm8mQpV8FHMSY+96El+MoFRjGtO5dypyeezgqG41YE7HT3gCQIvxOoIiRRzSDrsMkQHqVYr2qGJBIHia/Px+ORukNIdh8mie23FvNBpfEQ8fvMvIPiN0JA/Ns0RkbxSTkdxzjWrCJhJDz9VFAHybbv0HAgjevSMJp5C8Tmix7H3NZD5uPUMgcLXxJlec07S/YuvOSQjiyDBLpoe65tYzbPGB3ihs9uHoRN947ifcFV/5uoZ5aY5WTjYQivUOfW2ibzQaXwkPSZ5xG8iNaY++XnYXCfCO2quGgVev3gImJ29e7JlqPSnuNHYjq/ZeiZo87XNmSM2jLLTsyy2tJjfNqHmyZawNj900zV7yYkLRZ7QRuBvGBWe65ZfEfCq+ugYnYavfQ3GF+GXz91Vcr/v1cCUuQdOAcs3ozk/bbjQajffgxb3r5QGn8qoVVtxDnqx9wHdZ7xn79fNZW4Z5GUGctqBdQYEYilfJtlll3dizPxP9kc+S87PSXvaOe6jcNeTGbB0j68aciDjXYfjLDlHk5NZWSq6FZZ3YStpsDdfDMiTQ8AECn1H4YSjghn2T2EOgB+WH66td+Uaj8XXw4J48rbAYznSHSGaDQdK1zIdxA2FAqLzWSWS7jMxUsKC7No1LHNoQCTuT2Qx4Z7UqT83CWSRPbC9+Uf7O9/80KBzY3Ol/GAaz73yLBd38cb574YuqWfpd9l0Vr4sj+7PC+1xvrtNMhiN1OqWNlFaGbqNp/zqE510TVLb5vtFovBEfCNejhzoJkMPN4C2GengeSXDWjsYAtU37lQfZboHGY/S+ccGl1Xa9G60hOVIxI8/XpUvidSp+X/0JvDTPv/UjkNEAi3NlPOS60xcVqmxSnQYXvDrmNZhkqvFxDJ1NwNyufI1JTrEMaHCh0TcjCZCO3jV/MjYYiaN/PDbLKL1RZ7RxmplGo9H4bNy8QpeRTuY9Y1mjY0nK5vK1SL/X4Uk26xRJ3SSu4d7Z00Q1Mmxc2nNUMQJQcPwe5DTuCbPOUeZVrgyqhDDy1mQ6qbgLwqqzgjyFzu5JPZDJHIxpzoCc1VF/Ht/sejp71OWVFW7XqIQv2fFgZ/ZniGrtP2YWXwxoNBqNN+Lxe/KRTHhBrcg/wyxrki/MJnsveV5hM0/4CQ66+rU4rblDs6+0je2c6r3mw6MXvlWytMgk+tIYWB/wwcgMC0I33zcQ52nQcdglzkdUskj20nkOG8hw+hdfuSv7uDazUZd0P+Ywf1qPQWU3Ohkm+R45jUaj8UY8Jvm4flWkOZf87IMomRuUe153247OmkEvnQv4Lu99WZIbCK3S4ZWoRjw/edxSljpFLIqICYlYO7e5LO+C2nBaF59h8/NP2jX2TBUa0UWu67f6vrnbKKD3Nqiwd4onxRWVjNUqWEWNJB9i96R+QvBVPdembQOlunwajUbjjXjxU7N3q9o8vvvsRhH3XDuCpatuSIlB2OExUetINZWs+1DwnU52exdhtmPwu7YyTmRPcWIm2sSrPxkZF6lmsWd/OsP2QQVOMBGR7+S6B73zOeRumMOe8r43MHgWbk2o7npzdqMN4WThNbD1gL5wwAj6nfYXB7Xa3ncc5+O+PfxGo9F4F44P3p3Xn+XmPEBWDlzHlTTLPZWNq3Gk8lAuZOrFDEokg3VUJDyUlSJbsHc9jGq4h8w+hKT+ejkbfdxoBu16fszqmAOylJ2nxpHi6LfxKFytxZgMUHBx41rDb84rK8EJGJRsFLzibbu+sqF1EkgC+iZ9o9F4I44kH5effEGKVOVJxP/NAq35or9PVfIdVtjVwifnk3Y4DhyaSrx9E8l35+NjDhxvQqtRee4MilG7EyCtoP90b3k+ohaazpcfuxW5TkXZ1kGLsaJX0qY8fObNmwBF9CQ8LAhGXKYbGBo61LgCRpqUH2nr4zRT9Zku56lCGVa1gbq1K99oNN6HG08+IY1boudV8LCIwdZg8dUyDH9O4rhzIxNyuPvcaanjHemiLlwWnwZ/QN5yjXXJA3SccNjL8HUKHef7bhmnJlXSxwdxcyP3UZjIb9tE8w3kO+glkRfSbY2VzvG1SksQmUV0+FbDjDZoMvgYKZg/4j12tFnbkW80Gm/Ei/fkJ9gDffJ0OHvYMcTpTQgMPef+/8Hm8GVOCekrYLgCYyMm+ZPdXJ6V477XGu1a3mzCA99l82pl0hNVH3ELflJ4M7VwP8xNziQ+c22ZyLWvPbYfQtXmdTMFMuQrYPr8GgM0Fg2DpbWhOJij4FFDnmIaNhCvYV8ODvFNgfPl0Gg0Gp+GI8mfH58z+P3qqhXLP+HrZ/JPZbIWImltbRKt2DDRuX5/3CU7epYPxGJAPjWSbmXcxBCCZUXtB5vP3BSTSXAR81IWHqgLxghHRDZRzmT/SV2oju1OPg42F86xxoqGIxo6IvW1E8ViHbclTnvyjUbjjbjx5DNvNMuhxVCgypGXvft1SWHGuPL2Ym8xO9G6zs7CsdX59qmrN82VtnX1Il5x1arBujGIhoHB3v8TA8HLSdqnpk0S5xubnQRJQ4i62iFObVzedRKJONM3XhenDRGxkXXlUTTAHZSsfLjIw/WwLMKPXSKNRqPxIr7oK3RxiWU3N6tbez8h7Jq2khkB3mXaft+Z5RKfVCg27VqZhkhsc9QJD5zl+j3VJqviWx3h7BDKHvLK8Z+14VyTyAyyrm6Cn2V2WfhRFfcZNhxOHTvUL52hNYyEz6ywvy78mReLK5NEXTKbIp2WrY+FPOj8KGdwZKh/0f5VhuYkv+AbjUbj0/BwW1sOuPrcGYLk1Kwuw4S+6u5CpHmNGt6AyDZH2XwzdHYLbeEZup7euF6Knv+uUfXogcMtVZ91ErnWZU6ydtsjDjC9aLNqU7mr9HKox3g71xvi4uaTt5uejLfqdc/+TncXONFlOAR55K2vPEwzuerjZbPvv1B5lDND7peRoZqMaWJvLPHcp0aj0XgTPuTJx0+sIk4hZy5n6y2l6D9nMvBnynjgCc3XodC3X+82gwtZ4rWwe97bzMt/4sWd+ogepnjvNxPvbBh1Lx54WwEqsoyjysPoOL1yeIgu2PwAzPK0uXDimt9OnyaBI07TnY7NBpsPM+ZnirzxEFTGMR4X++nLxo1Go/GZePCpWXTH5k9FyZ5Z/OdTCipfzlkSmk1k3uub6ESran6vlv2ruzaf6DV7hqHweWSPWtnlJSEdkrrC4LmEENmGLqjTa1OYa8V5xqH5CBWpN3vB0bBxHdC8BzLeHQmjzyewgZHxmOD35YdPvi0c9uJ1Gy1Z/52+dZaYXJ/bZRu10Wg03ogH4fqTqzSDllU4+bSaZXl5eXO5mawQFz7Ah2P9uswtsLwVpC10rl1nXWSRFHuKm3orO1GFb9vv0yzETWnCD/Ydwtk0tsuQwXj1qmiys7hNSwwEi/1Kh3x0BG0RTlKLsfMxRX4cY5vYOzy/xNE1TIGH63C0++wrOY1Go/FhfCBcf7cqGcU7I+leqZFoI9n6UuZKzmApr8qZrtlOeFEj9K7X/Xr03nQSTxbNqIyW8eNd4ec4BU2Ksa0S6/jIOKu8UFDCG0DcjvFQRjV1RlVIKRan08PXZRhMczIJYmwBzlOGK4iMkXUNukiSis5bBpWtOKIlhudFF5aOXBgfwGtvvtFovBEPXqFDRLeJiTnWjeS311BP4ck6v0stcRbLWKXpNArq3eQUSgXdzcSt+KnjVY1REfq9ZRCS+dgumFTFSs5YMQ0dGh0K5xzaplfVtmgam0R9jZV2QuUlA/nxd+ZdHMX8zaAwifAteHWhhKuwGrytvh62Uy8Lp1D98ZIZvHEwRGm/Xn43YxobjUaj8S685MmbW/Vi7gWlInl5ipLKvsuaGRLw6lXasjpi2c/6Y6w0iZseU5CxsG49Bon5kZZ4KuEE/zYWeIhBBzCnlNs2GiLyrp11Vel7Y4WwYTHIfb4Cd7qitl6bfPfMKAUZEikql2eO5E2KbaIXsen5q4h7DbAQv8ePy5lcX+GjK0LpCi+iMY1Go/FZuCH5ezfyY0tU9Nn3Yp9JLELJWDoUYY+a46NVnHjkuZvYLCPHjh6cZUdTxnuZMS3vvPeqiaDxBMZmtZ3ZU6NK4EwMYadDUBFpVG858axzKZdP7+fB6WE4d+NnWDzbfvAe94d5l20e3lsXnfzR0ONATaPRaHwAD56uv0vhXCvO7pazhAkM86YMT1eTWDncXj9Bf/3sGoU3Gtr29ff5qT+5znWM2h9tWoqdSaMaFXEfweS3PeWgXyqfCBLpOylPO96GIt6cMknv36Nsti1WtCD21E8bzI+CyFXPOIH6mRlDu4/uVcakvlKdRqPReAdefvDu7FN673M/7sbuUUJaQu+Xo8vJodO0dfJ86XFy1sC/hJWs1LcIvjEce7n2itw06vz03m1uRDxyTp1NMtz2tb8Ays7qGfRxk+MypKCaqriXDNgYeGI+7YaRnYti6UXFhXF8szLVVT8jHJYOcvrKInb45rpuNBqNL8ULX6GDnb3Mpa6jSOR7ZTNIik+6ZxSk6WGRsGUsFpntIp17F28Sk7Le3JWqrbLPmFKVzbEdx6s8jJ5vehY56jSPE2PGKB892EnwYKREM8OPc/jCXKazxiSn55pCOHfHKEtJAhgYGZBx5wN/JqsPqz5+Ui/psusAvm8P46lKxYNOxXw2Go3GJ+OFbW2NXJO5UJ5WKe8fXd7dKZ6a143FC9JSXJgnhddeernhbNqlrPSp75uRuNW6vjcEJvGkXU/bY5nQPis/E0PMGeqaJ62QvwRPeTT+7JabiClvgRwNR39NTR2n6cDzqrvO8ZKyreMElw/DkM/vsj0QMMjr1T8RUfVm3tVllWrTokaj0fhMvBiuN/hJPJ1H9ePxpiKM274YxkTCCRmPYrmHMpNsr74nkVkAjhHHDZTCuln7ZFhluhaN+5YpR0lvtLV0J+0qwNAu4zSe2ILGLDxwxkVhbDmjhMZzdTYbp2EQoA24hpVGZ8pIvyef6GEZP/sCMy6Al7A31GwFDZrqG43GO/HCp2Y5tVqeTp7qqQa2ZW7N9Xx/IMa10Yom0fEDMZXOvg+Ws2P6cbCxk3nhSZ0k281Qxq9QYEWoBcaUpvj61rslQllwrfO+SRKL12NHcrgp5lyl9h2Jq4iO20tZQGgePGVYtEX8PQNoc+o0RpgJPgna7Ou+0Wg03oMHnryFsxGIfKGZ7V2dTAATv8ddrUGeBu6a+FenOI3qleyNMYaPL8buSf6wAczdOOb5UzPkMdVrxzb3nETKtfGhuP1E+NAPxmqPQjZ+MaLjyYsiNByROA6rSlk/u020mtx6sxZVE6v7HNJ3KpKlkkRDXI06tAKX5ZebjI1Go1Hhxc1w6rMLry1YmbEw0/a/KpZQhIWPaQf93OJ+J/MkK+blRlFtNsD2P5K4sN4LdDyeMUrUc1H8KD4dVJ0e+CSeZQOx2wtjXyTXQ81GzmxcfT3THUYPBtvDyAeZG8bZpNJ+IcPEh4/mIJuEDYNQHyRuA9NQRdabCq6PB/UbjUbjE/DC0/UnisxystX/XO+8v7yvE0Od4JVnIdpV6annnMVz72K8if7xA+KxjDvjWAeFhz/F8QOPXXh8qH92/Qrd4PfgKptrhf7Hg4uWlMFmlROi2seH1nCOB8MeozDcXZvlMYphkn9nnjrjbg8YOemFcdAP4DUajTfiha/QYZpQ+rwLa1TubgHj8nldv5RWEQRcRJkyfTsVz9zjznC5S9t6hpLsPAruzY79A3IVGBvHwuC7gp2AHrsTgnWyKDg5quv9cJBvs+DqBwvCr9HBNQRlgxEQRYjrEPZ/DYgtslXqXhZA4DbwGvajlBk/cMDzkfUlRDia4BuNxnvxwJOPoVpby6pCSkXYT1FT71laZQywBB+0zcs+XXRx+X9QB8PAqU6sSyUzY6pUwK4x+Zi99kqASjAkHIkuwXmUI+V3yJ9VnfHihoU84ynP2Tm2ghqbSL3OoaM8VdC0NyB9JEe5QtW/QOIqjx6fb55vNBpvxMNtbTmsbm7NDE9Sr3BncF0IuKAmXuURUa6/g08yIaR8p9WpjQ/pmTSoEt9/Zx8fnUD88dU0KVlrh63uZ+tsk/Z097dCQcJyk6Hpckx5uGx4y2oxVO0sBGJki+2dhz/JVHEyoqGHbWxTdqWXQFOAoxSgEQxzpWKj0Wh8Jh548tlKNJe/zAi4I0aWSUR88lYTjzzKTWK0ltxTLnG1cUnKvFXW44G4RwWqj5Vsg0p3EsnOP7vqvGXxVDQZd22xrlzRvK2Wx87hDNpQX+KqDuWDncRes1G+b4ufiQvdCoVyzZ9dD7uWE20+D3W1pPmw/83HlGg0Go2X8PLe9d5rlOT4hMwXhfoqh8W5Sr8JbaNn6vZhP8lXIEhy/wK53b1c9yReWxkTkILFdDwaBgS4eHhy8yLVs2e/dng1SChDHqzXLuCmroyY5AZc/uIk9CUf+p1mfixKvHrJquzxMDhkGxX3sZ2XGU8rk/rxWm80Go3PwQOSv1YuTxWnFdKo3F1ZKq/Fgp+kXpqdoghIQrg6Vzqxi1at1Ge9ds0yiF20XSB80WxsNaus4cUw19taflzS+VMRG1sB62rHR1ZieDmJv2NoH8LdsYu6xsWq98Ppqy7hRcrislr6p4YJxAiMrppMDb6EfRd8lenEq/i3/dDqCpGLpcxz+7jRaDQ+gGO4nvctcyFhh2zh5/Q7DIINi94m3v3Inw/u+lU5Sc59WEr3x74HVf0spM94JcpR1Cles4qja+UkHYPXGH82l0N8aT4dC4QGKEEzY+sqpvxmwJS7nqqjdrkJw4TqGpglrBhqqKuH9DVeuvthFpIw6oKqXnkcu280Go334OjJR59qpjL1MbG/4sGiDN+SX22zrXGySAHkQ6g1RxW2P+lehe3j8X0g/0m04w73+nJsxETWE+7b4ZwMdZEYbl2ftehFGnUjiaiE3QZn1UHw4ak0HGc2GHK9HHEaRBewXfXlvNqHsVzqTLmW5N1FlkjPjtY3Go034+G2tk/C1lm61Yt7inzVy/3o2rveFTnMjSdZxGEbFeH79i7fh2DN5SdNRid5tbJD+grc8Vmr/zDLlkwIeevsibrkNSJ20MJi+SU/ne7gTu+ylZGTeNKbg1leZlgW0R2nA6pO5dclAQOR2pM8ShxJaEJvNBo/ODx8hW7Ce4We0pg8eXHLVkhNjnPpXqvK4+JoQiYhW/SruPNhZQZvbt83nuc5ODKyIyIaCt3x5E6eY62JJ7o9c9eyogEzy7Brn7WlEnZEcFYBEmVG7A86hLmWmXJMoiDfkoCAiO//ilqAWjMNZXNXKKCwbZDCgMEftiVv7I9Go9H4LDzc1pYJzIfRL7y6YiVh2GPebo+X/ngGlGsiovx6Fq3Wyv15GqmoQGOTdBNNpavF2L4b8dv78pPoTzr6PC3VvOTEOAcwo8G1YJK0WxhLzrOdzMx6JgYfKwvd2TnXvfEY9bfjtE5Ta+vHRisdgjozSOKdejJwh+ERojunS63RaDQ+AQ9JnlciO+QxqpXML+TXmsdymSjQQ4zU6GuNxwaV63utp5MXt+Wt9H2yKt/HZk+3G1wPE2472kcMIGDm4iXGMdXWYJlKk9CmMYDtm3lZrOsso7tvOhlxtctEv7fA1VEuqAgIxopOZTMDYhTAwTDKw7QqCHQ7/iZ4uyizURqNRuPdePaePL8A/TLuwuvRc43tsb8eCX4fZ3r6mKvv0d22vLH/z0eCQreFZpNSsd4aFX6tUPlk/pBWFBZePZ9PfAfXMtcMPX0/ertUJHjq6xj+bUegwQaohkmTZyScUZIYolX+bBsvIHTFVwiIxUK+qa9KxQzftbszGBqNRuNNeEbyqTsph7RUSBKvBCkrpH5yU70rp1AjqnLWNfaoJuFSF4cnYfI65L6/fDYp//4t+x2WzkgOxipaQfn5Kw9JxlBIjRUu4GsAZSmd48lTvbTowjBs1EsygS7Pk4OtE7esU1n396ne4yupPftGo/FGfGDHuwwnb/VaAdE5SsEbsaRsZBSBJSJ8wTu66nnXakcHjNbteEbKFy1g3jPlgomjhfmx+LKKZ9ghhs6fQU3UnccrTo7W1Wwc/PpToIbEeU63rOjI0vPwZYGAG2956jqH5myjmFyvE6q/AkB3lz4DBPMa5eAQFm5ybzQaXwEvkvwTolrLp2Rh3Y3cGIjHWXENa+adruUiHnz5grBD8qvx1nPIHks9YoAgitmZsa0j572u5pI2VxsU3nbtkHeOjIfOuZKhwNFwNXo3n6M2BWOPH1t6DtsAx0evROeop7H/3FJxMwf2U1VNReM9eCsKNxqNxhtx+z153GVuwlPjPDuTzMeWNiSFyQq6njRnbvF07U0ADTqe2ks+FqNZKSRllr1Xeb/eP/X6M9c6a316wtU9a6PzRFt0O3Wf7jHTLSuEGmYR9XKCKkV6cmHYKq+7uRf3eQfNR4LF5+zACLh2wlOfsR4I/A4LuqrTdecdGNEg8D2bMpvsG43G+3HryWs4QzJhwnnVU6E6qXdK/vqjLV55NceTjKHugP3jVj0xRGnTIDnFHTivIvhKr0R+Gi8erEMOdSC9Qdq23p2/SoUPxaRdupv/pE8WPxK8jArdIxjEZHaV7UskPLQ/BKtBJMgRbjXeQzulUssuGvorVQnKgSw6bDQajXfgxc1wzgHyvM7EYTVLw72Y9MHVMPX+Ks+4FAL1jHKQ7a6U6E/vV/PuR69ua4PzrMjOBhIiGyN8vsiJCWx6o+h8isR7+UttNMgygwco/Bz0CbWWtILYUxHcRuI9L9npA3eVYHFduV7TVLCf9qeBuRKO0JqiJzZmo9FofBAP35PPcB+i92UOq9lcgNdGJBWZ+irx8znc9kdw148n5T/W2jONyevkAEX27nfaQBwvC1vF7Xru3fhKvmConRMP4/ToYy0wB4e2k9KQD9eXJSH9U9urMN/KoVbm64mJjqjTjlY0Go3G+/Cxp+tXCHeeVIVOqNyYO/cpc9FeJeCKrfLy1cdvn7TErWY74s/c+iO7FF/Pwx2xsSOYiG3pl+7bz6Ho4Plfabh54AqJS/FC4ClAE6bVyvI7WdOrZJUDEbXZNkPpszMgUe36VK1RpCK7BB8QeDvyjUbj3fgYyZtIvEGbFRLxyypj08CzRnE5P+EizCwCe9dClJw8hOdEKaXd+5NYj2s/O03u62rVvSqSUhCuM+ByaVsixfJngemmGnis6Qvsd/Ou7s+an3mPAcLkIrruzmxjZWbjKPuZi+bM6JXNVypnH6E/eKUUXVrJyTDPo+NHgBqNRuMT8Jjk/RKt9Dc/zWq65FEpI8xoGBRtpjBYwKG87vwcLNvXP4fWede85ziZQVv2ODp0P8/iKEAQTVNkPi+RNskt9fl1aOtC//zsOfyUNt7JxUcpkE5tbjHe/DKut377qwbvfJhrF9RDb5+NG2w0FGuGbzQa78fje/KaHOECiV5N+jrXLnUdr7ju9VW0+OmwrP5Zs9c9RZZU07iFlFqLXSePDeQePkVGwHv1pk4VKTjJnKeHsq550sWyMpIPvR6MDfPjsT5zu/hTZW7huzzmcXI7k3R5rWQ41tHE9XU7/62C7aFvhfyH6SZDs6sO82VZftRpRQZAbKPRaLwDL4Tr0deM7hcu37xFq/BGKIFkbgiv1Ad1eYXQz35zlI1BWkbGeNd57VmfXOpck7ro1ZdQ08av1F0+jNV0YfkG9gmp6M32/kNBPns6vwJ/d/lp6ShmvzbTYCyJ+G5Vg8vO9x5hIGcpZgwMXaf0Umgo9ZHONBqNxot4geTTu9wigjxQrFhrNcwI2fKVku8LV6tpqs1nwLuGz6RSaDyNyBpmY9JzOOK1od/2INF7hbvKoS0OnnyYb7iT4372nm7UAAkfO0LGzxx+vbx7nRxL+ppItX38zaVgRZn60cgrG7x/fNIe+d9kfxoY/qT/BdqTbzQab8QNyXuvhY92GXLF0jROL2D4l29kJuVYlyr9CA7Nf4R1E+Ml0xm4ZfmnTu1sjBL9F2MQgYMT7Idwb+uK/LKefGe7Kkyz96qDGpr8sO46jA6nMEw4pi9Wj0ZgdmUtpz/LOA0pk/ApKsRhAdYLx0HEbb2f6fD6ddZoNBqv4eE9+fC9Nzjzzy6/5pok2+biO1iuPfL0qmacMz3vu955/b6duMnNuclZ0knLbJODgMycum9smAk2f4kfOnSabT8hoIYFv5N006BA0uNeOX6bHovR1G/1vHceyj++ZJb2LoVnMNpVc1ywdJx3X+9HJJ2HOYY6h5t0UVl7DbCeIiZq6i7jF3fqbTQajZfx4o53IuSDJqW4jo9PziUwJfhQX4t0yId3lvkL87q8Q75njUxIct3i/XQV9v14VqtyJTO3kyiVPUK1WJWMHdFBKmpX+SVKAyGtn/XkGYUAVhLr9CACwd2a5WZbpY3jvegynjT1HOL24wVbT5sRglJNyqNxVc7DtmciBBAuu3WYm3MoR1o7841G4514cE8+W6grIkZ/P/OtmAwf0GHGeSgX75HKXDTjynk2JrhgFUm4U9Sf3bdJY3cMFRAxLXmTapGYZvp8Ut17rJP4ZsJ+2kJ3/pCzCF9n2etYp06uGx9lLGRmOA3DtccoRBHK9qd1Q1fk+qBOXW1JhaFX1It1RIOA7RW6ILaJ1+58o9F4Hx6E688Lt/fpJZBK9K+Z/CF+mbUdssC7DHqYhDXTkXauvZC+Z50kyc8aPTEHtsuecBYmJrGalctjCSrXdrWlo41Dtr7sAkXQGEA9FId2RGU4wmAWPV9XAPoxPdspdHnF0E+D7kOa6xCSsyajMuVm8qGf+HyC4kDd2DFXEVu1po5h/I+GSaPRaHwOPuDJY+g45iG9uEMVqsPu2se2knF0H1ynDJkOp/KpcFIgczsr5EZKngZVnH1wZ4CgVIvjPzziNDAAcnjKcJO5VV6JEZ0sPUfgQ+ydxwAMALSF5lEmmKqnXRw64/sizmQLlwLqWVoYS33la1/gMkGo7KfwG41G4w14QPJI6iJMIrNEXu8qr3b9zLR8L3OD37lXmiHdZx3bLzfZyYyX7PgkOxP1JPxaGUkP2pzkVqoYIxw+znL9GGc65hYRs2ToqGGwV05zoKxvpT/bP2yPsWy6fNyrgytIsqkcCX32f3d/z6k3P6PRZDKCEH4f3dgXkIdtua6ctjBsNBqNL8TD9+Q5Xhzz4pqdLWlXfb8m+qP9PLwKt3d5Q5lruBdbVzd4XuzB62GRPS++gSQP9b26dx78XWTBDtlg2DimujEokOjXw2C2blubK/hgXEism8rEm2WRYdqqpi0W2dEKSKchy51nxatCNof7yip4W0IzNVw/XZAC5OcVG41G43PxgU/NgveyXheq4qZ7Zcczpr8rbZdl/945m2koVVO5k+c3tSe3E5zQZ968b4szanMnr1CVPOTFgRw1ZohdMRFkbaNJ8f73SDdXdVBmqKoSXtdj1Tm5sFvmXQ6ns6tQCTwUud1EScK9+lWVDZF0oqcpMX16pSav8cFhX6/XG4xvE3yj0fgKeOjJJ+Rzu9e8jwPP3/5joEppVxn81Ev9LjG4dgn71/4we19ZfPjsrR5zrTzx6en4PVz5C+988aOPN++Q8ThYe8av7CwwDUJdBujoiDkc3iIfaTQg5m2d2HQpkMqSzXK1yeMjUl9oZM9s8h7XbWJ0prsIJ3ZRo9FovBsvhOvDqvhCvZs4a5qG7xVHOnCb7NqOJuTUh2Sx4wauTeM+PiP8DFX4lh0+10YWyg6A8mnMWb3aWXEV0fVOWObmZh3S/ccRqeVqJ5dJ2jVnB25JGJHxrwZKPo44tTM/ixoUcMGOTDnTtZudQqVqCFWoa9gvsO8MfjcajcY78LHvyQciPJU5peVl9sI4PX1fY7eexlOXZnx+pOvUYcwIX2MF14hSwpCE8tE6QZfzqT2xQudopKBgpQa5srg89YMa69B+rZURE5qITd0kQFJG3KgOVcje6+CumJtCLE/Ww3T3nduPClw/63P2yeXhr8wyXtFoNBpvxXOST0LiFwpXJs2p6mclVXzgPpe0uQ2X9swseGVZxfKW/IhEeZEdV+nlYO+Ysa990o1d1fH3zorh48lGTOZJXROh5xGvE6VPxbqqxZwbn5S2n3rZq+x1sJx9hnrPOOsexoJYhaM3jTYTFXNGxfDODXQu7TUKtjy37BqNRuN1PP5AzeWanJZwWLrAOZ1Lq43fi0BeWNswKMy+/fW0c63XNBMMakTdPbISVWmgoJCev97HG8k6QSU4uhCLs2Ez0oILPHzM4q0CR5LLix4zl1WhudyOr2fG8H49tsmP8Ydx2P3IghKXCjeGEkzq3LvfNYfMi1bO0EvJ1tpbJkOhhR8Z/aJrSCXpW/v0jUbjfXjt6fps8V2kM6mOmSB6f/frmjce4gLug6EVQyCxI3GfCGEuxJ44fJgajZdtwqDGvm18qv+2/Vl/cqom47eTwYO21e4ua9uD5xj2PFE/XtGBtz16XABYO87+0JvbTrtuF9HP+liO3hRwsw6yXETBT6JvFvJdurEgtkT2zIXsYMB8J/OaCzYW95uTGo1G4xPxwb3r70pttyeua4FKbhBW37pIqoX35ZFszR3MkHSUgEcnzYN3nTxmXX2W5xIOEYpTY3MI1Y+Oy2fZTqe8oLoj6nHGRjR2JeZAQxCBH4SLX3VTH2yAPqM6bpxO44XCxv12yyZ1Ri9sH/s+Whj7KESTIxC+ftdbOTUajcZn4PGnZuMqn636+CjcnY+SycxdvbksVkunf/kYjzNJ5HEWfJsDKTrKDy3r/hNNFUhN3cNUIoSRB03wUKxfWIcPstg3CqC62YCQdcHjaVhmZLg37oKbCxGOUZmbXdGNWWXKq0LgEB8P3yE0rzcbS6Ht3Yt1Hq866FR6Ee0aTe6NRuNr4OGnZp+EFdkdmqnkFS4SeR6oPHvQlfHxwA120nMSyCSfHOVTy7su9B/+7ICwCBfbwk32k9+sUNFysb98OQPY7p2XfJKjMPPV4LEU5EjnSftrKb/aHoJ5mCIEYdjB8HH32dHIGIaJYRm0dNz4NcE3Go2vg8d7109PRQM5ItPEp+Hnt7t9aPMOd2WypRjDoBKOUXb0xGPdTIN6x/2sbDxbdakhUxxJH1a28uMvWWM75mGi43vwGuvc2UGYVwVE4NhHWHRHtCv7y9kx6sPjJyyhttrx7fum8KqznbhEuQMwJDKjUmekAS49k1hQVcY+BNTAy5ZIo9FofDleeE9+UiOu1OzyxeV2byIyl91TVODW3YvF7zzDpdtOZzMkxa0tEig5Ua2IQagvJyL0GmBW9BzPyMqomoh9lwcvhIhukR2REul6nhlgvqKguYMYQXEI44SRpZtrRP1oVeF3zMdH5S711JXHYVSx8UohREnWmKn7XP0eXzTgKk0ajUbj8/DiB2o+AvSbcy/pi5oMrjG2lgmrW38tiGrH05nI3qSPaICHT/1YJpRnRQnsFZRYfvwi0it8rNHzNIlMOJXJbBNOnuXd8CamQMZtQ4H1+doqQATStlk5rRRSEjzobHt9pwd58KYipt/5onP8Zkp4qGBGLrzS17zZlruaIfNSRT68H1Wj0Wg8wMP35Dl2C4vZKstL2Vj0xoKoQVbVHruZG36RR8ZB6kxYomwLve2iDr1PHrl8BPE5bEt1+JzLsQGAfOvavHWnwaiaw2Sbqkolq7BycW6ch+lM0ndevVOBKiukQKhdSd2sCR53MdheCdxy55C75i30c5H25Pb1X2IIsHmF6tZ5/ISpC4PYaDQan4szybsQY1zRKyqtN6I9MVTqUoYS+LW6vG617Gf9YPJL3L/8u6SpZNZ56qtUajcRg87R41Ofrnb4BPm2CJT7YkCUi6GS+sCmcSMh24YDdjUjdR7KZEo9Ac8fcx55LIh1jPKva8Obor4Rlfhk+9qedo4ftE2fyKm67EoojG1Wptav0Wg0Phf3T9fzxuboQsFihl723f3SSPVPlru9rN6XrjSo/Os6vGxhmecCiZFAumyjCAl/pLENFKSYsNmU6jHKGu+SA7y1tiiYabZPzOKYqXHPIwmyqmgT2VYhkjboUSKblhkqQGPGNr3HqEmmsKWnmVEwf88XGpaxlCkG87emlIwaNg5qg63RaDS+HPfheo6/IoeoX7mvUvm+3dMAWOVC3LL64TKgT3ifaWrAaSgj+8vHHiwxkgR6ngcGXGQf/XUREdXrYS41Ng1YH25rky9GkK8S+Wyoju2AQyx96zZ/6mBGQou6U6t6q29o1JTeurgOrfFf9lk2OuhJe0MuVekUGVmH+9rygQbzHVDQYE4G2sbLuMmshUaj0fhcvLjjXe7GsfdUScHgr2kWCKXz4hvf5zjBlJR4uS9GDERkfZTlUbXdVJ6ZDJ/3u3XHjsHvxzoxAjKYBLjM99InpGaNiqj67YO14iDnlnuDIFgY3I5xf2W/wv/wIgq2lPOUYdadLD+nR6Mib1acmao4DHGOWNfZv2BONc83Go0342G4vswVkVmkWt1xgUUPq/7C3Kpsm0QwfRkLbu3exON3ikcv/AmTJOzhsskYYdvEVUU91JV1RZKmtkHk5yAQOLu5ZE+kqthOuoyt4Vkmc5UTvU/1vjL3Izk39oZrAWhAXH+Lb9jPMjosjeLSWgYg2imV4nTZ+qJzXua81sYUzrmuKR1Plzy0IRuNRuMjOJO8i6vG1cgTCC3nbvNvFBhqp03ivfD9O3rn8fxa5OvnAliHPJwtQ4foEWbtVjiVe/F1wmw4SV7YcNf88fRCPUlvU2CSfWZalXpRySz4EucPWU9uByHIPNwHCJciEa+5gnm5FZGoLi8REZubDeVGoftK3WEo25NvNBrvxCe+pEueoOr6spj55RXKR8T1mUOtKvPpcO/fVi719WMh/b4/qef/4Gn73ViMYLgiB8JOk46E6CMj7lXCcd96P8LAI2dxlGZMetRJPe9KtVRHW3KmfsehzIYO3PpqGNy4PmZQqpD2lQwDP7RevytEcpiuo7XWaDQan4YXPlAzcVrq8Ri84blqsmPssBdafnHLy88+7JrJ8LJjmHt+bEYLUsi89nphRhGmM5Jb90Gd2znHh11I9hRPriW0MtpW1cWqSEaLaKdICEejORXkUlboYqZi0HdUyrxc0ocunTG2xRW0umqlHq5mGk/fHcOpcapn8pa+Jv5hUNBtFmtubzQaXxEv7HhXu0fxtTlbJVcQGV6sZgr3FMyrPibbXnzVPzdtUP7egcvcxKduX+6fLRIaZxZC4hRvn66xe9ebGMDkCgmvPB6PLcppgh67rqTd63G+VABxS//EqXe9OQVP6FoxGO5TMMKcEvMpAYhQ3NQXEfdKYjLqIx03MDqwLsqpjAtXPnnKRN2fde0+sIgajUbji3H05K9Fdrp5lnimF6L3x5TgveLICxZLk5voqN/lZTLTYGswAfbCmy3gmZfsSXY532kJr4PvV9UmSQqRjyoyIPtJbc3HePHkDDXI9IyL8qvOCEvoLqViV3tsfIzDaWCEscm89wOWcfikPEYXVn0yNjjdRHhOyVpb6a4vB35eLWUXByrhKzQajcZbcPTkNT2522jmQIznFgRMiiRrkJEpeEJI22ev3JsZss78B3eE3D72rMEvXM1XBoKvXvbrCWxqmhsv09W2hJwcz6186Af+WUOBsZXiafakQ0vG2Iw+jdi4kILklwsYIq5+5pYHAifuNl8uSKVxO27Bu/Q13wfWXWQT/NLXotpN8I1G4824uSefrUL5Nq27fOKVl7J5RbUiHbQpn9Y6uXt7xc9f27P1290Wf2SvGBUgWU+RBUFANn4gl22L7V+zPgmKyMMksdBtlTjfHKh50pRKuH8fYzzUPsnGfmPkgt8315U/jJ9Bsunjej5IUV7VcWBc2AIavg7idIYZlN7urtFovBtv+ArddnHuljDjEwupQepruK+V+v/OS79+Mm82miN7AfdmxQO3LSvijI0t11P/9hh17lvLe9MvD/hscqEKHMnesnZ4P/XwRVZ0P803WdvTV6Hr2DZFC/D4cM3ITRaKd8Gb25fXk4FhvlcaS66bGnWNRqPxuXjwdH26jI8/GJZ28eC0zvQ01f0ddcJih0tkxn5cBtuxdXSs9gib1KauHAFPG1lqFzoEPebYjb+G/R7n/H1UCjv7NCCTNS0QZZnnmhtj0XtFD1T29rXo4LvYOhRf07vnmQMyPjhgYqa0s1wsH5IhkUfKmwnxquLgRHk5LhEU2cguYVcVOs7j1Gg0Gm/CDcmfViBLsk++rsHZXEZpqS5shE3aT5B8VGUdrtjtC0C6sJDqW/bRgLSlshNGXnvm6ibjkDISNLYCK4k/ifcTHg1LErdYSZFh77q61KPuuu189Zr/HR+iPuBRwvrpVwZZNxxDFRHT/Rqk61p2gVJngv11CXfGxmijGb7RaLwbD+7J1575xrVCTxo/kfHyarKF0zXFLm/8wthriyS5eEUwNdZR4V3vzx6bPz9qyG5mFrwwOmfpqQuKLT8k8ipYctD3ROJb/w+QGdpiRf3atvHzmgdv7HolDoePAzChkjnDzRs3XoZPnpWGPuYLvxRUajQajRfx8AM1p8Am7xXv80pY8UnaNDSLnn9yfzwkoM6VHqetb325TQRlYLtE5fEv+yZ4/Oa9bieAqQr6iaToujxOmIDuhidTHuqkvVaJslmQ+aJlwIIvuwSGP+pT9++sL2ClYDsq6409fpIf35N//NGipG+7qbtvNzQajcaX4wHJ576QD30Or6Ra/FOR+968MQGtYir4Tnfqn86Qboi/Zguo0tkLfpRVp8VCDR+ycWZRufAnhhJ58d4s2SRhjrSKvq8thqkTTKbVdEeFZcfbR8V0KC6jBZ8FDHM3m4U2dxPeI0+nliMhnDciA8jbbqhIOM8EbhERZzQq4sSO9r0t0eTeaDS+Du6/Qrf+zqXRcjYP65ZSFq7gkeWiMzcWzBV+Hk0LPrC3SWZ5hdxWok9d5lBX1ekd4xlJMCGTNEUlBcJT+MnpLkd13RiCd09KOe+Z3/HDaACmFUYYbmgfSJiCOkt3hZ9ZXqMqvqk4Jm5ouE3I99eFFxcjAdEwc3Eq9OyxeDAyRzNoLYSAyoNQRaPRaHwhbu/Jk68o41TmW8fzTrmOz27a3EglkBP6oD8iWMTteKdCizKt3CEdzmfDi8CyOHBVH5F41cfSd21lyWwogct+qOYe4bLtedp4qPDqOjARMiGrWYadLVEn6+NOC5q74tecXCpGAzGti+oXe93jtcIztru9349fxDzfVOD+rWGDbyDONlZxk/nxGdRl7/7nQi8By4TIhrPRaDQ+Gbev0J2eTkbavpbS8VEUcuU8XySbgmCucwmF8lHmXC7Dsl64b1guO87K3eGur4cqR881y+OKYNSIxNfXEn1S2wddbJQbhmiae1jF8qEOsPXK3So/T7JIAdoxQuPC3jGc4smuxyamjGu0uhLIrJ3GiYxrDcMPmc4Hgvd45TprNBqNj+GFV+hy1wNTJ9Fz0XwZqzzDTIvoLWrQLZG/t0UjGbt8TcpPFuFZ2xs/ItNZhLzcprmVHPUhAZN0iuCDgqBVK51KrkhJzpuFIEAx9LfDtyyOpO2DWnE4J4lnj3/euMvmrwRWdV4z6yNBKxRQzsZz9G53jUbjK+CFp+sj7XjOKtwqcGy288XuW9WuP89rYTkqASSyvEinCT45n0qAs9diq5EK8DTNlUBdaZPsKR70Gp22pBzw1T324K2E7ZWHzCFfYfxV+I31q5BdVkj2lR/0/L11t/ixupZQo5kb0iwfA5Sm85/OSIm68i4ykWpCSh2urkaj0XgHHm5rKxKJ3i9YPpwMS6pbxdiVZYIw+hml7O45eF4840J6a1aAt5tRVi45a/ssH6WfIwhVg6O9+Wg4x7IVOpIrcJ1FGyrHnSFQypnMd1kZFu7/03xl7RT2Vfb5gtxnTyJAMF2ZIYUm7Xp/walajW/Easpd9j6K1DTfaDTeiVuSN6DIJ4sSU//2TK+lc/vjVwi9flsdXDZYmTncnrWfSPpEZGZAYrRUj4sfXT2QU3jIIkKDrFAe/dZddNkFJKJU41BgXQPOjd2+b0aga4bxxnx48G1WAt2zMlD0bl5j7AmaQb1W6a389aHD+LncLdfHpao2vK2re4iG/Eaj0Xgnbr8nfx1cO4Tht8gzj1M1SYcCFTVOr8l/51vCCs0+ULaExzJVyVew2VmTtI1NK7mGR5a/8iYr0xNygbB0j9nKMywN7Q9ZuB0+j0dFiE4iqxUq0Pyhbg8ampQZ5pCHbRKn4WjHcV/Xl45rC9Tz1/KVsHfZo+4562i3wDOJatr+DwHRgDFbo2D+Vkaj0Wh8Hm6/Jz9JIvD3zpTpoWRIg9lJiNSt/svL4SWb/bdqgSRlDg85lUtsyABmyXvlKqqkb7Mvcs7rKXi4frCdQbSGabvoLiwsQn02f1iEu4MXj8EBmJ5gS/C0YEDDnXujJf0aHUQowiWQKi2LTPcVQgYevM+/qhVjkF1lW2FobpA0fAfQyViT4qIo8XuE502gG41G48vw6J785otJK+bZhkPHxAa66k6DQKeUVSzfHCau/9Pr96k3OKyjdRa3we4dnLzojEUfEG+FZMK8Z+49Y6Vn1ya7eonuaXgQEOIdhmV0GxAwQ8pMeNv/GD7IyFRFdqTAQP/8IlhvDqxL0RmeN+pkZXFbOzWpwul+/3lfJnj3tf3bPnyj0Xg7bt+Tv7aWnQsuvqY0w+u4irGLbqIFE1j4G+jGe0Q6Hcuz7zM5ytNibhYsjy57eVx3XZa9j8lD/rBTBpGSL3bs4jg6sSb7M7GrXSS3UWMNksb70nd6Zt53xmiVkcDTAW3i/LpnD4/jplCQZdv6Y24e9nUfLmtxVlUQdYsQCmk0Go334NaT1/B7piNNV3FV8N4lW4frldmFc6GdOw70MQJJ6zgPMnXG2QSJBJ82nEi4TthfDVqchaVtanKYy3N6O8/Se6JG535z9xMhWSR+R/DbK3/s1mpxRYE6GVenmNswp92w5blHo02LyEcy2RTomTaAkUinlnCwv9FoND4Xt568h/9ynKduJEaFlHz1jWQMeetJcQw9s1uYuXtT9pbuQ9vivMEKwUuH1jJqzs0b16HNgwrjdCJGl/DA47NDufFx9LLP2VBO9xhZKjGI1vvjJ5CY2+5U+VmwxcmtrgnzhpafHPhbK1bmWHE1WX46ry2McTUajca78IDkkcK8H4Ofipll2AiYTs5d5PYqP4yDQYRabqt2XpDLvOCR4S0A37+4be6uly7OaUa8cfAMMZLAdO8iKSu8XCnyLCys2UwlE6dCpI35iZN7GUa7B/t2wZbJz0Zem9CQIURl3dUBQ42jBvvxrC3rt2IYLvDRBtavnHPqJ3UiDP28qm6CL41Go/EpuP1ADYa72bfVkFp7i56ud92dzoSI50z2iZf+AvJ6d3GHSPgr97A963T0lJkoU2R43LV2me5KiXT+dKCWfoc60E3NErHuJEclZZBoobqTMgl5ZmREmYTB91Pv2ORm6diuuWLzqlQY7GWQ8LRYdTINVT+kcVrNF2g0Go034OGnZvex991n/LsOYmevGW3/nmWJvwc/Oceyepmfq+vHmwd765KMQnntn/pm1G1Q6glUcIE/eNTOC9+yr+cS4qtX5T2CG7WW/jAg1bi8hoNVsLavfSblKnopZuEdu9jc7jbfAEK2hqQsFJAZG0Pt0PysrrvyvGJqY4zbmnPw5SPfaDQaFR5va1sHjmdSFSbeqyRS8a5q3lljrzS4YCftdnub7mOrZ1LLfOXYB08oByZInXxPCL5clKXBBSU30YHdXm9QKev10JFMdV05pPMMhadb7yYCp/ueAvt7j9soTWW5pWH1KAXtA83myjeZHm9ef24sNhqNxkfwjORNiCIzcIz4NcwIAfmx62c5uq4tv+VMTd5nQyPEBx5veIP6MBHv+qa5JF0ZcbFftKyct8fDJDwP79UuZC/3HULJPkKT6Frm+CayOItXEoyMbIgD2SYjBwNaEjeJvEh5lomNnmM9aCbZiKxk30asWi4MgUaj0Xgz7kneOeywPJ32Vk/BZasQf3SpZslrbddY5tjmXopr5/UjrzIR8Y5d1XzEQ5EdZJ+w5xv7g6Rr4ELOCO8Ka5v4Hd3Q6w9dSoLJbCGEgEwxajfJKcz/9bxvxbRW/QEjylTEiq8UjkCQwvk8QENppamfnWUgiKytcLcpmvQWk9H1d/Mv5fg1Go3GZ+L+6fq1UQytSkqEMfe3L0k4IZh56pw+7x9zURHcgx3CsEl5n1pHIPSBHByBWTort6h4VPBPjc+xIstlthw25RkGCqTr+GWz+JSXNRP6olu3Vc984dIwSJC1Uw9KkKecl9l8lH4N3dgSyWC80wbnPNBIzGt3jJuzi5JX7ZifZ2r1IOYurqvkviTMN/jUXm00Go0P4MaTj2HiHDY87ppIufg6oI1iah/p5KFWBM/h0txscGdFF9D04FERocAGOmwW+2M6/EfcaS6ML+vsiQGf1nbDyUYSe+ruCLzYMNUV42IZOAXXt75SDm5/qES7/3NbvMEOeutBOTYFJrnPr8yRoQNivMYWfqeAaVWYLB19mps8mej1pb1Go9F4E154T56RuWAZoSZp7n2izAurIwFnrz3zXjlf07PSkS30QOr1KcwMkfmnZ4fvZh+NmoMsN1QqI6ICJTWRlDj0gete4J7U+WcCHw2kfeXLYZTNyuF4K9apFEODiyd7HON+D6vvYLRkYsv2MoDBFKJBh48nNRqNxpfihVfoROpAdkXK6KmKZE+O5+0VC59VuXnQNla15R8yobtwc8qKNbwHSYdpeABd8Ytt3bN+oSOQgd66gbc7iEnF21DxFTCF3+I9YDcw3us3OEh3r8NAi9ITDpM0URdn+yWWyOHS01Elm6t06rIoC9ueilk2oi1QLLzobi5644YZ0k7Xzv1V22g0Gl+Gx6/QeSQr5DoWMaNQKxYLa1rtP2dFlcnikaRkjT60F8XfV3btDi/5Cslm4zQb0TQrE7a+leLeN7cr5MwqHmwS3pHwFC94dJ4ISLcrVvdnk+r+VSozTTMnlZpIHW82nJIwAk+BjnlR8/fc58N9eKmjAcXGVW387vKNRqPxbtzekw+Lq8zlSwUf6nYco+JrsdeW+L7Lv4ZF30V8mSudt3SK11YUlbx+ltTy/qwIv2zl9B5PeE/v2LdsoTET20/KV+qCvOWpC1Sa5C8CnqW5uuwF+4Nq9BLLI/Fa3dPpriNYUF0jK56i6jg+Rhz2LKgZXzpB2/I6rUTPeaLohOIRlPPuflRkX4s2ohnphdBoNBpfDbf35ANRyX7dzHS/0BbLYW2myuD7y3oqP423Wn2POAkXx0zx5EPe7ExyRYLYucx7s4JDrjwe3uslfVILKesH6k8u6Rw2nQYH6zZ3pI9z4ESHcZxtjPE3Pzerf+b1WC0OPnQPtrn27qIjK3SxdV8WgZbjhEbMHA2nuoscbN2zSI+JjgfzjQZJvM0299gnY2aNAWQ/iSg1Go3GZ+GG5JP4JmCSCBNdlDFLV3EB+LtI49lqmBFzRub5OfRQ85IsCcn7otsYdRCR5IE3GEtDedCCI3JodxWOnwTyfD+NMI/qPMzuncc5v2bnXHdbRObLRl7cbWTGHI3ZGgY2qnQVvowIi248TdqjyyMZFDUuNPP9OPtxBKNnGq+rYLRI+7m7RqPxTjy8J5+tRHcknNV5sKKFIp7w0Gc2V159nXt+h1pRrxhlJWLlupoe5vWdm8/BZCS1se9/EEh1jPMyJLEWdTyaYAfjbeoa2oKdEVSqzpeNYE/cQ4JUPIq1rc+aD92dyqyyFZgAF5slYrAEIwhuyOnK4I2h0LoJ9Xy55vhGo/FOvPCe/AST0l1ZrleywKa3wosP3tKpbeL8szwrulXSPMl9vlSvWAbes011Q7YZZRfZ1GM42/BKxs65beV3gCHRo0hcP3b1Re82hs31XT1Bi+1y0XcPEkPOVJIn7OHamaI4XIFzhl/9y4MLubJJB7f6lnrs5fd57mzlRqPR+AI8eoWO6IF+OOaZxUKjzIhJZFoUQb/5ohJH0pXrfrYrqC55gTFugKoUnjgWqHox5e3xjU3GMLF73hvJ3jV3MqAKTF48FMrz/OeF3LCIelvkdFnMAMGyOHQnuO7BfIRBs20MkFMdZiiJjGxRyXyGy9obElsGRVfAwKgf82w0Go334eFmONdiXvtiWJbzzGdNYsw8IoO8RI/p0zqBhWcV1CPnavdHJTxaHfkV6FWdLDQ9XDN5cVj3t2Lue/RFQMSGUIVzdZkCIXX1fXf9kDQvLYSKsywbnSSh6xOxaklbFdNP8yW5fizOt9soUETM4MNGhqNsa46cAz/Ljl+bgBMrIcDSwyl4qzsMH/Lq+Vq4Dx80Go3Gx3EmeVXHfyabZM5skaRxUiBmk/GIeK1OlhKe0s6iC9HzcrS8imzCdI77IgMkB9TcvJftM6FBRSmFvjnYlApjgX0Dt9sbHb4tBU4jG+jcFo/RJPx5Oo2fbI45XWUbC1V5UN2G4mjgKBafuwjOV+7GvOqILFzNecMBjSwdlxQ56V7hZMrwEvIKQa4qDFNtNjcajcZn4UzyJjl1lau+86Eq2rtr8EPwXj6uwuY8Jl33YZNV2gujcKuE75ysqiNTZRAEeb7OoHDNgj+uLJqMk7kpgZI8J4o2cAH9BvWlU5c5/jhmS0viXJYTBQT1Yn5hjwVA+eN1ZXSssjoYDDvo/Npw16gq1psJznLadQK3j1Sbf9flDfWa5xuNxhvx4BW6O2Rl8i+0Vd5i7ZrmsvdSudvxwdBcu2fr6TQCIvml+8A7wQpElrDcKovkbIXccrQOmsf+cwA6czSrWEywR/CUdUYn3eLcnSIPjliLC2cbKTAph8szEHRo2+dWe8ifIxtxxJWOyJf3E4F/G41G4w04P3jnXJiKCnx+/h05HTl74XO+tO4ye3d5kWKJXjWf0N/24ZYrf1PDHPllJDn/+jsFM55snBG9S3Lzdyg98dFRHhKbJj9ScAZ2X2Q/2zjTLa+7RD8J5sAcavYo+YPJOs+27LD6I7vH3O0I9LhFZGxTSw0cldIZcQ96ZbrOKvn/HGV1Go1G4y04kzw/9BQI3FEepfHR9eN5iZfAmR/MgBehdJZHFpZm6ffYMx+OzJrBmOsJ80Dm4gjURPbDca499VbD2Du9DEPg8NMwoVGjXBHsnGoHwfOHcrDg6oyvfLuTHen+APP2x3pnP6lbiZuRBVuCrkTN6hxtS57cq6/8PyL49jz8FO5vom80Gu/EC1+h26vTfFmoXqA2od/LZ+PglWUvLrFlHLcgn8TJG1pYYICMn10fAhHbUklV6Ots+FCjids6NfsI/WyK2akKsqzMxD/n7weoNwcmf192xlQeG4NxpsiEHyNow5bk2KcjdBg9Mp6nAK5e3dD1bzULiiwqNdvvzSt83AdVWe/ZF+ENuiZm9zP7bp9k/4/6wbtGo/F+3O54F9fgvUN6tkTFxS4rlaR90f6euJgXrHFw5TNPH515Z4okBVXIicUQ72oG47y6+D+qq8wjW4msYd+V8de2kUJh6WyE3N7wd9Ow8qGzJVHTy2nDcjgU98crulHUWDYGhR7sGu/F5yLrFoJTHwmY8q4vKVaeto9D2apPIRUa72377HhVo9FovBO3JO/WfAjRZjuk+8XstKc9ph1d0RuYW4ijlGohrWLVZ8fylOe89LQgamnib3R7fea42WYPV/U6jo1wPGOFuKHe9R67J0QUcBGiuFfubH1u0LzuGH/O+jwdazfF/sqhQEAth4wd9y1383S8R9obOGLDzliNxuvABF61S67yzLHX8Z7+/KpeNN5Q+fbeG43G18ODzXAAuevpsxeyGEC+rKaCauft0GasnC+p5HHd4LxEl652WkpE9pPpWtddr+KBp/nI9XNK0sNnyM13UNqTHg8MmoEuUNMjtA4FiuvnKjoMCiW5Tqf0cJ2VFAoRmXm+X2fzmdy2qZVP3i/7a72jGDXQ5Pgqek1w+XXFRqPR+AR8wQdqGPcMlEtJUg+iFH7uWzr63udqqe2RtXwVTh03LrZiHCgfYrpoewD3mMiT4c3bTmR7nZK/UFFd0AGMJ2bDMTT77gB14GSdXe7wedoMDzVN1/HswIpEgOc+x3BF9p2uEsdt9Md/X4Bu66TXiB0uUDQo2PJoNBqNz8czkp+rpFto99HH1imMt36knop/XW+vqs/ERdaxvbJfJY5h93nsKK0m+NVVDG1v9xE/wksR9MS7vItVMIPF7Fie9K1Q5QG3hQAFfg52kq8JhMV93h6raTmM80XWFm/Vp8MAV4j5hx7Ta7my4WYfJLnabSjGApu8G43GDwGefYUurN5+wXzNz98rqa3ftW8eHUE8y1f6J3581tLUwj1RHrxbBBoqzuX1xZX4ixW0bWJk42nUxew19Khm3vuVBbp5giLh1dTchRfU9uuC5IXbMKTYeOFTpVfy5pRcf83XsPl8Rm5E4RsL+BCeuxqZq6fHPz1v5bv0Lowg9WCBqvjThkCj0XgzHnjySn9FPDFXi9rB5ZuhYLcIQxtpGPQVPIsunJ3X8fY7EPQ5jExjYf70yp0EpL74TQx4mS7pZjAUSWBFibAzinK3nPn7AUB8t2Na1PPtRwtlfz0O5j84xno98W4KD85Bo37nGz9nTg9vCCZK7DKT4Mv5gTrOVqVGISDRvN5oNL4mHt6TF8mXqFPM1C+jZ5JGUkYmGottWBnZDao8+6QaEa8/JuODteT3y4W4wZWVJNxfxBgq4wGd1WUb3Zs768lz3eeRw6p9BcnQSsfrGetn3HhxYXxlcXn9id2oq86em0dkuYgXGfa7nZf0ETNsVM26m9ozJ4MvwWuGa6PRaLyOB5vhWDjcCRl46cq8/ZiWE6ulId2cZHz9lE5TG+Buqd2ecv451BzOqcO2FRn3RkAlcAdDapVv1dTDIL2gXEWW/Ni4xuQ1JEJjxbJO7VfZ7hKjsMBJlDNqvNd/RXZ0GVE8zMdhx6CV2f3uyo1Go/EJePgKnWbu9AUXzjzEs5dbdMLJcGAmwbAve/a+5ktthjD7XuKnf+c9YKUuAnXVgY2tcxYcSZUGlsjqzDnCfBM/dUzqjmET9bAsqX2LbP/+tYvcHht36ZzaxNM1bFsZS4bcyV2yk87SB3WmV+4MTBh+VnFGgWxcC2xuus2Gsg41Go3Gm3D05KNvzCuzPCBuqJ6G1SuWYT12uXlOy3Le5K3cUyVoD/Yp34lzPGz/cOTDZAWa/fiR9np5iSF0nLiKHI5HdnM2An/btbLB+EckThFWgfZT3uKpXSFzXbouPV2b87PA3ozaZaawybiWX5aYjJGDGQSxi5KvMbn+ru7brr9uIul17F9YMHg2c1yRafDC3LnrRqPRaLwZR0/eBysvoEO2U+6kMFMxzjJgHzHZ9MC+FKSX3rBvzr/rXUcR9sNihslwfrWrk4AHkc0i6zv0+DW5oEdswvXr1PR6vWu2jUw9HOfpwaJTqYksUXFPm6nX2QUBTERxLgxK4EN0GA2xbbI5qCwjYH5CGD8lvISR+FUdL4m7KcU25yHUddO00ul/g1Ng9zW7MhmF7dRoNBqfjgfh+rHUunBnFU+9W1Ur+V5KhJevwkRh9HfmTvJB4nNNxyYS3e712qf+FSv0zC0Uj99kT3QcZLK6QE4u2jaaRVWYiFmtpBuJtVFnDXK+3ry7m//kewds8MArfIqF0Eha5XWYBIk8PmYjqXiibn9IBwwTjrpEtYWnpjYZoz6NRqPxLtyQ/PZe8kX8iS9yWM0Spy9KPC2Zh3x835v3iXde30s07iMZa6WPBO5r5GdMvs5pJLWmo1uS5NYuacySspWqFhmM28qMgtW07vA6MZrTn+0yTdJWWytEEhQOM19YjOnYgUzvsOMY2pqP1ZZGFW1eR9mlysaGK9Ns32g03oeHT9cbBFElJYv7pSpjBhX+7OmZiRR+Ti2fZIz7rzoX5kpGrcFSwWR/i55EWJYIMmY42qXP4fBCbrSp+hqjDImCt9WOGJeHNwBJJ+pP/Kicyfyu+nrVL9MB77/PSeBnGLAu9U+XAnlXqm6bUPge/gs429F2w+mueKzTK+PcaDQaH8Sj9+RL52Ot2NfPmZM2Ccy3nbcjReF3OzFd0CZ6edmWcJg95GiSWjZbyhoenHf+jtRbOJuuXfdue1neJNznD3Hpuo20j4+CNezK2u6YIz5xHj3YRiTLb1DsCrNua2CmhYH503CkugZ1oY+m/o39K2gwM6vBMRfJCYEUyb5dF1Wd9fMPNjcajcbn4IUP1PhYrSfps0/psZlgS8KsZPF2BQr1sFQRNZ2LcKgywtTIUesBuiNMsnv9K9yeEAWZMz7DtiuPDqktcpNyCGa8ZXOfbb666cURlUUyJtyZdsO9Dd546lUT92bGgbsMbNoDu3DQzSTctzfZHv/SeY5pvfFRurugZpva7hn1jrofMLB1VvtfNC+NRqPxALev0M3FCfxvWJziQnYP3R4TkaB7Nasi6tCgNz5EDo585u1C+uamYX7YITqB3rB7dQ6F5eOzN9Uxl+7kCHu3NFay94Bf2bbrnhz6J3vxnAcfrgD2Zmf+mpswuF6v6VxTmJ2CAHBBJIrti9Srtz5F560j5PwAmjN8tX8ZWzC81d+0r5nejUaj8UYcSV5d6DFbpqb3q5ByljgJIDrK6tdoEpR6pdEdj6FgYQf4uSmSE1jVPnp+eS1PLN6kiNvg3o2k90LX/XyV6xvoKuX9fZ0VaN4q4y32AuVGurw+z7qZFCMM2xvf0sIwOt3p2mLjATvH0QCsPowE4/RMEW+DSXib42BARQUitDhuNBqNz8YLe9eLICkh9c+XjLLlfmLHAWJBpueLYOlltHI1fE5PSfEE7A5S3b3yA1sVpHOjERpI0zbwdEJy1HuRdz3wRBf8+e1FZ4ph+apreULIc/ZEauBJvOsxy8EzB9twsV1ARwOZETju3xNn5yqnUYJpuOmebo2BgzBU6kUlXeNqjUaj8Ra8SPIeFaFvbPrWRWkVMcZ6bEpUrdRI3sE/NTtqGDCGI4fAThik9QHbTdYUf3ZeIGx5KiLCT9sVX7852jt8vESUzBbrZpYQMiR2VXemuV80NuzxZ7pyO6i/iVzfkbdQJER3qKn0ijvZJqugn7t8e+BxXWouew7RrW3ZaDQab8BDkp8LtQzP6GNvzGelLV+C5am/kz+drO5omgfMJdmiqyL09LS6xdu9UJCxBnFTaMipi31UETXY+54xGj89gJfFgRPjApPmmwDLfqmGO50mH1ZgG8iyfitlZNPs8tHwUXG3kDRWRUcfdV2RkkMfzYrH8Cq7DtOSiiGJbLhGo9F4N157ur4kIC3Sd+7+6z289LOjkq2b+SrK1G3rt9fgWvPjIn67qFP6Cj2vLpN3yt9jnyHxhFyy/gV9OIx883rgEWCAYKR7JqZiT22tp9JiMxZMQTJoDvqJgiG5vgmAzex27SDWPcE+5st9SZC8fmfgJaqvmgbHKcOT5UOvGDqDo9FoNN6I1zx5kcvbFHcnWU7LHUvZBxW1b+/5dpvUsEheK2nl22fPyqfvNDu1IhV7svlOHGnsxlbkQ0TTaPkevVwz9yDCycs+hiUq9kYNSFaaPWYd+mVJuUmCCq8D7nLIckm7cDlxxPwIJmYmbTcvMJAYFUHSLdokmwD+D3CHlKbP5y+7zaaCjUaj8R684MnPvzUp3vGQ4lkay8XSlQ55a3t9rxjEaIGeJb1moSYt1M7bc249MASQzcWHlfftXcS0R694e2kI5JHZFbHcTVmsNJPmIDgCJQf5VfiNkWAAwdA5XVsUIPKF7YUheVX5U/kRhMBoQ7xi2p1vNBrvw5nk71zzW/ACPZY2x2bT7T0pkct1b+wnxXKpmSkSw62xLvjvGp3HJZvjw0VkYZeR602CzItckYBEE0x2NpjuQqf5g7wYq4BjLfJMJEQaRNKH0wJ/ZzqtdN3Rh8mQJukOgCK6x66Y0qVOehlty2o51UZBGNcZL/P4XwMyV0TC0ulsNBqNt+H8gZrJWfMjHYEOAsWFoyzX45V4rE+LnpAlRxzFnW7evTu3HMLxCbh5nvHJquEYTej8MC7GesogubKGV2AdU4XMGBgnBpX3Vry6xeh26PO2om5pmzhwxum6vvy2xzsTub7aDm1wX+dYbkvCRXaiLbeUS+wVSPDzgN+lMwutOPHzI0Tr5gZv2dys32g03ogzydumAh+XFUrj9IxIA4WdsXaOq9w+Oiax+aK7vWsxObx7X/lu4PFVniu1F8cvFFpC1lfpePhqq8LnhyjCKf1u1/QZjkeS3ARrZlfIXrbKS5VM74roZ+Y0KFxsW/e5AZFmhtMk7Pkyfeq5QzWXODtAI1K67HirB/WIhtw2TXID7+6LD41Go/EluL8njwsjxDCRMBXONqrF68mippsQHgPjwL6yf/HqegiuimqnsQn4E74oCk0tWdPueNRVNFLIYKn6fzcun+Acrk1102G1pA2KT7sLYg/Sih7QYM258aaHRUd3xOavquoMjz2Gh/AHZ+mWmRfA+ixbxV0AoHs0jfcODGhPtB/faDTeiZtwPXg49E3282fYvbvmF7wnzHcqE80JlJ7X38pqSlCF1MXWkIsevEb+2wt4HktY4V2NLVq28IcTH1WILYH3eyTiSGpOHg+nqQuuxN5pHRlRkfCgJQ7pOrbthNu+5NylhkYBGEZXGZqnDznJMJMwyQbKum4a6QfdW6dZUMUZQI1Go/EeHEl+L5wiftWsiXLX3Mevrbd3pXFJfWUVz8u6iDE4rsqZRUV1CebJKIwRjeEhN4n8hjruVoG5gxJb7GsMaIPNqlcOmfhCe5qMa6au+TLLmMyMzZPNMgMRlb2TyIgdglrjwzTLroh2X5QZ3t+70aXRaDQ+GTfh+unRiORxzgtFgLQojSm5t/usjacktSnNMO3mY+22fs3z/K39LTcZH5Og+LptMNK5yOIqHhqjYz6fB5FTCliiG9k1aV5tpAQshx28b6rG47wL0nF2uYQ5A1K1qlihd+aejwiGiOztBg7ddlnJ9bSjPHeWR6PRaHwObr5Cd0/wInK+91zm3XucRMsr4M4pZ2yC2fVjiBqR88mmeRNZD3DjXeTNtaBjpeZ8Wt+SIub+LFGJzRCRRQAwAh10LARCHSzmZuQwBbixzLrrUwREUnKEzq6vEvObA3SaRShU1RtMfE/hgfFwiSViroM7u3z5vWQtx63RaDQ+Ex/8QI3lC/PK9Z5LTUqTkbKQZs5U/vGlitEYmDYX6xl+rkpqorv6ZjmkC/XiVqyuG1E+dWkVM6w4joiYAvFb8jMzToSeDp0uhXSe3kHFxT3mSKzN5ugCUah3FYXLcjbP5GpUIOnaZRcYGKFUqCDs+RGcNYNzvjDc8nAcnP5g0axv0zcajcYb8eGv0M3d4OcuJRyFDNSdhpfnCa3cy+1jcrYkalCx1iENF+vK07paCxrO3Hx59p81tWTP9WCe6DBaeNAGAW5n8Hohz7ULBKJUP+uWHV8GT6ZFxHvPPF5InsHr11XnCnUXd/P5HjsbNSaibhN6Ebc1LextT8+GJhES6n8RFgk2D6oYjIwCiTWEDyxezfcLdI1G4714geQ94blXneA1sL1uclj0TDCvqHGqbrxym1/N1+a2R6KfPTS/4CMBJS76cuApsrurVsaHFvm4FS8r6nXgyErhpPomiAWDAbHGyHxoRqnC8va9/imHPmK1A/3pZTxZdo+I9TI6nzpl0+C6CBYC1Q0Ga2I77oYg0UR4RJ4GBBqNRuOjeETy6I+u96fnggWLbb1+q4T7qSekxsKLy2EVIKDslzwp9JKDOrYW8kX2kkc1QpRj/fWevtet0DTrlIgj3P1qnoailtU9NOctGC60B9p5wR8YbDTNeNue5bwvMi+ujYRFvcFmIW8bXKPt5NpxgCBD4rsnLTStNxqNr4dHJM/+GW5+w+v3XsZOK3rm8fECqG4hfhrajNwDq/Q8TJryIBeZw8DVk4aOQTJv/6AzCNC7cEVory7uPkKXcDI6vRnP7+BF9NR9H4kN0f47jvUWg8GCEpkhAi/Ul0ZLCm/0XCkWDLRdEgQmXn5MN7oeY3uNRqPxTnzgnjxTkke5WWqajP46mwo+SuD90Bx4Hzhzly/69C6+JmSwnqPnJ9Crp7v56ynTlefqUMedgw5pJNm46QcWQIicYBhCvLctEh7mc9UKh708H/WCsx3ce9/+2pHWQq4/RFm41S7pk41vkCN+GjNbc/71uyR6JcPQYTRK57lR+RfDG41Go/EizjveiYj39RJPTmDBUvHkklVZGVzf5yO3VGLIJBDcgGblJRWVj1SuLVLnXuzMUFgWnXQdpodzWfd47b3rt9xJPIsw1MB88a/VuZZVYAO+ihhG1MN0b/s+26Iqun4l4zKHxU0TWCEU2ZhcZQL9AqK9+jMNt92A/zzBHsdL3/FoJ3yrNQsMXA3j3O2J43OssgqMZoPdAnPEAzP1m0luOqA5Z9PE7KhXo9FofDIekHwWHy3OC+dxk6/eFVy/8Xvv+aKYvJ/uFIGtd5c7lWAt5IaH4mllHKMXvPpTlJmCRAQ/mILe4Gre9oH6l7oFH3pbpDV2X4u0p76rg91t56TDsCMMwyg5OJegajQSkow9QhbqTZvQ6QfueGZSmusgTIhBKWRXUyqemAoJUQfjsPpvkI3V7CNdHukV2DzfaDTeiA+/QrfxZJXiRTlbQW8MiCdhTVy32dtMaBtlb17QcV6UX8460pdt/gBn3suEbpj3+dOb13ql40fZVrvgPaO/euUBwQ4GVVcfG+DmjQYOBmB0EGWtEfKd8aS+iscx2IZLwr8qURecp9MOTEu++nMnPOkjFskuSaiaZbsuhnk76NpoNBpvwuOn6z+8Fhn9fUjeOcUCOwAmifh99kn8IA3nXBFRXuXMn3L7aT+I1Z16qC+z/9YeWNPJCfygVG+SpbnUdVJ/NIbGdhhCOBw+KhAU3xnpFBZlUcuhXMmDc5OANUSF6XUi0oTPw/S4Ywtl4zMC3lHncUptiwLN8Y1G4514sHf99Ze5ZePGZSk8sr0AxqBstWafF0S/pGb8neuGpoNn9yVjHsCj6kzxiuVCI/A3qe+9TIlDmvKlHfLvmC0XV3q5/GChTE8V2M/2HxfsWF3CHext1822meVj0H/FLfjZD4vVbue+Mk4C8Z9FRWzrbD3Yefjv0Wg0Gu/CvSfPBHFLGNdqNhd05q/ilBrIc71tcaPIwbvDZFtaXvejp+e2YwN5aHengjWAzIZMEzbkyRTK3PZXOxYjHS5svLoAjIzkCBEB73Qbd2HU55HcXdkvWg4xKtdDdEoN8o56KA2stNX+VsrXA26e1bIrZAQE0jYLeyy3aenEGX0mLiDkDMVGo9H4irj51Kyth6n2k+J16Qt+4V8e7ksuy9PVsBa6AsE33xrdAeP9DbOLu75zlVbvghwkZ3TfRq7xu9I0QtMemEwwPV+DttLxG6x356GHyMGDsR3tpUOmW00fKfGllTuNA7i+027OmTeR5Fb7MB4OamdXnlg2VyODojL74cYYyUmHa1xWaAL6sn7Qz5d+M3+j0Xgfbr5C58nh2XI0PTrytEKp9VJVkMvPVW8fEWXeWw0mBus2l7dwSjTlosqZBFd2lic24rC1C7E7IiWDolR3e+tpOS5GzV7fGdjeceUc5wJJaX+BVAqTVWP+7yiaRXzm448m8ZqoWgyOdkHSPk/j9TTykcTnh+UwELKqs/w7lNdlo9FofB5uPHn0MsWFRO+9k8kaOQvMV7Xy99izOicTI4aNXapuEwVJ9dLy0lGzRVftQX+BBpxb9wCZh05e9CTyLICA8zHUPZO+wHxOh5ryHVzXdsiBHeFbsF4J/7OBdRlHtvu5vP7JtLGiZgPKl+CcaOb0YOT583UcvPOkTeMDarND941G4yvhSPIp742/FT/tcg9i9MvNlXyVhWJHaYe6rqm88ipxOeLjCXy9M1MKMdwYOqyJPbArGHDBigenei8TCqMMTxm3Cp9wmZcqnIGhbP7k6szSrDBqsQIrevzsrJN1GhNqIhR9PPGCl1DQZ55e9tGD/xONRqPxibh98C4NlbuznReXr3uPnB8MO0VYrwJnui44ItXGc/EOgRuTq/nospdlxeLtvTfn3Knuz77OODCjMBRmln+77EAcY1Bmv15GEspIbYBTZe4LKDKjAmX1O7I1uAJ1/91tscKFPLzEefKzfohI2JowuU58+STK0Gg0Gm/EDcnvrUJf9eXqsn6Bz6Krlfe6jlK2frZiJj6i1ypxA7Nvs+iMlS8SNFLeXHuOPypiXyXu3EweJ3KLzeuCKp5BHbU587GZO/3W5BoNzRqA8ReGMVwPRKBTTmnIVeQ9Kthi4eRqxqTEsElhKmZ+l8GsCof6j/o2Go3GJ0LtlU/ANhqNRqPR+N7gE7a1bTQajUaj8cOIJvlGo9FoNL5RNMk3Go1Go/GNokm+0Wg0Go1vFE3yjUaj0Wh8o2iSbzQajUbjG8X/BxkCRxR50qjzAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 648x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 648x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "N = len(dataset)\n",
+    "for idx in np.random.randint(0, N, size=(10)):\n",
+    "    show_image_pair(dataset[idx], 1/4000, idx)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "plain-finnish",
+   "metadata": {},
+   "source": [
+    "## Test DataLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "elegant-measurement",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataloader = DataLoader(dataset, batch_size=32)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "light-paris",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([32, 15, 256, 256])\n",
+      "torch.Size([32, 15, 256, 256])\n",
+      "torch.Size([32, 15, 256, 256])\n",
+      "torch.Size([32, 15, 256, 256])\n",
+      "torch.Size([32, 15, 256, 256])\n",
+      "torch.Size([32, 15, 256, 256])\n"
+     ]
+    }
+   ],
+   "source": [
+    "for batch_idx, batch in enumerate(dataloader):\n",
+    "    print(batch[\"image\"].shape)\n",
+    "    if batch_idx == 5:\n",
+    "        break"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "torchgeo",
+   "language": "python",
+   "name": "conda-env-torchgeo-py"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 4d39acc229b7ea878225bb3148ba7ea665d0c10d Mon Sep 17 00:00:00 2001
From: Caleb Robinson <calebrob6@gmail.com>
Date: Wed, 21 Jul 2021 06:14:24 +0000
Subject: [PATCH 5/9] Adding some dependencies

---
 requirements.txt | 1 +
 setup.cfg        | 1 +
 2 files changed, 2 insertions(+)

diff --git a/requirements.txt b/requirements.txt
index d22db4fb42f..04089519d27 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -18,6 +18,7 @@ rarfile
 rasterio>=1.0
 rtree>=0.5.0
 scikit-learn
+segmentation-models-pytorch
 setuptools>=42
 sphinx
 torch>=1.7
diff --git a/setup.cfg b/setup.cfg
index a7a10ed564b..9d60e3d8595 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -64,3 +64,4 @@ tests =
 train =
     pytorch-lightning
     scikit-learn
+    segmentation-models-pytorch

From 337a6b9bf9eab34fcf466e6952ff70a411864e61 Mon Sep 17 00:00:00 2001
From: Caleb Robinson <calebrob6@gmail.com>
Date: Wed, 21 Jul 2021 06:19:58 +0000
Subject: [PATCH 6/9] Formatting fixes for docstyle

---
 torchgeo/trainers/sen12ms.py | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/torchgeo/trainers/sen12ms.py b/torchgeo/trainers/sen12ms.py
index b834ffa6dd2..57c8e76aa42 100644
--- a/torchgeo/trainers/sen12ms.py
+++ b/torchgeo/trainers/sen12ms.py
@@ -31,6 +31,8 @@ def __init__(self, model: Module, loss: Module, **kwargs: Dict[str, Any]) -> Non
 
         Args:
             model: A model (specifically, a ``nn.Module``) instance to be trained.
+            loss: A semantic segmentation loss function to use (e.g. pixel-wise
+                crossentropy)
         """
         super().__init__()
         self.save_hyperparameters()  # creates `self.hparams` from kwargs
@@ -131,12 +133,7 @@ class SEN12MSDataModule(pl.LightningDataModule):
     )
 
     def __init__(
-        self,
-        root_dir: str,
-        seed: int,
-        batch_size: int = 64,
-        num_workers: int = 4,
-        api_key: Optional[str] = None,
+        self, root_dir: str, seed: int, batch_size: int = 64, num_workers: int = 4
     ) -> None:
         """Initialize a LightningDataModule for SEN12MS based DataLoaders.
 
@@ -155,7 +152,6 @@ def __init__(
     # TODO: This needs to be converted to actual transforms instead of hacked
     def custom_transform(self, sample: Dict[str, Any]) -> Dict[str, Any]:
         """Transform a single sample from the Dataset."""
-
         sample["image"] = sample["image"].float()
 
         # scale to [0,1] separately for the S1 channels and the S2 channels

From 1dd1cc10e0215d223e9a6e253a2cb3015cc78207 Mon Sep 17 00:00:00 2001
From: Caleb Robinson <calebrob6@gmail.com>
Date: Wed, 21 Jul 2021 07:39:56 +0000
Subject: [PATCH 7/9] Fixed mypy and made loss argument actually work

---
 torchgeo/trainers/sen12ms.py | 26 +++++++++++++++++---------
 train.py                     | 11 ++++++++---
 2 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/torchgeo/trainers/sen12ms.py b/torchgeo/trainers/sen12ms.py
index 57c8e76aa42..ce0de1658d0 100644
--- a/torchgeo/trainers/sen12ms.py
+++ b/torchgeo/trainers/sen12ms.py
@@ -1,10 +1,10 @@
 """SEN12MS trainer."""
 
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, cast
 
 import pytorch_lightning as pl
 import torch
-import torch.nn.functional as F
+import torch.nn as nn
 from sklearn.model_selection import GroupShuffleSplit
 from torch import Tensor
 from torch.nn.modules import Module
@@ -26,7 +26,12 @@ class SEN12MSSegmentationTask(pl.LightningModule):
     package.
     """
 
-    def __init__(self, model: Module, loss: Module, **kwargs: Dict[str, Any]) -> None:
+    def __init__(
+        self,
+        model: Module,
+        loss: Module = nn.CrossEntropyLoss(),  # type: ignore[attr-defined]
+        **kwargs: Dict[str, Any],
+    ) -> None:
         """Initialize the LightningModule with a model and loss function.
 
         Args:
@@ -37,6 +42,7 @@ def __init__(self, model: Module, loss: Module, **kwargs: Dict[str, Any]) -> Non
         super().__init__()
         self.save_hyperparameters()  # creates `self.hparams` from kwargs
         self.model = model
+        self.loss = loss
 
     def forward(self, x: Tensor) -> Any:  # type: ignore[override]
         """Forward pass of the model."""
@@ -50,10 +56,10 @@ def training_step(  # type: ignore[override]
         y = batch["mask"]
         y_hat = self.forward(x)
 
-        loss = F.cross_entropy(y_hat, y)
+        loss = self.loss(y_hat, y)
         self.log("train_loss", loss)  # logging to TensorBoard
 
-        return loss
+        return cast(Tensor, loss)
 
     def validation_step(  # type: ignore[override]
         self, batch: Dict[str, Any], batch_idx: int
@@ -63,7 +69,7 @@ def validation_step(  # type: ignore[override]
         y = batch["mask"]
         y_hat = self.forward(x)
 
-        loss = F.cross_entropy(y_hat, y)
+        loss = self.loss(y_hat, y)
         self.log("val_loss", loss)
 
     def test_step(  # type: ignore[override]
@@ -74,7 +80,7 @@ def test_step(  # type: ignore[override]
         y = batch["mask"]
         y_hat = self.forward(x)
 
-        loss = F.cross_entropy(y_hat, y)
+        loss = self.loss(y_hat, y)
         self.log("test_loss", loss)
 
     def configure_optimizers(self) -> Dict[str, Any]:
@@ -109,7 +115,7 @@ class SEN12MSDataModule(pl.LightningDataModule):
 
     # Mapping from the IGBP class definitions to the DFC2020, taken from the dataloader
     # here https://github.com/lukasliebel/dfc2020_baseline.
-    DFC2020_CLASS_MAPPING = torch.tensor(
+    DFC2020_CLASS_MAPPING = torch.tensor(  # type: ignore[attr-defined]
         [
             0,  # maps 0s to 0
             1,  # maps 1s to 1
@@ -159,7 +165,9 @@ def custom_transform(self, sample: Dict[str, Any]) -> Dict[str, Any]:
         sample["image"][2:] = sample["image"][2:].clip(0, 10000) / 10000
 
         sample["mask"] = sample["mask"][0, :, :].long()
-        sample["mask"] = torch.take(self.DFC2020_CLASS_MAPPING, sample["mask"])
+        sample["mask"] = torch.take(  # type: ignore[attr-defined]
+            self.DFC2020_CLASS_MAPPING, sample["mask"]
+        )
 
         return sample
 
diff --git a/train.py b/train.py
index 3a71b681065..afed5a3cc9b 100755
--- a/train.py
+++ b/train.py
@@ -4,8 +4,10 @@
 
 import argparse
 import os
+from typing import Optional
 
 import pytorch_lightning as pl
+import torch.nn as nn
 from pytorch_lightning import loggers as pl_loggers
 from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint
 from pytorch_lightning.core.datamodule import LightningDataModule
@@ -150,8 +152,8 @@ def main(args: argparse.Namespace) -> None:
     # Convert the argparse Namespace into a dictionary so that we can pass as kwargs
     dict_args = vars(args)
 
-    datamodule: LightningDataModule = None
-    task: LightningModule = None
+    datamodule: Optional[LightningDataModule] = None
+    task: Optional[LightningModule] = None
     if args.task == "cyclone":
         datamodule = CycloneDataModule(
             args.data_dir,
@@ -176,7 +178,10 @@ def main(args: argparse.Namespace) -> None:
             in_channels=15,
             classes=11,
         )
-        task = SEN12MSSegmentationTask(model, None, **dict_args)
+        loss = nn.CrossEntropyLoss()  # type: ignore[attr-defined]
+        task = SEN12MSSegmentationTask(model, loss, **dict_args)
+    else:
+        raise ValueError(f"Task {args.task} is not recognized as a valid task.")
 
     ######################################
     # Setup trainer

From 183422bd39a773121263c0320683cc2ae43d2c1f Mon Sep 17 00:00:00 2001
From: "Adam J. Stewart" <ajstewart426@gmail.com>
Date: Wed, 21 Jul 2021 15:29:12 +0000
Subject: [PATCH 8/9] Add tests for SEN12MS task

---
 spack.yaml                                    |   1 +
 .../lc_1/ROIs1158_spring_lc_1_p1.tif          | Bin 412 -> 525066 bytes
 .../lc_1/ROIs1158_spring_lc_1_p2.tif          | Bin 412 -> 525066 bytes
 .../s1_1/ROIs1158_spring_s1_1_p1.tif          | Bin 412 -> 525044 bytes
 .../s1_1/ROIs1158_spring_s1_1_p2.tif          | Bin 412 -> 525044 bytes
 .../s2_1/ROIs1158_spring_s2_1_p1.tif          | Bin 412 -> 1705920 bytes
 .../s2_1/ROIs1158_spring_s2_1_p2.tif          | Bin 412 -> 1705920 bytes
 tests/data/sen12ms/ROIs1158_spring_lc.tar.gz  | Bin 367 -> 2007 bytes
 tests/data/sen12ms/ROIs1158_spring_s1.tar.gz  | Bin 366 -> 1992 bytes
 tests/data/sen12ms/ROIs1158_spring_s2.tar.gz  | Bin 364 -> 5129 bytes
 .../lc_1/ROIs1868_summer_lc_1_p1.tif          | Bin 412 -> 525066 bytes
 .../lc_1/ROIs1868_summer_lc_1_p2.tif          | Bin 412 -> 525066 bytes
 .../s1_1/ROIs1868_summer_s1_1_p1.tif          | Bin 412 -> 525044 bytes
 .../s1_1/ROIs1868_summer_s1_1_p2.tif          | Bin 412 -> 525044 bytes
 .../s2_1/ROIs1868_summer_s2_1_p1.tif          | Bin 412 -> 1705920 bytes
 .../s2_1/ROIs1868_summer_s2_1_p2.tif          | Bin 412 -> 1705920 bytes
 tests/data/sen12ms/ROIs1868_summer_lc.tar.gz  | Bin 368 -> 2006 bytes
 tests/data/sen12ms/ROIs1868_summer_s1.tar.gz  | Bin 365 -> 1993 bytes
 tests/data/sen12ms/ROIs1868_summer_s2.tar.gz  | Bin 364 -> 5134 bytes
 .../lc_1/ROIs1970_fall_lc_1_p1.tif            | Bin 412 -> 525066 bytes
 .../lc_1/ROIs1970_fall_lc_1_p2.tif            | Bin 412 -> 525066 bytes
 .../s1_1/ROIs1970_fall_s1_1_p1.tif            | Bin 412 -> 525044 bytes
 .../s1_1/ROIs1970_fall_s1_1_p2.tif            | Bin 412 -> 525044 bytes
 .../s2_1/ROIs1970_fall_s2_1_p1.tif            | Bin 412 -> 1705920 bytes
 .../s2_1/ROIs1970_fall_s2_1_p2.tif            | Bin 412 -> 1705920 bytes
 tests/data/sen12ms/ROIs1970_fall_lc.tar.gz    | Bin 363 -> 2007 bytes
 tests/data/sen12ms/ROIs1970_fall_s1.tar.gz    | Bin 362 -> 1989 bytes
 tests/data/sen12ms/ROIs1970_fall_s2.tar.gz    | Bin 364 -> 5131 bytes
 .../lc_1/ROIs2017_winter_lc_1_p1.tif          | Bin 412 -> 525066 bytes
 .../lc_1/ROIs2017_winter_lc_1_p2.tif          | Bin 412 -> 525066 bytes
 .../s1_1/ROIs2017_winter_s1_1_p1.tif          | Bin 412 -> 525044 bytes
 .../s1_1/ROIs2017_winter_s1_1_p2.tif          | Bin 412 -> 525044 bytes
 .../s2_1/ROIs2017_winter_s2_1_p1.tif          | Bin 412 -> 1705920 bytes
 .../s2_1/ROIs2017_winter_s2_1_p2.tif          | Bin 412 -> 1705920 bytes
 tests/data/sen12ms/ROIs2017_winter_lc.tar.gz  | Bin 364 -> 2009 bytes
 tests/data/sen12ms/ROIs2017_winter_s1.tar.gz  | Bin 364 -> 1992 bytes
 tests/data/sen12ms/ROIs2017_winter_s2.tar.gz  | Bin 361 -> 5131 bytes
 tests/datasets/test_sen12ms.py                |  26 ++++++++---------
 tests/test_train.py                           |  27 ++++++++++++++++++
 train.py                                      |   2 --
 40 files changed, 40 insertions(+), 16 deletions(-)

diff --git a/spack.yaml b/spack.yaml
index fa43d29ee46..3a8e9993b8d 100644
--- a/spack.yaml
+++ b/spack.yaml
@@ -21,6 +21,7 @@ spack:
   - "py-rasterio@0.3:"
   - "py-rtree@0.5.0:"
   - py-scikit-learn
+  - py-segmentation-models-pytorch
   - "py-setuptools@42:"
   - py-sphinx
   - "py-torch@1.7:"
diff --git a/tests/data/sen12ms/ROIs1158_spring/lc_1/ROIs1158_spring_lc_1_p1.tif b/tests/data/sen12ms/ROIs1158_spring/lc_1/ROIs1158_spring_lc_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..ae30f9baac7cc151bcba8e3f3c9c7e90a9219f27 100644
GIT binary patch
literal 525066
zcmeIwv1$}i7>409JL@KdAh9rML>6MBjfH}iku4;GjnP;rHmj}n5)d-NcHYFaf&}pj
zrWb4kOPSWf!VB=*>;_iQ+UCjd=KMKlW<s9q{{FSHUP{?2rK(GnY5uKRnFpDN+5VjB
z<^KG>(aL<G8kW869p>QTa)18J_R74Id4A8=bZO<;2bt^a9S%x4$UJ}UY3B3I=IQ?P
z%*Ssx%P9LtnLo_xGS2)y^T}*bE@%FcdH%JvymG^Ty*Ba(ZS1B=nx-bTsY`vTtDL7v
znx-bTsY`vT2RToZG)+xvQ<wTw*Evs<G)+xvQ<wTw4|AR-X_}hUrY`lVK9}<}Nz>G%
zHg%~_^(g0QlBTIiZR%2=>b0DwNt&i6wW&+}+Tx#)57OdV{CH*W&vkjzUzU46$4|a|
z+qv_xKK@kwdUogRmigOC$=mZ0IeqhT9Sl!q+c~M$PiAXnyNvRIuFAXJvN>PBzZssc
zS9c%ZJs97<IlexA^zi=p^{baJ#y4&q94&T_&VGrN009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
jAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly@K1r?6nRP|

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1158_spring/lc_1/ROIs1158_spring_lc_1_p2.tif b/tests/data/sen12ms/ROIs1158_spring/lc_1/ROIs1158_spring_lc_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..ae30f9baac7cc151bcba8e3f3c9c7e90a9219f27 100644
GIT binary patch
literal 525066
zcmeIwv1$}i7>409JL@KdAh9rML>6MBjfH}iku4;GjnP;rHmj}n5)d-NcHYFaf&}pj
zrWb4kOPSWf!VB=*>;_iQ+UCjd=KMKlW<s9q{{FSHUP{?2rK(GnY5uKRnFpDN+5VjB
z<^KG>(aL<G8kW869p>QTa)18J_R74Id4A8=bZO<;2bt^a9S%x4$UJ}UY3B3I=IQ?P
z%*Ssx%P9LtnLo_xGS2)y^T}*bE@%FcdH%JvymG^Ty*Ba(ZS1B=nx-bTsY`vTtDL7v
znx-bTsY`vT2RToZG)+xvQ<wTw*Evs<G)+xvQ<wTw4|AR-X_}hUrY`lVK9}<}Nz>G%
zHg%~_^(g0QlBTIiZR%2=>b0DwNt&i6wW&+}+Tx#)57OdV{CH*W&vkjzUzU46$4|a|
z+qv_xKK@kwdUogRmigOC$=mZ0IeqhT9Sl!q+c~M$PiAXnyNvRIuFAXJvN>PBzZssc
zS9c%ZJs97<IlexA^zi=p^{baJ#y4&q94&T_&VGrN009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
jAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly@K1r?6nRP|

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1158_spring/s1_1/ROIs1158_spring_s1_1_p1.tif b/tests/data/sen12ms/ROIs1158_spring/s1_1/ROIs1158_spring_s1_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..df0502117655136f244499d2a84519f67d9cb4a7 100644
GIT binary patch
literal 525044
zcmeIwv1-*|9LC`<ImgouMRc%TL=M(P7Y79$YZj@XgH;>^hk%Z{OF@W2H%BiZHy}m4
zfn0##A~>2WaOeg2ragrYI=eg#zmq@Tmz)!xW_R~SSudqrD5aW}D%12)otf**b(WVo
zW~=q-y2Y9KVl^*2S$mX?ORM$ip3T)f&%Bj+y5?KDeCFQAt2xVMFY|QYEXVox8~Mz4
zW}*AAQ5KnBW&V6H%afGyDf8h$U9M#QG2Jx%O%M4WkE1-t(bd$XHg%~_LmE?EWj{5k
zO<n5Kkj7Nk*-uSsQ<wTQq%qaA?58HRsY`tt(wORb_EVGE)TKTRX-xIG?58HRsY`tt
z(wOQ+_EVGE)TKTRX-xH6_EVGE)TKTRX<R$`ACzl5C&TG^wfvXUgWt>N-+yl1`!egk
zR!1-HonBIvDr3GcFU~aQ^*TP+^TUJ9>{RQA2Ww@sEb{7B<>PkQn9jf6&5zI5x1ZhL
zTi(6Byt#b(<l*w|o7XRwx9;ripRDem{)jUH0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
f1PBlyK!5-N0t5&UAV7cs0RjXF5FkL{p8|gX(6EAY

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1158_spring/s1_1/ROIs1158_spring_s1_1_p2.tif b/tests/data/sen12ms/ROIs1158_spring/s1_1/ROIs1158_spring_s1_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..df0502117655136f244499d2a84519f67d9cb4a7 100644
GIT binary patch
literal 525044
zcmeIwv1-*|9LC`<ImgouMRc%TL=M(P7Y79$YZj@XgH;>^hk%Z{OF@W2H%BiZHy}m4
zfn0##A~>2WaOeg2ragrYI=eg#zmq@Tmz)!xW_R~SSudqrD5aW}D%12)otf**b(WVo
zW~=q-y2Y9KVl^*2S$mX?ORM$ip3T)f&%Bj+y5?KDeCFQAt2xVMFY|QYEXVox8~Mz4
zW}*AAQ5KnBW&V6H%afGyDf8h$U9M#QG2Jx%O%M4WkE1-t(bd$XHg%~_LmE?EWj{5k
zO<n5Kkj7Nk*-uSsQ<wTQq%qaA?58HRsY`tt(wORb_EVGE)TKTRX-xIG?58HRsY`tt
z(wOQ+_EVGE)TKTRX-xH6_EVGE)TKTRX<R$`ACzl5C&TG^wfvXUgWt>N-+yl1`!egk
zR!1-HonBIvDr3GcFU~aQ^*TP+^TUJ9>{RQA2Ww@sEb{7B<>PkQn9jf6&5zI5x1ZhL
zTi(6Byt#b(<l*w|o7XRwx9;ripRDem{)jUH0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
f1PBlyK!5-N0t5&UAV7cs0RjXF5FkL{p8|gX(6EAY

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1158_spring/s2_1/ROIs1158_spring_s2_1_p1.tif b/tests/data/sen12ms/ROIs1158_spring/s2_1/ROIs1158_spring_s2_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..35d51e381ff378cacc18515ca526d80e45305ab1 100644
GIT binary patch
literal 1705920
zcmeIzf2daV9l-JP-0RP&sdIW~`_T<IMjIox7A_*1M2HKCb|(_jqJ>06lZc2`A?4x{
z(IO%uBBDh^M94)XBBCcEBBDYfLLx#UG9p^Eh=^$Ks|F6-pZjaCdw4(RbHC3y=fdlI
z;cVIR^I^#_46BA=G&zi#=08Tq%@fTlT7Io2kFC#Nx9GTe^=QG7`wmYG!`fr(^Y^Sf
z?wYCQ`DY(){fEb`|Dkz#YljyN!%Xx1eZ%5mIBC!Fp*x0?n{WNw@}aMXUpMcaogAi{
z|J*z`J2CvY`5(>mKdb)hF`Vr9e-;?`A2L3*&aQ2>t8TAH>e+g$KCNY=Vf@oNw=S-0
z>&|+tp0Bs-^IADEj8Cic>XN#??ye{5#d^2CtTmIv_?NZ0E~^{s-r8F)*L(GKO)VJ4
zzp4vrXYH>0YhS%uAJk~!F#bWESr^uowWl7er|Lj`R0|gk<5TLanyIU6wjQo$>dpG3
zmM$K~8|s|eUf0we^=Lg;2kWz1v1AzktTxq-x~}f3$Loc9r@pAwONa3<>ioL2Zm4_e
z$$F^{)mOFlJHz<&+ESO-&2?YR)hqRWeN*d~4dXLvYh6*d)C0A@Uat>pa``a+QEjY?
z>Z-b}9;&D7jrzD2uW0}4?Alhl>h^l1o~^g)(^_^?`(NkQ#dU4nS&!B8^>%$;D_6Gv
zbzWUk*Vo<kM7>z=)|a(rRr_C?>$1AB?ybG`a=lky*VO9vzb>eqwY%=Gef4U6P^0g*
z|8-_vSXb7bda$0V1NBiYT+{y7Sv6Bv*K9pp&(xdsNiF?e`(NkO_PVC-s7LF$I#{38
zinZ;3ZK@r0UENiW*9-MdeNn5|wf}W~U0OHPJ@sV0REO%TT07PL*Ot1xZm#=ku3oA4
z>zi8t{r11M))jS2Jy84W_4=?T*SG(*u`a5s>b82Qo~}3Q<Ml^h4=4B>^-4PNarEM!
z{O&)`CwRoMrQiQ^ddGo-Q=9fp-nxJEuRm@2_R9IEA9<l2c}4cyvGc@&x!HAnGg>k?
zyLebPEb28p8vedv{$)5C4((oW<b2wO?VD$&fBT#1)2FxnaqIM7cl~AO^cfpxZaTVp
z)3<-bnE(L-1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0{?S?
Fe*+x4h?)QZ

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1158_spring/s2_1/ROIs1158_spring_s2_1_p2.tif b/tests/data/sen12ms/ROIs1158_spring/s2_1/ROIs1158_spring_s2_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..35d51e381ff378cacc18515ca526d80e45305ab1 100644
GIT binary patch
literal 1705920
zcmeIzf2daV9l-JP-0RP&sdIW~`_T<IMjIox7A_*1M2HKCb|(_jqJ>06lZc2`A?4x{
z(IO%uBBDh^M94)XBBCcEBBDYfLLx#UG9p^Eh=^$Ks|F6-pZjaCdw4(RbHC3y=fdlI
z;cVIR^I^#_46BA=G&zi#=08Tq%@fTlT7Io2kFC#Nx9GTe^=QG7`wmYG!`fr(^Y^Sf
z?wYCQ`DY(){fEb`|Dkz#YljyN!%Xx1eZ%5mIBC!Fp*x0?n{WNw@}aMXUpMcaogAi{
z|J*z`J2CvY`5(>mKdb)hF`Vr9e-;?`A2L3*&aQ2>t8TAH>e+g$KCNY=Vf@oNw=S-0
z>&|+tp0Bs-^IADEj8Cic>XN#??ye{5#d^2CtTmIv_?NZ0E~^{s-r8F)*L(GKO)VJ4
zzp4vrXYH>0YhS%uAJk~!F#bWESr^uowWl7er|Lj`R0|gk<5TLanyIU6wjQo$>dpG3
zmM$K~8|s|eUf0we^=Lg;2kWz1v1AzktTxq-x~}f3$Loc9r@pAwONa3<>ioL2Zm4_e
z$$F^{)mOFlJHz<&+ESO-&2?YR)hqRWeN*d~4dXLvYh6*d)C0A@Uat>pa``a+QEjY?
z>Z-b}9;&D7jrzD2uW0}4?Alhl>h^l1o~^g)(^_^?`(NkQ#dU4nS&!B8^>%$;D_6Gv
zbzWUk*Vo<kM7>z=)|a(rRr_C?>$1AB?ybG`a=lky*VO9vzb>eqwY%=Gef4U6P^0g*
z|8-_vSXb7bda$0V1NBiYT+{y7Sv6Bv*K9pp&(xdsNiF?e`(NkO_PVC-s7LF$I#{38
zinZ;3ZK@r0UENiW*9-MdeNn5|wf}W~U0OHPJ@sV0REO%TT07PL*Ot1xZm#=ku3oA4
z>zi8t{r11M))jS2Jy84W_4=?T*SG(*u`a5s>b82Qo~}3Q<Ml^h4=4B>^-4PNarEM!
z{O&)`CwRoMrQiQ^ddGo-Q=9fp-nxJEuRm@2_R9IEA9<l2c}4cyvGc@&x!HAnGg>k?
zyLebPEb28p8vedv{$)5C4((oW<b2wO?VD$&fBT#1)2FxnaqIM7cl~AO^cfpxZaTVp
z)3<-bnE(L-1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0{?S?
Fe*+x4h?)QZ

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1158_spring_lc.tar.gz b/tests/data/sen12ms/ROIs1158_spring_lc.tar.gz
index b7d8c4a69dc741a2c2b94b2c9c6b16f67b850595..67771a4f7c5895e710552fb2e9f9a7538b28af33 100644
GIT binary patch
literal 2007
zcmeIx>rYw-7zS`Nvvt|pZe}W-UG&SkxL8Xgr`|7dms+(-nhq^$V6$q)4zH~aJ0Y3L
zOr@4=&RVqxQmxVo)>(!q>_8e*b#zCjMDYSrryLxJ2n^+Tz_aYj#{ba1-=2@}ljj$~
zeKX+WWY3oYfi^Aq>Sf9YQ)@l?#XI+>$9|T)zwwD7vb;|F05lz@o_js006!U=eY5ZI
zbo?(t>2C$TcR$Ja+30t{j*t@KSWr>c=&2&lYu;5LtD`kCus2m>(z>h(ahada`SSO2
zEsfRIosFjs2(wo;olX?XTBk(E70s2B1x0h?_$~p<{@h^S-o7R~WB|8x%{CD14NFE;
z>sb-tE#7U>;4xM8wHPJln00t8*uj>UUV#s4@P?ii7+Gsx<*whb`#@cJ>I?8-Uce#N
zskVLls19y|Xa-vdWv@oHB=Ty~a0oJUrD7eoml8Tu7L``eiPR&xlfxIs^;HGqK-#<|
zSSC^aK<Cr8<9JJBfN@%{cQNIxzecdG=g5eyH~x}xVWmrOPfXl3!ro1-yZD5Qfe>fZ
zy=pHDaY^bO=aGnIf*sj+s*m8C*P}TeDGZ$N12VNhw(E=0TK@NppFU!AmofP2`Wfx%
zwz&^;v?t+<R3!O`HZo@pfaj7sz<a{4!um722dLdb=S{y*d&11PdzSIz0OJnws0e0-
z4P5Ac!07HrEl$OJ0gb?id@F7q<h|@(h%*|-T&3uyXn}0kqow$t<9P(S@EM7yt2cYU
z?n|I2r4>fUwsuI%a0y%tQB|Bps#wERqI2ojMRX=*Shbtw{;g%tp0}bnBqS(=oHfoH
z0k7_5ZQuo7g3m+k@^F1(GOPMq`vF!MaqFmc$jA(j?P+<(LYUfH#gc|++d#IAYBi)o
zMHtsdL)eBW3%j8~s7QHuBf;*rRLUO8c^FJH^|d=@YbYV>gxk534QZ)~;q)e>0K~Ix
zwiLR!6ru$WJt;p^h|bCZ8L1(L4XRCSt-2q5lqVbm-ECgy-?b{%@00!LSp?x%Y2j?1
zK~ogVV-lV{bxK!fyc;D=BX}i}A$UxP>LQakHF=>FL_-n?q}(ep_#et|;&h$)m7a{@
ztLVfqbKpO2PdZ$FTI>9@#`w|O+VIm#_771B<Ov|F9mtUYWK+fe!1FteLkmv%&X&#i
zn6qVy5XqG2_9RGro<Wzg8_hFBjG&RqJ&DnL*7#_W`O0w^T}GEGMlOiOXD|UX)C%wW
zCT5D8DqV2r(ZNDrg{aXd%^xJE{>qUpucpL9iz&Xhanj4W&R2i`+rSRpO(K%dnFEf!
G8}JWR?>_VZ

literal 367
zcmV-#0g(P5iwFQK`p{qi1MSl>OT$1E2k>`EsVx?)gSsdL+yrf|O&YgWw@yNJa0^9L
ziW*Cj(#5GDadL2QaTQnFui&Tf6FB!Hcz1R<K{Qq=6#hTBzJK2xBo}ziy+*{jyX{Av
zupOM1&X0UvYJP6|vgvpDR@^?J3D`o_v1R3+%g5DGeYIC{h&$p4_bRUAkzFox?vZ6r
z^043PMsX{&EQ&W<QGDEMh4I(te%hZ=jm8G$L|q_aCNYuJ(y}qm@|3Cdvszwc8C4&|
z&yv<(*7C~uj9jZ)e_zY5*99ty`XbhIVv;55uGknP1u{hLi#$vW%8Pu*^m~kI>F%5M
zTw0?VQ*S;;l#zEZh^fld2V?YBWVvA?zg<@Szg^Gg28rCCSC#1IBEDaH4C^A+pAHUp
zy1`j+*$b|Sef!{l(o8@9<!Q`+)pkGTzk>On2F(B8%=-KT000000000000000006-3
Ndj}~2Sycci0016kv<LtI

diff --git a/tests/data/sen12ms/ROIs1158_spring_s1.tar.gz b/tests/data/sen12ms/ROIs1158_spring_s1.tar.gz
index 92fac27e1ea457bebf16c041e16f923e1a73413c..a383bf129504c65d19dda7a0baba4aedbb4d435d 100644
GIT binary patch
literal 1992
zcmeH`|5K6&9LL#pm;24_ZfM&~y6UoI$zle%A<VmxvohzVY<`2ahDukEX`rG!nY(!>
zBhHa+Lde}Bohd%vAQ=L()w!m8n>xQF4A@GYB0MT0Dm)Lne%R^%Q14&g@B7?+-uHfC
zgfFAsA#Hq)+T|O!UpPODd9)&tOmlNTi02aa$2<~UCnRM{3v6E=K<AaC<FDUsc)iVf
zBK6gb-Cy1LLw*{!kGPL&XehqsIeD4Y`wJE438fu>2%e(ee5s|z_~1Re)-C~N4>m!G
zmc`mCZ}s}}8qz4{l?5w|MWh0Fk9f;hD9#Ml?xp)dbg+-&f*{due&Y`e@%o}5SJb{d
z|MO(0dUKeSj}A=blm_$)`E45rI2rP2=3Y7vj`r0!*@=_{!!Z*8DGZtXhEUTKBbqU1
zg#V6$(aXhaF~Mrm;d_V#DFXvH8PUeZsb*D=9Zl^ls+v(bul8D)bNKVEMLeUszk(?k
z9LKWD>XQINpNpeVtK0btC+F6WQIzo@DYU%89~#{<4(QUuvs`~b`nY^>CWU}^n<Ksg
zqC$CiaJWuDi^DOIu42>sLCBS|nwCO8D@o1HE>toL@BSnSq-Kr(siYQm<R_bNcV<aD
z4jmoCt3G~gt&u8O7smD<9ZzmG?l3mb*v1cLe<F!vwb8nqzwb!N(sKU4d#M-q0ILN|
zh)yd|ks~YfZ}JAc1UD~*JP@chRc?x=4UvB|m1V|T#(-MBUgwQmR8Jov^v}Q`C(hy9
zGRGUu!3i10P?Pu98#Mhy7&4aBBg2jQ3D?HIqa3{$vDtT_Ug&vkz|+Os@c-J=o2k7~
z7MlZ6HmZ3v%#<FOCb5ZP%p}JGxx-1&s2DzHD)FxTNCzL9;b-`r%Z&{`fe}~v+X=71
z8R<6K1TYp|x=NN?bIx|(``#qL%iQqN(<%Y{1X+ww7CoN(UtqnJ)X{}FITy>5V=LQq
zmd|D<OCar~;x+}e*6b*74`XmWA;<hu&pdsgMOSZ$T^PdJ)9WJi3XK3{v+V+%JZvZ>
zNWp%g$P&T>{7Gxlk!B8Fp=cdC-3BC2;XZ=(T4CJ{;dk3)Ej=Y=kEI@GwcKL0j^O86
z-*$9m2{mWB^SG7mhgedn=0mgQ6ce|@An!z(cx5{^Te?lG%qv_T@wq|3uVQq^0+G$%
z<j{aMBo~VPBo|aHI6%OePWYS!AQOsQ>`ZsROL4r#Z5FAxQLk)>t4CI;(3Se&Tnr~M
yU;Fh0JBaW(pDKV=5BolmT)XD*-!TOO&+8~({QazfYn>xeRANHYH>f?Yp#B5K5h`5(

literal 366
zcmV-!0g?V6iwFQg`p{qi1MSm4OT$1I2JrXNQd=xo2X#>hxCz=^n?G)?ZkdGY;1)8d
z6fu@0rHhjwadL2QaTQnFui&Tf6FB!Hcz1L-K{Qq=6rLYk->2^#Bo}x)2Y$l2vl}G6
zxEr0-6CUt-=W{cV&7jA3((Wlu!4h2Cl9hW7pHy4*)n3ykZi^$_Yq|}GtOoa7mrQG#
zhy7MRNyFGQDcuf}^kfjm>DT9e+MiRtzeQzHmxx$_m`G}A*_dQ`s-X2tT3%*FRUgIA
ziq>D%^4jE#T<co@P|I&ORjP^lD%ML@AXC(Ru`$f5WQcq%@+dQ?BJw@c?=f!WyKmle
zd5v34z4-!BQQpBIrYch(jM00Il}DNUb|v-yZnIJzW^#W~RifLA^kL&EZj0D{K04m(
zN9WPyAi5&<?SubGC;$96W-|YdtLEQpV*Y0V^Zz&VKK}p!00000000000000005JbP
M0QStHi~uMA01v~k-T(jq

diff --git a/tests/data/sen12ms/ROIs1158_spring_s2.tar.gz b/tests/data/sen12ms/ROIs1158_spring_s2.tar.gz
index 9f989a15d9c69143ced93cd0d51ea30bdf768c8d..b3c0373f1cc5cf732e8825800dc2a2c85fd4d62f 100644
GIT binary patch
literal 5129
zcmeI!>r+#A8V7J@9O`y#m)-4j=|TgFBFZ*^ka7`{Ov^10k|-#V0CBA#J+MI|!HkI{
z<G5~RTjUm?36RWUPO_1SKod|%32WH_<yy}nAYejSB-xV-pgG8LNm$<O3;PH3Ri2l>
z7tb@_&&+S;8~F9Fyy6o6`zNn`4uj8^Q|p1luO?YAP+Y7Sbu-T;CHI!)(vw6<Pk#5?
z{Gdb8+27s~Egyx5@=sEdl9To(IqA-m-&EdNOA0y?dgMq_(vh~HALO40wJq4pg3iz1
zZ42CK8(tbMlljP2F$?jgTe*5Iw=>(;+ap}lSJ_tb<Aql~6S4%G{PL83rKWe<itp~~
z=A$<<ROQ_14#aLntRvUe%J%8}`*@+#5(`ppCGPWYH$-v_|NQAk$@o71uc)p*qHfox
zd*_UEckqJH*}1Ftru(RM+Z_q_;(jXWqv3a3xQ5}$0iBW)_78(?J=3wH8?dW(MlB2T
z{A97HJmq-9bS4n6Oe=h$58ei51$B(!iDt^j4`n%kzww4KbHv`|H1o~h@F}Tp?sYtM
z@31YS8kuC>Rtch2_;zj6Rr9nec=ed&((d!6EOKd+_w4FNrC5V~bxct32+aG|WpjiK
zjDG_&m-A)@Hj7^p<!p8zK~3_9>X9l`u$6$JWrc!lpznlH`VI^uYHbK6od_aWkbS)`
zPEBow%YfXigP1g;GDi)v&oV^sK#9n0?O_M`y!?DtYA!GZ{absKl@<=RB1`Dm`x(co
zoS8I+WExZ>4JdU^rl)*xv~egI>6>a=NgG7EQRc~-yWmp?cp}_bldaf>vygFZJSKxE
z2kO(8zSBmi)0-g;;?Txms3FkUQ;=QQ7rd_A4><w;Rs@DJAfGJ~4ed-ducTMYePPnp
zu?n$(T&5JI&>3~pid1+Mpl{(S>KV$$A#atm5nM+q(PCaqMWdeVfFpM~6^z<wc?j%}
zxX|k-rHU5urqUmF01^0BQ#v2|JDMdS;GMJ>r2#18g|Wzi^23M)SCV3u{T{rDp5h&H
zkhURTWM=9_l#})~EYSw{i>@iEVY=#Swpqr5AZ-|n(jn(UZj>d7_@k3H1L`?6KWYcK
z0o~+$LLtQOEtfYSZuAT<%0b-^`v7zHF(Njj9a5lw=EXZGU%{2QGOAftn&v`oqBrKG
zgp5=;9JrRcw;s+%YSAzJ(gMM7_%g5(Cl<aP+H%SLcIIaO+`_;J&`}@Oi)`2s<5oqv
z!F>yJfZIdpX@9+hIWSDTfbLhb?7+nm^8Ayv7PBku@SvlRDvniMcaME<uD$?%Y=olw
zn1svAZF+0B(XeUw@F7-3c(iEx)bN0}Fc?A$bZdOPy*%R)@CbMWJOUnpUqoO{cySXl
zJ!YsabMD96(GPT7$IfGKSNEnc)_ytQ%>rG=`_gC>F8`sGP2m=msSW(%izOSvNu9N|
z6`VHa3@9}1%J%pT-zn?5H#oP+70zbO;$m@~T?}j@{r&fTt)5NjWdCQXV_UPmd#b;m
zE=tQO5@iC|2J>n6nIT8+cd|xDh^pNF{p`Qk+v0|vXX7(ia4aDHvc72I(F~`6xFxYq
z26FWY+p3%a>ACcU=bCi>@uJdJ#_PLROW#!E3EeNR<<z+DE>35TyC>|af6X1aJv(3$
zyq+J6b)20jcQtpUxD)++l{WZq+CzA;iL|PmgkRynOur_@&svLV?@ieZTeWfcrXJ7-
zszu8r28JIUOa>0(MNCpWq(_stJ}uWaq+qes5~vZ)oD&nM=fRP`K(XQLauCR$lQ7d(
z<t}6%ci{^lPxOFXfk<&JO!6wY4>>1!!Sr)N?*oN>M0|rOLkB-b6D83qTp0NPd|!JU
z-)y4t;YCi+cuSriU6Gq9<Q>GzdXzr!Gn6c;NCC!Z{m289#5++XuZEhChd6FJzyX5+
z77y3oat)-xF{<)nAg{&><S=AXQip;I7a_VS0(P%LDL(`fd6E6KCYnsS1dNEq!k-sb
zIBJ(u#%PUJTA&{Evy*iKs^(IG8#wJp@&SFJyV~%IS^)(U6}794Rj1`bWT0p(wxS`l
zsL-tn!BT9{G@8x}anKeN?`rlsV!oBUAzwrpyl@O@7<#GMTb{@euh3{<47|dLaMdWr
zCwAZ;w4to@NyS6h#EESsMOg~mNaK_&fHbLeAcGv7tL_rFz^#fgHUy-FD{9fxTam6t
zv$TFw`F7}1v+V86y-Js>z2(hGq^?;oAT_BM=yV71dDoR9+eKX{(bRQi=YtgCk8?xP
z=$;;J)q9hGNrsDj!8D61>m`=Su@d)3*(1-etb4X)XLgviojIT1dOn{$UuV7LzmlKj
sxW9qF@fuwuZlC%^eyQh(N5CWC5%36j1pY6uMtl_*2&dlmiokjO571Bl;{X5v

literal 364
zcmV-y0h9h8iwFQl`p{qi1MSl>OT$1E2k>`ksVx?)gSsdL+yrf}iH%#UTPLA9xP=ZX
zMT{j$>Ea|voE#inT*cM)EBGn=1kU{kzB@adAR4O_3jZHm-pjiOmkYeselwDCd&iHu
zVJA2(M^#^zTc3-*D*9cy6?aZ(0u@$sD=JEFTaKfv>w3>|NxIx3J;#&WSCwAPA-gik
zVZYUj;&y1;6mPbp__*H=<FEUE+MiL)<_6_CE)a<f3C{E~a%-Hcu8dL78Tq2f>iEEq
zC8NG<<SXMIwN{P#fswyn7pcVYh1YYEA)DhKZw!(mS)5;SK1?hsaDFGudyMMo?whtR
ztx;X*FP|gIsykRDbQJoB33@Au{4i1fE~npb*9-YUqW0%?B)U0|@7Er~2B(du!=v3^
za28zjgG&<M9{f*Q>F2*XmHBt%$NYPk|7pPd|IMt=KL7v#000000000000000%)WP}
KB~DrZC;$M5N3Kx-

diff --git a/tests/data/sen12ms/ROIs1868_summer/lc_1/ROIs1868_summer_lc_1_p1.tif b/tests/data/sen12ms/ROIs1868_summer/lc_1/ROIs1868_summer_lc_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..ae30f9baac7cc151bcba8e3f3c9c7e90a9219f27 100644
GIT binary patch
literal 525066
zcmeIwv1$}i7>409JL@KdAh9rML>6MBjfH}iku4;GjnP;rHmj}n5)d-NcHYFaf&}pj
zrWb4kOPSWf!VB=*>;_iQ+UCjd=KMKlW<s9q{{FSHUP{?2rK(GnY5uKRnFpDN+5VjB
z<^KG>(aL<G8kW869p>QTa)18J_R74Id4A8=bZO<;2bt^a9S%x4$UJ}UY3B3I=IQ?P
z%*Ssx%P9LtnLo_xGS2)y^T}*bE@%FcdH%JvymG^Ty*Ba(ZS1B=nx-bTsY`vTtDL7v
znx-bTsY`vT2RToZG)+xvQ<wTw*Evs<G)+xvQ<wTw4|AR-X_}hUrY`lVK9}<}Nz>G%
zHg%~_^(g0QlBTIiZR%2=>b0DwNt&i6wW&+}+Tx#)57OdV{CH*W&vkjzUzU46$4|a|
z+qv_xKK@kwdUogRmigOC$=mZ0IeqhT9Sl!q+c~M$PiAXnyNvRIuFAXJvN>PBzZssc
zS9c%ZJs97<IlexA^zi=p^{baJ#y4&q94&T_&VGrN009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
jAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly@K1r?6nRP|

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1868_summer/lc_1/ROIs1868_summer_lc_1_p2.tif b/tests/data/sen12ms/ROIs1868_summer/lc_1/ROIs1868_summer_lc_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..ae30f9baac7cc151bcba8e3f3c9c7e90a9219f27 100644
GIT binary patch
literal 525066
zcmeIwv1$}i7>409JL@KdAh9rML>6MBjfH}iku4;GjnP;rHmj}n5)d-NcHYFaf&}pj
zrWb4kOPSWf!VB=*>;_iQ+UCjd=KMKlW<s9q{{FSHUP{?2rK(GnY5uKRnFpDN+5VjB
z<^KG>(aL<G8kW869p>QTa)18J_R74Id4A8=bZO<;2bt^a9S%x4$UJ}UY3B3I=IQ?P
z%*Ssx%P9LtnLo_xGS2)y^T}*bE@%FcdH%JvymG^Ty*Ba(ZS1B=nx-bTsY`vTtDL7v
znx-bTsY`vT2RToZG)+xvQ<wTw*Evs<G)+xvQ<wTw4|AR-X_}hUrY`lVK9}<}Nz>G%
zHg%~_^(g0QlBTIiZR%2=>b0DwNt&i6wW&+}+Tx#)57OdV{CH*W&vkjzUzU46$4|a|
z+qv_xKK@kwdUogRmigOC$=mZ0IeqhT9Sl!q+c~M$PiAXnyNvRIuFAXJvN>PBzZssc
zS9c%ZJs97<IlexA^zi=p^{baJ#y4&q94&T_&VGrN009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
jAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly@K1r?6nRP|

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1868_summer/s1_1/ROIs1868_summer_s1_1_p1.tif b/tests/data/sen12ms/ROIs1868_summer/s1_1/ROIs1868_summer_s1_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..df0502117655136f244499d2a84519f67d9cb4a7 100644
GIT binary patch
literal 525044
zcmeIwv1-*|9LC`<ImgouMRc%TL=M(P7Y79$YZj@XgH;>^hk%Z{OF@W2H%BiZHy}m4
zfn0##A~>2WaOeg2ragrYI=eg#zmq@Tmz)!xW_R~SSudqrD5aW}D%12)otf**b(WVo
zW~=q-y2Y9KVl^*2S$mX?ORM$ip3T)f&%Bj+y5?KDeCFQAt2xVMFY|QYEXVox8~Mz4
zW}*AAQ5KnBW&V6H%afGyDf8h$U9M#QG2Jx%O%M4WkE1-t(bd$XHg%~_LmE?EWj{5k
zO<n5Kkj7Nk*-uSsQ<wTQq%qaA?58HRsY`tt(wORb_EVGE)TKTRX-xIG?58HRsY`tt
z(wOQ+_EVGE)TKTRX-xH6_EVGE)TKTRX<R$`ACzl5C&TG^wfvXUgWt>N-+yl1`!egk
zR!1-HonBIvDr3GcFU~aQ^*TP+^TUJ9>{RQA2Ww@sEb{7B<>PkQn9jf6&5zI5x1ZhL
zTi(6Byt#b(<l*w|o7XRwx9;ripRDem{)jUH0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
f1PBlyK!5-N0t5&UAV7cs0RjXF5FkL{p8|gX(6EAY

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1868_summer/s1_1/ROIs1868_summer_s1_1_p2.tif b/tests/data/sen12ms/ROIs1868_summer/s1_1/ROIs1868_summer_s1_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..df0502117655136f244499d2a84519f67d9cb4a7 100644
GIT binary patch
literal 525044
zcmeIwv1-*|9LC`<ImgouMRc%TL=M(P7Y79$YZj@XgH;>^hk%Z{OF@W2H%BiZHy}m4
zfn0##A~>2WaOeg2ragrYI=eg#zmq@Tmz)!xW_R~SSudqrD5aW}D%12)otf**b(WVo
zW~=q-y2Y9KVl^*2S$mX?ORM$ip3T)f&%Bj+y5?KDeCFQAt2xVMFY|QYEXVox8~Mz4
zW}*AAQ5KnBW&V6H%afGyDf8h$U9M#QG2Jx%O%M4WkE1-t(bd$XHg%~_LmE?EWj{5k
zO<n5Kkj7Nk*-uSsQ<wTQq%qaA?58HRsY`tt(wORb_EVGE)TKTRX-xIG?58HRsY`tt
z(wOQ+_EVGE)TKTRX-xH6_EVGE)TKTRX<R$`ACzl5C&TG^wfvXUgWt>N-+yl1`!egk
zR!1-HonBIvDr3GcFU~aQ^*TP+^TUJ9>{RQA2Ww@sEb{7B<>PkQn9jf6&5zI5x1ZhL
zTi(6Byt#b(<l*w|o7XRwx9;ripRDem{)jUH0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
f1PBlyK!5-N0t5&UAV7cs0RjXF5FkL{p8|gX(6EAY

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1868_summer/s2_1/ROIs1868_summer_s2_1_p1.tif b/tests/data/sen12ms/ROIs1868_summer/s2_1/ROIs1868_summer_s2_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..35d51e381ff378cacc18515ca526d80e45305ab1 100644
GIT binary patch
literal 1705920
zcmeIzf2daV9l-JP-0RP&sdIW~`_T<IMjIox7A_*1M2HKCb|(_jqJ>06lZc2`A?4x{
z(IO%uBBDh^M94)XBBCcEBBDYfLLx#UG9p^Eh=^$Ks|F6-pZjaCdw4(RbHC3y=fdlI
z;cVIR^I^#_46BA=G&zi#=08Tq%@fTlT7Io2kFC#Nx9GTe^=QG7`wmYG!`fr(^Y^Sf
z?wYCQ`DY(){fEb`|Dkz#YljyN!%Xx1eZ%5mIBC!Fp*x0?n{WNw@}aMXUpMcaogAi{
z|J*z`J2CvY`5(>mKdb)hF`Vr9e-;?`A2L3*&aQ2>t8TAH>e+g$KCNY=Vf@oNw=S-0
z>&|+tp0Bs-^IADEj8Cic>XN#??ye{5#d^2CtTmIv_?NZ0E~^{s-r8F)*L(GKO)VJ4
zzp4vrXYH>0YhS%uAJk~!F#bWESr^uowWl7er|Lj`R0|gk<5TLanyIU6wjQo$>dpG3
zmM$K~8|s|eUf0we^=Lg;2kWz1v1AzktTxq-x~}f3$Loc9r@pAwONa3<>ioL2Zm4_e
z$$F^{)mOFlJHz<&+ESO-&2?YR)hqRWeN*d~4dXLvYh6*d)C0A@Uat>pa``a+QEjY?
z>Z-b}9;&D7jrzD2uW0}4?Alhl>h^l1o~^g)(^_^?`(NkQ#dU4nS&!B8^>%$;D_6Gv
zbzWUk*Vo<kM7>z=)|a(rRr_C?>$1AB?ybG`a=lky*VO9vzb>eqwY%=Gef4U6P^0g*
z|8-_vSXb7bda$0V1NBiYT+{y7Sv6Bv*K9pp&(xdsNiF?e`(NkO_PVC-s7LF$I#{38
zinZ;3ZK@r0UENiW*9-MdeNn5|wf}W~U0OHPJ@sV0REO%TT07PL*Ot1xZm#=ku3oA4
z>zi8t{r11M))jS2Jy84W_4=?T*SG(*u`a5s>b82Qo~}3Q<Ml^h4=4B>^-4PNarEM!
z{O&)`CwRoMrQiQ^ddGo-Q=9fp-nxJEuRm@2_R9IEA9<l2c}4cyvGc@&x!HAnGg>k?
zyLebPEb28p8vedv{$)5C4((oW<b2wO?VD$&fBT#1)2FxnaqIM7cl~AO^cfpxZaTVp
z)3<-bnE(L-1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0{?S?
Fe*+x4h?)QZ

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1868_summer/s2_1/ROIs1868_summer_s2_1_p2.tif b/tests/data/sen12ms/ROIs1868_summer/s2_1/ROIs1868_summer_s2_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..35d51e381ff378cacc18515ca526d80e45305ab1 100644
GIT binary patch
literal 1705920
zcmeIzf2daV9l-JP-0RP&sdIW~`_T<IMjIox7A_*1M2HKCb|(_jqJ>06lZc2`A?4x{
z(IO%uBBDh^M94)XBBCcEBBDYfLLx#UG9p^Eh=^$Ks|F6-pZjaCdw4(RbHC3y=fdlI
z;cVIR^I^#_46BA=G&zi#=08Tq%@fTlT7Io2kFC#Nx9GTe^=QG7`wmYG!`fr(^Y^Sf
z?wYCQ`DY(){fEb`|Dkz#YljyN!%Xx1eZ%5mIBC!Fp*x0?n{WNw@}aMXUpMcaogAi{
z|J*z`J2CvY`5(>mKdb)hF`Vr9e-;?`A2L3*&aQ2>t8TAH>e+g$KCNY=Vf@oNw=S-0
z>&|+tp0Bs-^IADEj8Cic>XN#??ye{5#d^2CtTmIv_?NZ0E~^{s-r8F)*L(GKO)VJ4
zzp4vrXYH>0YhS%uAJk~!F#bWESr^uowWl7er|Lj`R0|gk<5TLanyIU6wjQo$>dpG3
zmM$K~8|s|eUf0we^=Lg;2kWz1v1AzktTxq-x~}f3$Loc9r@pAwONa3<>ioL2Zm4_e
z$$F^{)mOFlJHz<&+ESO-&2?YR)hqRWeN*d~4dXLvYh6*d)C0A@Uat>pa``a+QEjY?
z>Z-b}9;&D7jrzD2uW0}4?Alhl>h^l1o~^g)(^_^?`(NkQ#dU4nS&!B8^>%$;D_6Gv
zbzWUk*Vo<kM7>z=)|a(rRr_C?>$1AB?ybG`a=lky*VO9vzb>eqwY%=Gef4U6P^0g*
z|8-_vSXb7bda$0V1NBiYT+{y7Sv6Bv*K9pp&(xdsNiF?e`(NkO_PVC-s7LF$I#{38
zinZ;3ZK@r0UENiW*9-MdeNn5|wf}W~U0OHPJ@sV0REO%TT07PL*Ot1xZm#=ku3oA4
z>zi8t{r11M))jS2Jy84W_4=?T*SG(*u`a5s>b82Qo~}3Q<Ml^h4=4B>^-4PNarEM!
z{O&)`CwRoMrQiQ^ddGo-Q=9fp-nxJEuRm@2_R9IEA9<l2c}4cyvGc@&x!HAnGg>k?
zyLebPEb28p8vedv{$)5C4((oW<b2wO?VD$&fBT#1)2FxnaqIM7cl~AO^cfpxZaTVp
z)3<-bnE(L-1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0{?S?
Fe*+x4h?)QZ

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1868_summer_lc.tar.gz b/tests/data/sen12ms/ROIs1868_summer_lc.tar.gz
index 7add773ab18f939eb66db59a5a7363d7e494214b..c7d9c48f9c4271f1e1ab523f58a913a8dd2ae34c 100644
GIT binary patch
literal 2006
zcmeIx|5KU;90zc(u5Q<Dk#)_T?#8;h)?$d49L(vB^R7F$(WC7PQ??;BEqkCrX<>j#
zH*eLQE!GfBHt?F?28EUknIb$nPZuh1O5zmsxoaT_$QK_0kuOjERQ%Fkuzh}e|M+>|
z`-N@Yk#)Lc>z%A8*X;nihPL;9SmJsh`{B2{KWnpx-zGn^)D2)|g|#oe_~r+nSG^{C
z9=GG$6E{k)T`tHTL4aD^v212(^m5)<Pp$9X6~eDD@bVee*Kh3idR{OUp-M>^M-ZAy
z)4ANb;9vf+RN_EiUJxS|<hf_PlL4NdE;Kle6HA>zLR&RtFz9s7X~tS~2&q)*v0=~M
z*%s|=7-Y21BKPaMBw}$z8JQBWS<#+nIU{MvS;8WTk9v&-g5WZQ?6W+zvIaM$$b~WC
z4a5i8m#414`O6lIUpkVw4f%nzXF()FhX=1mcn3A=J93Rn*Kb*$QG5e;vwnf^d~&Jz
z*8IUntw~8yUhtD`bOQ-CyGm9Ko4@Nk`)d2;o*`<{h0%rc9a!vuH3plLA?^HNTf78m
z&!MRbMc>6YZZVYBWKF{BbXB`Hz7TElaM+|nklX!kZr^cvFI|1EsG^1V)<fcPJCRB&
z_JG&E1aH0y%HLP1>y=M~-%o<qdqJ7H+-l#y%YGP`BU(;HsxpGE4Iv&ICzeZyfc6aD
zQ?hHW;Hv!<!2TgW>}26NmCE6SGa@!_o=&amVR$%3i-dd*8y8M|ih6Z252Y`TBRF`T
zjf<Kh=J04$KKnheXAx~O{zUR&I(e%;t&cnUSyeFNySlBbWcE|yp%#gN9SbE{u_PgB
z%X)l|Yy-*8y`zI7hts)Od_?#Wnl`UZCdRu~CW9og+|nf`G4~i_0hll5_%{ufCFgPg
z??^X^3L79jU62X{${X3m)HMz#x}7@Jh>f%x&Ho2G8tcU2=-l=>^@$%Brx?B^m(^w7
z0@S+`0Ci#Yz&S-d+2@NtG*2`mH+5`8F=MGQQ7ah2K<TQQ&oQ)(PY8|DcsT5BLKQO@
z%6UAs!&WHbpOhX!aykfvCHLA4WoW=;S)agTw#vBrjWMpKuQa#!V|h0y?@>!Lgy|YG
zP`;j_)%)ka^bXO)?u<aq06t&;A6;1vq;dSgb9WdZ2Ks<XnddeqQVJoHhJiS#WYoxv
z4OFxF=>|Epaq&`PKEWYJq|>eL!Lzcn@|101nx##Lz&g`WLwd6Ht4KApa+@iPxVI%3
m%3+nBhp`RtZ0J37=Oa7M$B+NhK(aFRMDN_zp{za6W&I5e!a>FW

literal 368
zcmV-$0gwJ4iwFQ``p{qi1MSl>OT$1E2k>`ksVx?)gSsdL+yredy(ZmS-8u=?!7UW2
zAlfQPN*5<V;^g4q;wrATU%^k|CvfgZ@b2hvf@rK#DExnLegD2YNG|YN`^|{gyjl?T
zyWLJ$K0gk4x%IgjsAh1<cjD6%nt~&F!cmp`RX(Xg_w`;y5Et?Y_bYzYC&zVp)g#-P
z=3&3pkK%S{+Z1oNqqs9@hw<0ve%hZ?&E^*6WnCg-8DcW&Wn^oT)v1ip&l!1{Wp#a&
zKPyIm)yQj;Git3H{R1Pv-4v-L>#JNZNrr4$_vFSfDUv1gwalZ$qJqr#%)H0Ap6<SB
z&!si4GyUcZL|JtQi<quVe=tVxC6*s0>f7b?|GUjXewe8JMO}$*yYa)uQ`nHP@qBo+
z+wYzAE(X0TV&6XapS04?zdM8Z7Y-MC{)LPAp9ReS-^}~`0{{R300000000000002M
O{QCeYwn32qC;$MjGP~LU

diff --git a/tests/data/sen12ms/ROIs1868_summer_s1.tar.gz b/tests/data/sen12ms/ROIs1868_summer_s1.tar.gz
index 9c1ff0bcdddaba930638c78e988320307586fdb5..b9758c2e409eda5e23234368655191a28fdbf33c 100644
GIT binary patch
literal 1993
zcmeH`|5MTj9L8Pli(5B!cWuoiz1vTlU$B{%C@fc3HfKpX#Z=195)Zr}VS--}esI_B
zV%9ZgiiqsOj^ayPA_@|aYidd0j1eLN6DR06!~{gZ51-v`*X93E?_Zzip1bF{_bZhV
z7gLScIv*43G0fmD)I+8gnanwI>9M`!L)j2W?g#UOMQmup(2e*zf22X*E{@%Q`OCCZ
zSKdlWympiVb?qX?mi?am_?<ZX4^@5XmuGjcx7WQZC_k2z$a1~UeV|bjqTNi0ntou_
z<MpH>Qx-Jzwvn$^_XkH94Z`F{R=jlcic)3FKeHy;qdG#F^Cq+_(#KR*8vS&+a%PK!
zc8_0dBcduM{9@)4zkl(G*&m()tRe8v#by(TWKZdwFZRL-$O2W6VB;wsws*QEV2Lwo
zJKqWf#{ld2fe0LKrH$Shn+bDOdJ+vth__`N8d8_<5tC<eBSh0!b`MMYQw82*q#5SB
zL(3?>oD)!OznI2pTJ_IyYlF!w_SAOoIn~C(Bfj_J6T%?QwdpXi6*G+(UKAreqoro~
zC@v56=UXlPA;*IZJSM6@tG*7{ZBSnxw6>U+Q_|dbyR~|7sN0wG?NT|vs*is>P20~e
z-N(<@Jws%cnf0yvZZ`=G89Kvf-JBgl=&0WCdDnLw40hm?yJ+nWmpc#nGFK#l{^lM9
z<x!bZgGvSce@}9}mOz47i(Erk37MLY+}f;?gQKWMvjS$v>2sla6GL2giDw2kQTNRv
z4b@n6kFXG4;qY+u)0Zk!Y3umFvWv?>0gJOdJ0%rha^H)2bFb?H4@us2ptFcTCx9&*
ze?<X<)Klb@j{<z%62`a1uvrX9FTf72Oxk|6h*XPsf-L@K1kQ@IcizffiT|I$>lX9s
znx7$vh(NO&(R&i97YKUQ&DpGh!-zcgIZ&>FgWP;ri*)XBxU6(|{<zRQebzmV#y}6E
z6tc?5sm4lYPYuUGejePIN*4moyc(f`iNA<X@m**OOp_A0>Pm>%CgfNcwFKv339Bp2
z*41VDR8Q@kQD4zjN0XD`8<Mj^E@EJpk>0L+>XK74yPm;}*qcu5jcL>l%rZy=h1mXo
za*BP!-_*lh*k2~^mPm7ujB+yZm9V_~6@P=o%pI<KF2u{+`|7bci9Na$HmyagJGKqX
zWQv+#Dj0?qD16^*WZQ+JEDcPzP%W-^IjF)syBt=VHF8zfg#j%!6Buc9qoP5fZgTS|
z*95>3+1ZY*aiy_`OD9(cemrrVX7BJLX(_MkSH9`}-vaCC(1%GAUlhiCni%sh-gh)v

literal 365
zcmV-z0h0b7iwFRl`p{qi1MSl>OT$1E2k>`ksVx?)gSsdL+yredjcK=5w@yNJa0?wO
zh_p(Q(#1)TbaHTTaTQnFui&Tf6FB!H`0nU%f@rK#DExnLegD2YNG|YNN6kpq{8|w8
zyWLJ$j$|Oqt<TLsHG?a;7oVTe3>@Zrj;gY{FQ?VheZ5!lNP2ukRz1h{$#Gpr`eZw^
zJnXmnQQQt~o8sMe6n6&gF#h`7Px}k1+1#N#*A*g>A;C#6BU{s~PGyXK&d94GtLr2G
ztQq}vBX3O4sI_VIkB$6xTci@#S6(kkhHS2fyfI3OWO2UXJWebsaK0DjJtp;Z_f2~)
ztw~+zH(w&ksykRDbQSu833@My{5VnHE~o$BZ5Q&RMC~u@N;K@o4_i-RgJa|Q<n*B5
zyXajGde<breegeNrJsLyF7sch>iKsi=6@bA|9`XS^A7+30000000000000000E_Pf
LqLg;t04M+e#2c}}

diff --git a/tests/data/sen12ms/ROIs1868_summer_s2.tar.gz b/tests/data/sen12ms/ROIs1868_summer_s2.tar.gz
index dc60518f3798ec5a7fb4a95fb478e98362d5b49a..5454b379189275eced7bc85fd3056565fbdf3c9e 100644
GIT binary patch
literal 5134
zcmeI!>r-0!8NhL8Y}0E(-JQu+Q?(^VqN#B=L|r66v$==@(xB0-*X$<706~(7$qE4`
z?QCqvOQQx1ppcCmPQC9&j79>Cn~ruh>T-@?)I}$?Avs=aIcNZdI-S09`g&jS`v;!q
z`ON%gzLAwb4myAA?fIbKWh>_Lge!7rZJY<QIUL=Hui)ItQ{^*_8CW{@;^)-EwZGVR
zD2sakRWvJ%wRgW3`w<rV5Q~kv_@|R61tB5W=y%@1hG1F0Iddi?#IjmeN;&t%4=fmo
zWq$2dxdx;0M$Cn;4s_&M@Gnf4Up_PqFcv2<R~jiVER$sOrjcW@pXIhM+w+$%EdIgb
z`~VOi?=W<C8%XhhZPq$9b+$EM>YTflquN#BNy=&~dZY9Wd~thpYhOjWbWUURV|xBA
zaQdHpQaJzRs;`DyVY6>#t1Z9$*VjJ;HPSJnVaQ?r(l%waTF-F8!+SROWpbq(4WuTi
zds8IrjIDn(b`XH_Vyl~<W)3c^9%<yuLoMY?Pc47D=2gh#meB?V@H~RZzjbM>Pc;1~
z(uni^Y^bU0xrAej$H^h$dOMUeJT(K#Z#`_(Y&HLd5m#;yTr`XNo@92L@!r~(y6e~0
zyYy;LB7W>MnKR$-XjA*|dH|$fAIqaMwb`%%fzf;=E5<bf*9k;nbf#_+_9B-(A29f_
zu0wD&n>XF4PBlOkh!ZVUTJshrwM8uyUMdk@(Z`1~&AP{O7N6Oxy{(TUY1XyDNM)wt
z_Y3c7JN4KO+6-KYbO;VM(cg`hdk(O#Eie}0t3raYeh<ip{%K=r8akP6a4<VX7-wv#
z(XPV!R6uenM`_bC5ClE#`L$RsNyFnBJXS<E(GWo&*CoLz$T`n}QF7bFYfvr77Jf)-
zI1Tv(*e$suJ;pVrKW49wNR8JTk@KF|1ZJG8l6A8`!LEv6#sj@D4q2Q?j&m|6fwSxr
zLab3a%h2dnp?lqUzdp*Y-UZhqE>x1Nl+a<Y*oO@26M5<5+I-|0TJ9l?Dr?=~j@uOq
zY5#%US{~xo<HD(h+F^o1x{!7V>erKu_h-{8pl^<TlI76s1!wi--CzSuM6P<G8RVqx
z6+kO;Tfg5ZpQWWh8|>+&=ae`G7t)~u;ePR5GK~T#N{{#j84EOwt{7G!&4S-<)m`c>
z^0naXvWWC?pjJ<5qMCsxuZw)_@_rntu7E0n2hg(|waN{y2)O-8By~X=A7nz4rQ>hC
z*@XGB;i9BX38`CU?&u^4wwG2rQZ}+AeHW0oxGLX+o+=XW3Xc;Ss)j$4LVv%?Rb)h`
za~dfLU27N4#SA^}sp`xg%Qd$5_Fq0;CMmP>M%pmEKK_I0DZ9Znf!HYC=Agg}2m}NI
z0s(=5!1p8I<G26cwDV&s#MRGC-kGlOoSPek<)`EJ9{y{BZGEM4{j0J8={V8A?SV`W
zY{viAnarD<%xUUjb!^!S*9D2Y_qh1&StH*jZ2j>>u*#dXr^#oci2RYQ;Oo{SF^g5K
z*iiubaF|x~ohio4o{}^whsO3Xe$}h_m>p`rHI+HM^p$h4*imHw<GdEpBlFeo+`~)Y
zrLF6q#uzV*$94dXMlt6b+^~C!;(0Mq*Go%TH&m!-30`7%WN1n3d&T~=#TGt(zABqA
z=i-|d+?bX^Whbo-x`Un+CKy#@#vBkMW0{Y|rS^gY=tUvPsHxFK!l;gAK4QOb(~Tku
z{UPyvGLr&+JPJq{IdTsy*W;Jdz0exU<#1zM>jGLBbp~>>naOueRM}4e$?=`x@@Y$9
z-Hvi8iF1`B9(^+D?hWlEBtobjGDDTQkgWySjOlyobiNh?6(iu$((5gSO(kh!WB|P)
z#Eb9M0EN&}cbZtTka`oSfJ@m?%S;@^XRq92t<pze5>ktPG_BgB>tZ=4SmuLeU@mM#
z)=-v^D6TW5cfi{vl%FF@)Z(Bv#E!B(hZzK-lSzY?+3%AS1<X~j85ue%7CJN~bS~^b
z>C-YYT?1<1_E3d%$L%VG8_b1%H!W8)MbK^ZRBL0s8{AQ=m$sW~N353O{Q_}LQv{U=
zaS@{+O03b1j%~t_KAM-t1e2g2A>C+(l7MqElK>NXUYKZ9kkf{sc=nB4heinHBQMds
zuv9PnXEawSDsX7zpa|NJe6CLlrxyZ_C)?SW-m4SA^9X?6@I;A88&zhh3||1|-FUV-
zi8r`s7L+GarsXSaiGcsAf+(+%e*FfMGx7o+wCUuvFA3Efxayzx$_YjP&<?sYoMDtZ
zvg=oJN8SiuJ++Pq+bZ{FzRu3JKYr@@_KtT~Ym?oW%WNvy>Zbhk`}wAUDFK0iKtLcM
W5D@sEfDh*jem8;L7xezop#K01)dM{M

literal 364
zcmV-y0h9h8iwFRq`p{qi1MSl>OT$nQ2k?7osVx?)gSsdL+yrf2jA^%4w@yNJa0?wO
zh_p(Q(#1)TbaHTTaTQnFui&Tf6FB!Hc<<Ta38Jw|q458~>s{{-k{7t<VIz`NzZyin
zPNyA~BR7!c=I3IdiovDaiO)`H3J&u<M@3oLlauJ_y6)|IBt0IH70*$9*L9>%wlmGc
zeybP7t<bh9-fl&4yWa}qujhX1&#6XZi}D<oh(v}2XZjeqHObXf#;E6vd|705eBhrI
zqrPh7Ym*su){Xj+k-y#)sl@Sx&vTL?o8tjDhDnhu&aXKiB^DJpzZ2#?#<g_!O*@y?
zxF+<QFA!zb9V`+$3jM(Zy_H0Ml&Ei))BkTb3;AK9`inXe4Lb4t#$#CLwElE_vft~T
zcQ5+gD-z#6_@6Y>@4q{f{r8=Z{jXsEX94^FH}k&#0000000000000000000m|K0(}
K8XpJ%C;$Mw4YVo%

diff --git a/tests/data/sen12ms/ROIs1970_fall/lc_1/ROIs1970_fall_lc_1_p1.tif b/tests/data/sen12ms/ROIs1970_fall/lc_1/ROIs1970_fall_lc_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..ae30f9baac7cc151bcba8e3f3c9c7e90a9219f27 100644
GIT binary patch
literal 525066
zcmeIwv1$}i7>409JL@KdAh9rML>6MBjfH}iku4;GjnP;rHmj}n5)d-NcHYFaf&}pj
zrWb4kOPSWf!VB=*>;_iQ+UCjd=KMKlW<s9q{{FSHUP{?2rK(GnY5uKRnFpDN+5VjB
z<^KG>(aL<G8kW869p>QTa)18J_R74Id4A8=bZO<;2bt^a9S%x4$UJ}UY3B3I=IQ?P
z%*Ssx%P9LtnLo_xGS2)y^T}*bE@%FcdH%JvymG^Ty*Ba(ZS1B=nx-bTsY`vTtDL7v
znx-bTsY`vT2RToZG)+xvQ<wTw*Evs<G)+xvQ<wTw4|AR-X_}hUrY`lVK9}<}Nz>G%
zHg%~_^(g0QlBTIiZR%2=>b0DwNt&i6wW&+}+Tx#)57OdV{CH*W&vkjzUzU46$4|a|
z+qv_xKK@kwdUogRmigOC$=mZ0IeqhT9Sl!q+c~M$PiAXnyNvRIuFAXJvN>PBzZssc
zS9c%ZJs97<IlexA^zi=p^{baJ#y4&q94&T_&VGrN009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
jAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly@K1r?6nRP|

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1970_fall/lc_1/ROIs1970_fall_lc_1_p2.tif b/tests/data/sen12ms/ROIs1970_fall/lc_1/ROIs1970_fall_lc_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..ae30f9baac7cc151bcba8e3f3c9c7e90a9219f27 100644
GIT binary patch
literal 525066
zcmeIwv1$}i7>409JL@KdAh9rML>6MBjfH}iku4;GjnP;rHmj}n5)d-NcHYFaf&}pj
zrWb4kOPSWf!VB=*>;_iQ+UCjd=KMKlW<s9q{{FSHUP{?2rK(GnY5uKRnFpDN+5VjB
z<^KG>(aL<G8kW869p>QTa)18J_R74Id4A8=bZO<;2bt^a9S%x4$UJ}UY3B3I=IQ?P
z%*Ssx%P9LtnLo_xGS2)y^T}*bE@%FcdH%JvymG^Ty*Ba(ZS1B=nx-bTsY`vTtDL7v
znx-bTsY`vT2RToZG)+xvQ<wTw*Evs<G)+xvQ<wTw4|AR-X_}hUrY`lVK9}<}Nz>G%
zHg%~_^(g0QlBTIiZR%2=>b0DwNt&i6wW&+}+Tx#)57OdV{CH*W&vkjzUzU46$4|a|
z+qv_xKK@kwdUogRmigOC$=mZ0IeqhT9Sl!q+c~M$PiAXnyNvRIuFAXJvN>PBzZssc
zS9c%ZJs97<IlexA^zi=p^{baJ#y4&q94&T_&VGrN009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
jAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly@K1r?6nRP|

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1970_fall/s1_1/ROIs1970_fall_s1_1_p1.tif b/tests/data/sen12ms/ROIs1970_fall/s1_1/ROIs1970_fall_s1_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..df0502117655136f244499d2a84519f67d9cb4a7 100644
GIT binary patch
literal 525044
zcmeIwv1-*|9LC`<ImgouMRc%TL=M(P7Y79$YZj@XgH;>^hk%Z{OF@W2H%BiZHy}m4
zfn0##A~>2WaOeg2ragrYI=eg#zmq@Tmz)!xW_R~SSudqrD5aW}D%12)otf**b(WVo
zW~=q-y2Y9KVl^*2S$mX?ORM$ip3T)f&%Bj+y5?KDeCFQAt2xVMFY|QYEXVox8~Mz4
zW}*AAQ5KnBW&V6H%afGyDf8h$U9M#QG2Jx%O%M4WkE1-t(bd$XHg%~_LmE?EWj{5k
zO<n5Kkj7Nk*-uSsQ<wTQq%qaA?58HRsY`tt(wORb_EVGE)TKTRX-xIG?58HRsY`tt
z(wOQ+_EVGE)TKTRX-xH6_EVGE)TKTRX<R$`ACzl5C&TG^wfvXUgWt>N-+yl1`!egk
zR!1-HonBIvDr3GcFU~aQ^*TP+^TUJ9>{RQA2Ww@sEb{7B<>PkQn9jf6&5zI5x1ZhL
zTi(6Byt#b(<l*w|o7XRwx9;ripRDem{)jUH0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
f1PBlyK!5-N0t5&UAV7cs0RjXF5FkL{p8|gX(6EAY

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1970_fall/s1_1/ROIs1970_fall_s1_1_p2.tif b/tests/data/sen12ms/ROIs1970_fall/s1_1/ROIs1970_fall_s1_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..df0502117655136f244499d2a84519f67d9cb4a7 100644
GIT binary patch
literal 525044
zcmeIwv1-*|9LC`<ImgouMRc%TL=M(P7Y79$YZj@XgH;>^hk%Z{OF@W2H%BiZHy}m4
zfn0##A~>2WaOeg2ragrYI=eg#zmq@Tmz)!xW_R~SSudqrD5aW}D%12)otf**b(WVo
zW~=q-y2Y9KVl^*2S$mX?ORM$ip3T)f&%Bj+y5?KDeCFQAt2xVMFY|QYEXVox8~Mz4
zW}*AAQ5KnBW&V6H%afGyDf8h$U9M#QG2Jx%O%M4WkE1-t(bd$XHg%~_LmE?EWj{5k
zO<n5Kkj7Nk*-uSsQ<wTQq%qaA?58HRsY`tt(wORb_EVGE)TKTRX-xIG?58HRsY`tt
z(wOQ+_EVGE)TKTRX-xH6_EVGE)TKTRX<R$`ACzl5C&TG^wfvXUgWt>N-+yl1`!egk
zR!1-HonBIvDr3GcFU~aQ^*TP+^TUJ9>{RQA2Ww@sEb{7B<>PkQn9jf6&5zI5x1ZhL
zTi(6Byt#b(<l*w|o7XRwx9;ripRDem{)jUH0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
f1PBlyK!5-N0t5&UAV7cs0RjXF5FkL{p8|gX(6EAY

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1970_fall/s2_1/ROIs1970_fall_s2_1_p1.tif b/tests/data/sen12ms/ROIs1970_fall/s2_1/ROIs1970_fall_s2_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..35d51e381ff378cacc18515ca526d80e45305ab1 100644
GIT binary patch
literal 1705920
zcmeIzf2daV9l-JP-0RP&sdIW~`_T<IMjIox7A_*1M2HKCb|(_jqJ>06lZc2`A?4x{
z(IO%uBBDh^M94)XBBCcEBBDYfLLx#UG9p^Eh=^$Ks|F6-pZjaCdw4(RbHC3y=fdlI
z;cVIR^I^#_46BA=G&zi#=08Tq%@fTlT7Io2kFC#Nx9GTe^=QG7`wmYG!`fr(^Y^Sf
z?wYCQ`DY(){fEb`|Dkz#YljyN!%Xx1eZ%5mIBC!Fp*x0?n{WNw@}aMXUpMcaogAi{
z|J*z`J2CvY`5(>mKdb)hF`Vr9e-;?`A2L3*&aQ2>t8TAH>e+g$KCNY=Vf@oNw=S-0
z>&|+tp0Bs-^IADEj8Cic>XN#??ye{5#d^2CtTmIv_?NZ0E~^{s-r8F)*L(GKO)VJ4
zzp4vrXYH>0YhS%uAJk~!F#bWESr^uowWl7er|Lj`R0|gk<5TLanyIU6wjQo$>dpG3
zmM$K~8|s|eUf0we^=Lg;2kWz1v1AzktTxq-x~}f3$Loc9r@pAwONa3<>ioL2Zm4_e
z$$F^{)mOFlJHz<&+ESO-&2?YR)hqRWeN*d~4dXLvYh6*d)C0A@Uat>pa``a+QEjY?
z>Z-b}9;&D7jrzD2uW0}4?Alhl>h^l1o~^g)(^_^?`(NkQ#dU4nS&!B8^>%$;D_6Gv
zbzWUk*Vo<kM7>z=)|a(rRr_C?>$1AB?ybG`a=lky*VO9vzb>eqwY%=Gef4U6P^0g*
z|8-_vSXb7bda$0V1NBiYT+{y7Sv6Bv*K9pp&(xdsNiF?e`(NkO_PVC-s7LF$I#{38
zinZ;3ZK@r0UENiW*9-MdeNn5|wf}W~U0OHPJ@sV0REO%TT07PL*Ot1xZm#=ku3oA4
z>zi8t{r11M))jS2Jy84W_4=?T*SG(*u`a5s>b82Qo~}3Q<Ml^h4=4B>^-4PNarEM!
z{O&)`CwRoMrQiQ^ddGo-Q=9fp-nxJEuRm@2_R9IEA9<l2c}4cyvGc@&x!HAnGg>k?
zyLebPEb28p8vedv{$)5C4((oW<b2wO?VD$&fBT#1)2FxnaqIM7cl~AO^cfpxZaTVp
z)3<-bnE(L-1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0{?S?
Fe*+x4h?)QZ

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1970_fall/s2_1/ROIs1970_fall_s2_1_p2.tif b/tests/data/sen12ms/ROIs1970_fall/s2_1/ROIs1970_fall_s2_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..35d51e381ff378cacc18515ca526d80e45305ab1 100644
GIT binary patch
literal 1705920
zcmeIzf2daV9l-JP-0RP&sdIW~`_T<IMjIox7A_*1M2HKCb|(_jqJ>06lZc2`A?4x{
z(IO%uBBDh^M94)XBBCcEBBDYfLLx#UG9p^Eh=^$Ks|F6-pZjaCdw4(RbHC3y=fdlI
z;cVIR^I^#_46BA=G&zi#=08Tq%@fTlT7Io2kFC#Nx9GTe^=QG7`wmYG!`fr(^Y^Sf
z?wYCQ`DY(){fEb`|Dkz#YljyN!%Xx1eZ%5mIBC!Fp*x0?n{WNw@}aMXUpMcaogAi{
z|J*z`J2CvY`5(>mKdb)hF`Vr9e-;?`A2L3*&aQ2>t8TAH>e+g$KCNY=Vf@oNw=S-0
z>&|+tp0Bs-^IADEj8Cic>XN#??ye{5#d^2CtTmIv_?NZ0E~^{s-r8F)*L(GKO)VJ4
zzp4vrXYH>0YhS%uAJk~!F#bWESr^uowWl7er|Lj`R0|gk<5TLanyIU6wjQo$>dpG3
zmM$K~8|s|eUf0we^=Lg;2kWz1v1AzktTxq-x~}f3$Loc9r@pAwONa3<>ioL2Zm4_e
z$$F^{)mOFlJHz<&+ESO-&2?YR)hqRWeN*d~4dXLvYh6*d)C0A@Uat>pa``a+QEjY?
z>Z-b}9;&D7jrzD2uW0}4?Alhl>h^l1o~^g)(^_^?`(NkQ#dU4nS&!B8^>%$;D_6Gv
zbzWUk*Vo<kM7>z=)|a(rRr_C?>$1AB?ybG`a=lky*VO9vzb>eqwY%=Gef4U6P^0g*
z|8-_vSXb7bda$0V1NBiYT+{y7Sv6Bv*K9pp&(xdsNiF?e`(NkO_PVC-s7LF$I#{38
zinZ;3ZK@r0UENiW*9-MdeNn5|wf}W~U0OHPJ@sV0REO%TT07PL*Ot1xZm#=ku3oA4
z>zi8t{r11M))jS2Jy84W_4=?T*SG(*u`a5s>b82Qo~}3Q<Ml^h4=4B>^-4PNarEM!
z{O&)`CwRoMrQiQ^ddGo-Q=9fp-nxJEuRm@2_R9IEA9<l2c}4cyvGc@&x!HAnGg>k?
zyLebPEb28p8vedv{$)5C4((oW<b2wO?VD$&fBT#1)2FxnaqIM7cl~AO^cfpxZaTVp
z)3<-bnE(L-1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0{?S?
Fe*+x4h?)QZ

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs1970_fall_lc.tar.gz b/tests/data/sen12ms/ROIs1970_fall_lc.tar.gz
index ebeb77620fa925382f4eaa7ab8c4f17cf21a1145..5f0325fa2076815ad6cbcaed7d8dfa946f588ba7 100644
GIT binary patch
literal 2007
zcmeH`>ra{o7{yJD*|MdwC5x_$72}7^Xj@W8#T$FqG|VkVXltF*3C?wBDN$0S;03|e
z85gLvD^XHF&7_uC2RJF-=qp)_RSRO2f(pe~Wq^|jYbkg^c$Xzh@PBBZujiZ(=j8bz
z`EN(ja`(QAirz62s8`6ynGJztrR&$(u_4v_Sr;(xSS09b2IhR+rE@<GaN~IW300q`
zq#A!tim6CuxWuzx-$|al`F9NFX8xSH_1*GjNbtqhKl-Gn&3kpk4MA`@XqZFZUE|o-
zA92XffQd#neYkch!IU#?H+L+Ov_$tJ2`p{Xg*y8Z19=*aG@FIfuIXZM>fIG+?mW98
zJ8QDIX!_4-yK%02;kLIRF+2w3z`}`;7J{R{&D$|Ae&Wv;AiQDQ@>T76Xk$tXpL14V
zzu~~akPX~O3bsrn#_}G*nZTCxa7GKaw8Zn;e_Q7F6~=Wl(^%bUwU}CzeRrU2XH-tS
z*Sr0SCoX{uNP;q8rH&}{nDo(({WI8FhsAnN7qHY^Oi+;Apq_xo2!qHUCSgbA?_K*R
zeHa({A~~Gxo30<N%kZIWIznyJ4PA72(W-v@f@-BmMCbw)n!vxzr1v}-_{xaR_dWWO
zjB!PTt}KH6*?o$rzrOVTu+WFb7l<B|h-A3b-r4$(WFHq8PtF^YJE=!pbZjK<H_--F
z6T}9Ov&Ah11602U0oca;)%CE(K=VQeSKyc9W+5PRe5y3pcsJRDSZFM>95upIw=?0v
zo$pmdZn$r>tQX?AOjFyA3Uwjqce+h3B$pwxoH)@#^z?*U;p0(n?sZ+D8NO?!B}mN5
zTL*cp4g#Ku7fBmjKgy*{_m<#~{|Vfh2@gRE|5YVPKII4}`Gyid@DBkNuh(<ztsstj
zVR;Jd+Xf7XgOuJL{B3Vh(V6-edknfuWp5O;0iFc|+#efDO34@|p?LTbhDHAThC*-C
zgSQ|VT@8&e$()DAw3^DM9BwXXp($4<(xKVspE+k<={u>ks?%1g26ug|LB5*~WZB9*
z+&lYWp?JE~snSCdA+B@Zt&exvHdpmp1`3$>n@%D2@@UI1pD3$k*RL(1=a+I%U0R(x
zLYqwz5lWo7?S+B|lrAUbm!~9yG4m`%R7vTH8(=3#FubgA9C7(0adWX&ZrEo2H7-Ud
zIsz7@Ndp`*?B-EN$eXPNx$cgT&Q)3-mUJyVF4cg1pFF^}Z?eIaRC9(Uq#WVTGei6Q
zHF^^#*j<bm6t<c0ezRCv+{-;&?7qfg)G@~!1M%Ui*Y!Ey^!{&wb=c%>Wu3)FefVC~
EzbhR;q5uE@

literal 363
zcmV-x0hIn9iwFSL`p{qi1MSm6O9DX@2k<wmn39kks!PE_x1ik7(WR5t%~N0<x-Cm2
zL}sBYUOEM_ojP>r(lxrKU!hOYC+O@)=*{3^4pEzhApCzYzQ1n<c4y%=4;nqW>w7^f
zY`2T;lRy@mb}P`W;7aa9XDynN$EwQHRr(b<smk=tURjY;d_?-HtV-mSq*N7hy=fo#
z8~t7sc3qdE?XVY}4#IBq^|_z+=TxJyMOm&(L?T6klUY`FCRv|KS^bQamqpstC;nNn
z`m0u6o1D>W-Rd7&`TaIe1+H(rUgH$GT=#in80X31e8YJZJCx)6AnbdLYsv1L^juQo
znlNv^K$O;Za7dUc%m)+nQ4rZttiN5x{J-DKWrwleUo@5I?jm~Jc<$CY)?bc}_xhdl
z&gGzUP2$@J|C462`7h0E{;R&3{|e@RCNTehGw<^c0000000000000000002<?-QQz
J<)Z*7006@CxyJwi

diff --git a/tests/data/sen12ms/ROIs1970_fall_s1.tar.gz b/tests/data/sen12ms/ROIs1970_fall_s1.tar.gz
index 85fb0abb8a20e86dde5af7410b89bc3946567ed5..f42015efc90a3fd4f5d3d57ebf25c10b95288ef7 100644
GIT binary patch
literal 1989
zcmb2|=3pqb`H{fD{Pyzste8}p;}4C~kEwJk>@v7JrD#K*h>7t`&tvay-JHUqrP9TH
za6%(n%c4s?96<tpt#4wg7>k*OmY5reE9?-Au?l~nB>v!g&+-XL-5RVD?an_jey{)D
z`v0MsGJE#dTkSA>CqGx_{@&fSRu)n@;^(96kL~`OCfifa{?;n$?e?yNE9~X?jyK;C
z{d+LOMn?4NJLCT<{vV#ceDfnNRCKd>zkho9KC6A^)t?^!d-tdQ)r0ld|8HEoIPLX|
z?z!93=Fj_c`+J7ohkGwhUawdGT#&zI*T3q&58vh0uYd8L=a==)e}B_|w%eU8uKWA_
z`+W_wP5VMb=H^|@+*Wjbr^)o0r+Y&4?w0M(e0%9n(em&+XMV-iRW7}oKX3EZb9+lv
zi$Bkpf9b0CdE1IFafLVbg_~~|m(O`-w|-{tuiIynbU%AOlRvlXr;6*x+Gn3PZ`v{K
z=k!grjj#6ajeSxavuBoC=B!sH{@q)AQq`YlPFl9o@ADRq(;?F={U@9Fmd;x48ntZG
z?9V2imqV6UMlDIzsz#Fd)H-Lm=d5K`XD=)12Jf7Pr0RO{JeavL`TB>l&E@0gzngo1
zb$|W8ucy|^@BVuD+)?%Ia&ODS?st5>D!zQC_1ma#=gx1N^||-+=C4VsBW`DW+rK+5
z$Lw|f{V!p!UthQ1RU5I_cGb4k{Pq>wfBpJ={$0r7j}QOam%sl%xt^b46pYjmXn20_
z;P2ndo24KByLj^B-QBmBH!nW;Ejil#?6r&H&Cs0p;`qH4_t!Lke77Lhef8hDXAbWT
zG?e&y9GnB~e_J>I5efYt`EQ~BXI$AitNwp)lJaYB*NZR3=B8<v&-E^zx${iK(`&ik
zXJ6Aht6yGq^z54VPp609`uof>`t2R>a3k~npPI3Izuakde=pkpwz{;q`s2a0cb{k7
zT(SSI&NZX?DgPd>ne87WazEY9Ub{PcX1(TZ@fH7W-*&Y-esnb=BbF7xbCOT$Or$Kf
z8!01hnvNt9f1+~MlFU_?ZFDagP0dD9Rb-3E;9tKf?J4{G@$1WbKllFn@jQP0onITH
z?cc=I6urJ!m;SXkBEGh8*3Qf8Qs4i{S#5dW!aiDmTi4d!wEw$bA5Gi*@0)M_)_rw<
z7vFBbdV6u!?q468%U7?r|Nq9%R7U>Z|Kjie?0<eAsVQ>Q-=Gj^cz#O$!8@-F3=#qi
E00zJ;egFUf

literal 362
zcmV-w0hRtAiwFSR`p{qi1MSnXN&`U<2H@FChzSOah1w__*a@23Wc9F0v`ZyK3%lbA
z17eJlyO738kV|D@VPh+{Ca>UA_ypE@1ZS5NTZo=f0)hX7%}izn?)G4sM~z7C`(Drr
z+wF2B16gj`r9hX0Yq=Ajw`fWp+f$y7(%+Sns7&4Ts*0rI5$P*c^~tM9ucFBHrhVXV
z^rATIx-P}rVHBVB!*2Zb+)w>E)o5%{p5qdc$dKU794mJwxt_{c^_-P2i>!%H{Ig=!
zSFL<)GNaGBRX?`!_q!sMIKJ_DO)}(iJmkhODU!qaE$5@ep#tX*!oJ72mhQf3=h7P2
zgn9D?qO87yL&8L1KA517lE{w|{q1t*|NUkmKTLFg(L|!bW&F7D+^ut3e>pil=yfhS
zSN+ZniEkhLPnzlWzcRD^*L}VJ68k?3*#Ezo_x%R|0000000000000000D$@T37T_M
IZU86%0FR8iwg3PC

diff --git a/tests/data/sen12ms/ROIs1970_fall_s2.tar.gz b/tests/data/sen12ms/ROIs1970_fall_s2.tar.gz
index e4f390ad439ee8125c32786f6b4de2d92534b8af..bb564e2dcc6f45e9d1b1011357341e475efd9630 100644
GIT binary patch
literal 5131
zcmeI!TToMX9tUuCoRyuim7z|ht3_J0Mdapc01bp}tG47u1S|+`NV{tAz^2#|K!SmF
zsM=Nmfe=i9q{ulrVhC*U0Lsm+Zp(6woWrFC33aW(Kfy$sLxhma^0E)zeeYBLznA~Z
zZ+`Rp%=~7)0T=(^RT#VcvDdn%lRhUWmI4Nz>x2Z9m8E8B_<oxc6AiaUS%K`p<LBbT
zD=%*e357@gx(Ng%ZQg$M-M}3OuLcGN9{=*-L6NVo@2ju)u2teIiAlb1;+DKz`ccQ0
zcgRvcdHPJDVgByCdD-wh?q)}}{rtl4){e7v-Z?$O!F%{wd(|(gnnO)pQ|YEMgMC@Q
zH$Sd*qA07(Y<`dCgQQp>(F<9Yh3{e%4|Fy@{4Pc_x#!IIPxqev@U*mGquXV2Jz2Tk
z+~KCV=U#sqD_?KE#*gg<MtV`j)Zc2C94<$$VfHnZyFI-i$I^}<omj@O?wj=0klRm=
zyB=CCrk-!u!&FqtENaHee>p7wd(LoiN@oCUdu~lh4qBW~q5crX@2c5T;^<vc{(e&i
zQRDnEyPbaQ&We69Q{WV51v?+T*wuj4_vQ))V}`CS2An=67$i<Ww$=CatjN`^Hv;^j
z5ciPl{@A8D!5EyH_Om^RKk9f_k%_X1ZtN{uy^__2a`ACWQ<7p{{VM3DNVjn!;AjE`
zD5XbB(Q#8@6Jf(b`lN;g70SnZZFuiaEwdCT$>aK31BVYkYSuJSOke@~)6;k^;sj3e
zgX`?zQ6f1fy*dhMfO5od`LpNX;AEDy1&dumN1+|G>I_x@YQf1d{G<ACmWh}m<Hd1(
zl^c-&yahrEGt%Wzun;^a{~`{N$chtk(OTm<Fhsd*W^&<LA_knI%8aTb3RV)oJ9xG>
z9~~z%?0cMw&0{-9%@}pI%FHdo&yt@|tMr*NqrADYmC>cXfD>SnOteSkjSV>n1mfwd
zwk7D0X(9-mRDAZiQI!Il@WWzC-(>?^rB>mK_vIzsfjm_w$^!_QZ;y3W8Ak^l#C6IQ
zGlQ#^fLZboRoQJ6xPHBRebowTz}^-zV+aGuq+aP~BpXk-puz=i9T6{nyH6IEFoyti
zt*sr46LKoxd15O#Y=3i9p;|#}paXi@Hg1Hv3(o}el!AARs#f+o&`KT@@9(SLh#rHA
zQ;jM+&H?>cOqu!xUJItNXV?f`o6rTX5=zk<k}Kt~?VP+M3(m&1ppg`bBPG&)-ag>w
zpTJFD<c7PSQg3Pc+dkcQ`dap5m(6?Qk>cJ@9{)4ulCv@I(wy*&(Da&r+C6cx{z-gh
z+F^A<b_2ch=2GU-;0pz!OWOH}jN8|5iy7QJM&4|PMpKY;OLDBEXS~Gn6;b4Va^QDf
zp63zp2zUfM0v>_iM8Gk3v`3wDt-m*M>&?PvoinnR!u+pAtc;HT*>v)!a>UOkr+Y<b
zXxcn1&eC=mo@guDXzu-%PbabvLvnVgChvtUe0T*HYm3sFr(8o3RJriL-O_>-&57l!
z-!(ogoAI{1?s85$$E_vF5{aJ_N}HD^K@l}miQ9H<vI+0&hHRx1am9wLg)f{Bm;*l=
zO`S=`3RRck#>aQEyW0bbIJQjoK7O5Zq=nB7LrNSO$PH<A!B}YF`)N|=I-j*qcj##G
zTzpZppyZgXX}j<-|2}=D@ZU2da&p(jkK8|N<otN+q6kW_?SwB7xnPN8P!)nBOzQ(I
zkXL&iZvy8?ft})%3c6~HE8uI9M6b+8YVjFhC0UB;422)^0knIzTFG9;d%#6eY+jyJ
zK;tz;sr^ASM(<PgGi!p8Lh%A88&_j{pK{vZQcy=Zkp(GhWT*?<Uj}F5+29e$Qy9_|
z7uWKoM6cM!(4o<IBY8j(xfT;yA;ftsjHb+B=O8*<2boE{cQ;SI9_N9t$j`+={s{xP
zqneq^SYSmXtGJn>FtGS)K5^%d$o+;C^h4YUajBQ%*zYH;j^MF-Bk@QuMIIJY`xJ4^
zIrUiDS`?#bSs&te!7Wm3-{H^Mn=s}ez83MeFe}u4cpV_fWCbn8`hRhCzq};9W<5az
zgIGjgU4Q&Q^7Mld`mc9S-s7IAn}Rt|roJwN;Y~zCL%k#PFs>8I-NMkp)A#`Bp*Sbj
z+GJCx7F3dF#M}LubU4kr*NyEF#?Ro7!1rW|J=9rm4F8vdsDa*?tx?8Dpau9tQRt{;
z$dUX%IaMiJK_`JsRHCom2>TF~6aBlb+%gfTJCY_<CbX$5@U9I(PPc|FZa6je_%<)7
zVDiP}%icbD+6Qy4f1Dkvh;FGrec@X=R{p%FtWD_Ow0%Rmj=R+#gl-s`fV9?u&0VgS
zLLNUWFaLJQ@x3W^DK!E#hc~zO<mWA!!@6=>@}un*+Gk=*fMn-ya-*Ih9s!SlN5CWC
V5%{mbvT8Z{5aZ4!uiX@{{{Y>;6tMsR

literal 364
zcmV-y0h9h8iwFSW`p{qi1MSl>OT$1E2k>`ksVx?)gSsdL+yw1idTnrOb?YQl2e**H
zf>^6GDP5cdiIanai>tWWeg!{;pTM~v!Mn4=4WhA1q458~_5J(qAi2P69W*1c>+_%;
zb~@$A3q-kPw*uV?F2zoK+NLRSr6#$q!mo-+m8Ng@Dw2d$M}#k>UnA}bUJ>N-X&?9-
z{U{E5u1oQD7{w=puor)Q?x+1Z)ogB2UezTcmLaB+Sypx?S)a;S{hXDTS=Q7?^|NC2
zSFOA@IiuIQ)jzcI+f9*5s=liAl4QtLbzf}^lOj1PU#mPy94e@M&+L1Q>*?;B_FP)y
zIx}y+K$O*YaEO`8%m-uiUSj!CqQ70v{J+~Q<cEpgUo@5I_B?*rc<MD&Y&;(w@AbQ9
z-HSo@irBXg{wJ+;^Y6`S{;T|R{ymBLp9ReS-^}~`0{{R300000000000002M{QCfE
K6BHx>C;$K*1h+H*

diff --git a/tests/data/sen12ms/ROIs2017_winter/lc_1/ROIs2017_winter_lc_1_p1.tif b/tests/data/sen12ms/ROIs2017_winter/lc_1/ROIs2017_winter_lc_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..ae30f9baac7cc151bcba8e3f3c9c7e90a9219f27 100644
GIT binary patch
literal 525066
zcmeIwv1$}i7>409JL@KdAh9rML>6MBjfH}iku4;GjnP;rHmj}n5)d-NcHYFaf&}pj
zrWb4kOPSWf!VB=*>;_iQ+UCjd=KMKlW<s9q{{FSHUP{?2rK(GnY5uKRnFpDN+5VjB
z<^KG>(aL<G8kW869p>QTa)18J_R74Id4A8=bZO<;2bt^a9S%x4$UJ}UY3B3I=IQ?P
z%*Ssx%P9LtnLo_xGS2)y^T}*bE@%FcdH%JvymG^Ty*Ba(ZS1B=nx-bTsY`vTtDL7v
znx-bTsY`vT2RToZG)+xvQ<wTw*Evs<G)+xvQ<wTw4|AR-X_}hUrY`lVK9}<}Nz>G%
zHg%~_^(g0QlBTIiZR%2=>b0DwNt&i6wW&+}+Tx#)57OdV{CH*W&vkjzUzU46$4|a|
z+qv_xKK@kwdUogRmigOC$=mZ0IeqhT9Sl!q+c~M$PiAXnyNvRIuFAXJvN>PBzZssc
zS9c%ZJs97<IlexA^zi=p^{baJ#y4&q94&T_&VGrN009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
jAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly@K1r?6nRP|

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs2017_winter/lc_1/ROIs2017_winter_lc_1_p2.tif b/tests/data/sen12ms/ROIs2017_winter/lc_1/ROIs2017_winter_lc_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..ae30f9baac7cc151bcba8e3f3c9c7e90a9219f27 100644
GIT binary patch
literal 525066
zcmeIwv1$}i7>409JL@KdAh9rML>6MBjfH}iku4;GjnP;rHmj}n5)d-NcHYFaf&}pj
zrWb4kOPSWf!VB=*>;_iQ+UCjd=KMKlW<s9q{{FSHUP{?2rK(GnY5uKRnFpDN+5VjB
z<^KG>(aL<G8kW869p>QTa)18J_R74Id4A8=bZO<;2bt^a9S%x4$UJ}UY3B3I=IQ?P
z%*Ssx%P9LtnLo_xGS2)y^T}*bE@%FcdH%JvymG^Ty*Ba(ZS1B=nx-bTsY`vTtDL7v
znx-bTsY`vT2RToZG)+xvQ<wTw*Evs<G)+xvQ<wTw4|AR-X_}hUrY`lVK9}<}Nz>G%
zHg%~_^(g0QlBTIiZR%2=>b0DwNt&i6wW&+}+Tx#)57OdV{CH*W&vkjzUzU46$4|a|
z+qv_xKK@kwdUogRmigOC$=mZ0IeqhT9Sl!q+c~M$PiAXnyNvRIuFAXJvN>PBzZssc
zS9c%ZJs97<IlexA^zi=p^{baJ#y4&q94&T_&VGrN009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
jAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly@K1r?6nRP|

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs2017_winter/s1_1/ROIs2017_winter_s1_1_p1.tif b/tests/data/sen12ms/ROIs2017_winter/s1_1/ROIs2017_winter_s1_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..df0502117655136f244499d2a84519f67d9cb4a7 100644
GIT binary patch
literal 525044
zcmeIwv1-*|9LC`<ImgouMRc%TL=M(P7Y79$YZj@XgH;>^hk%Z{OF@W2H%BiZHy}m4
zfn0##A~>2WaOeg2ragrYI=eg#zmq@Tmz)!xW_R~SSudqrD5aW}D%12)otf**b(WVo
zW~=q-y2Y9KVl^*2S$mX?ORM$ip3T)f&%Bj+y5?KDeCFQAt2xVMFY|QYEXVox8~Mz4
zW}*AAQ5KnBW&V6H%afGyDf8h$U9M#QG2Jx%O%M4WkE1-t(bd$XHg%~_LmE?EWj{5k
zO<n5Kkj7Nk*-uSsQ<wTQq%qaA?58HRsY`tt(wORb_EVGE)TKTRX-xIG?58HRsY`tt
z(wOQ+_EVGE)TKTRX-xH6_EVGE)TKTRX<R$`ACzl5C&TG^wfvXUgWt>N-+yl1`!egk
zR!1-HonBIvDr3GcFU~aQ^*TP+^TUJ9>{RQA2Ww@sEb{7B<>PkQn9jf6&5zI5x1ZhL
zTi(6Byt#b(<l*w|o7XRwx9;ripRDem{)jUH0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
f1PBlyK!5-N0t5&UAV7cs0RjXF5FkL{p8|gX(6EAY

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs2017_winter/s1_1/ROIs2017_winter_s1_1_p2.tif b/tests/data/sen12ms/ROIs2017_winter/s1_1/ROIs2017_winter_s1_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..df0502117655136f244499d2a84519f67d9cb4a7 100644
GIT binary patch
literal 525044
zcmeIwv1-*|9LC`<ImgouMRc%TL=M(P7Y79$YZj@XgH;>^hk%Z{OF@W2H%BiZHy}m4
zfn0##A~>2WaOeg2ragrYI=eg#zmq@Tmz)!xW_R~SSudqrD5aW}D%12)otf**b(WVo
zW~=q-y2Y9KVl^*2S$mX?ORM$ip3T)f&%Bj+y5?KDeCFQAt2xVMFY|QYEXVox8~Mz4
zW}*AAQ5KnBW&V6H%afGyDf8h$U9M#QG2Jx%O%M4WkE1-t(bd$XHg%~_LmE?EWj{5k
zO<n5Kkj7Nk*-uSsQ<wTQq%qaA?58HRsY`tt(wORb_EVGE)TKTRX-xIG?58HRsY`tt
z(wOQ+_EVGE)TKTRX-xH6_EVGE)TKTRX<R$`ACzl5C&TG^wfvXUgWt>N-+yl1`!egk
zR!1-HonBIvDr3GcFU~aQ^*TP+^TUJ9>{RQA2Ww@sEb{7B<>PkQn9jf6&5zI5x1ZhL
zTi(6Byt#b(<l*w|o7XRwx9;ripRDem{)jUH0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
f1PBlyK!5-N0t5&UAV7cs0RjXF5FkL{p8|gX(6EAY

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs2017_winter/s2_1/ROIs2017_winter_s2_1_p1.tif b/tests/data/sen12ms/ROIs2017_winter/s2_1/ROIs2017_winter_s2_1_p1.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..35d51e381ff378cacc18515ca526d80e45305ab1 100644
GIT binary patch
literal 1705920
zcmeIzf2daV9l-JP-0RP&sdIW~`_T<IMjIox7A_*1M2HKCb|(_jqJ>06lZc2`A?4x{
z(IO%uBBDh^M94)XBBCcEBBDYfLLx#UG9p^Eh=^$Ks|F6-pZjaCdw4(RbHC3y=fdlI
z;cVIR^I^#_46BA=G&zi#=08Tq%@fTlT7Io2kFC#Nx9GTe^=QG7`wmYG!`fr(^Y^Sf
z?wYCQ`DY(){fEb`|Dkz#YljyN!%Xx1eZ%5mIBC!Fp*x0?n{WNw@}aMXUpMcaogAi{
z|J*z`J2CvY`5(>mKdb)hF`Vr9e-;?`A2L3*&aQ2>t8TAH>e+g$KCNY=Vf@oNw=S-0
z>&|+tp0Bs-^IADEj8Cic>XN#??ye{5#d^2CtTmIv_?NZ0E~^{s-r8F)*L(GKO)VJ4
zzp4vrXYH>0YhS%uAJk~!F#bWESr^uowWl7er|Lj`R0|gk<5TLanyIU6wjQo$>dpG3
zmM$K~8|s|eUf0we^=Lg;2kWz1v1AzktTxq-x~}f3$Loc9r@pAwONa3<>ioL2Zm4_e
z$$F^{)mOFlJHz<&+ESO-&2?YR)hqRWeN*d~4dXLvYh6*d)C0A@Uat>pa``a+QEjY?
z>Z-b}9;&D7jrzD2uW0}4?Alhl>h^l1o~^g)(^_^?`(NkQ#dU4nS&!B8^>%$;D_6Gv
zbzWUk*Vo<kM7>z=)|a(rRr_C?>$1AB?ybG`a=lky*VO9vzb>eqwY%=Gef4U6P^0g*
z|8-_vSXb7bda$0V1NBiYT+{y7Sv6Bv*K9pp&(xdsNiF?e`(NkO_PVC-s7LF$I#{38
zinZ;3ZK@r0UENiW*9-MdeNn5|wf}W~U0OHPJ@sV0REO%TT07PL*Ot1xZm#=ku3oA4
z>zi8t{r11M))jS2Jy84W_4=?T*SG(*u`a5s>b82Qo~}3Q<Ml^h4=4B>^-4PNarEM!
z{O&)`CwRoMrQiQ^ddGo-Q=9fp-nxJEuRm@2_R9IEA9<l2c}4cyvGc@&x!HAnGg>k?
zyLebPEb28p8vedv{$)5C4((oW<b2wO?VD$&fBT#1)2FxnaqIM7cl~AO^cfpxZaTVp
z)3<-bnE(L-1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0{?S?
Fe*+x4h?)QZ

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs2017_winter/s2_1/ROIs2017_winter_s2_1_p2.tif b/tests/data/sen12ms/ROIs2017_winter/s2_1/ROIs2017_winter_s2_1_p2.tif
index 607e18320bb38a0a4b549202176267f04bc88b4a..35d51e381ff378cacc18515ca526d80e45305ab1 100644
GIT binary patch
literal 1705920
zcmeIzf2daV9l-JP-0RP&sdIW~`_T<IMjIox7A_*1M2HKCb|(_jqJ>06lZc2`A?4x{
z(IO%uBBDh^M94)XBBCcEBBDYfLLx#UG9p^Eh=^$Ks|F6-pZjaCdw4(RbHC3y=fdlI
z;cVIR^I^#_46BA=G&zi#=08Tq%@fTlT7Io2kFC#Nx9GTe^=QG7`wmYG!`fr(^Y^Sf
z?wYCQ`DY(){fEb`|Dkz#YljyN!%Xx1eZ%5mIBC!Fp*x0?n{WNw@}aMXUpMcaogAi{
z|J*z`J2CvY`5(>mKdb)hF`Vr9e-;?`A2L3*&aQ2>t8TAH>e+g$KCNY=Vf@oNw=S-0
z>&|+tp0Bs-^IADEj8Cic>XN#??ye{5#d^2CtTmIv_?NZ0E~^{s-r8F)*L(GKO)VJ4
zzp4vrXYH>0YhS%uAJk~!F#bWESr^uowWl7er|Lj`R0|gk<5TLanyIU6wjQo$>dpG3
zmM$K~8|s|eUf0we^=Lg;2kWz1v1AzktTxq-x~}f3$Loc9r@pAwONa3<>ioL2Zm4_e
z$$F^{)mOFlJHz<&+ESO-&2?YR)hqRWeN*d~4dXLvYh6*d)C0A@Uat>pa``a+QEjY?
z>Z-b}9;&D7jrzD2uW0}4?Alhl>h^l1o~^g)(^_^?`(NkQ#dU4nS&!B8^>%$;D_6Gv
zbzWUk*Vo<kM7>z=)|a(rRr_C?>$1AB?ybG`a=lky*VO9vzb>eqwY%=Gef4U6P^0g*
z|8-_vSXb7bda$0V1NBiYT+{y7Sv6Bv*K9pp&(xdsNiF?e`(NkO_PVC-s7LF$I#{38
zinZ;3ZK@r0UENiW*9-MdeNn5|wf}W~U0OHPJ@sV0REO%TT07PL*Ot1xZm#=ku3oA4
z>zi8t{r11M))jS2Jy84W_4=?T*SG(*u`a5s>b82Qo~}3Q<Ml^h4=4B>^-4PNarEM!
z{O&)`CwRoMrQiQ^ddGo-Q=9fp-nxJEuRm@2_R9IEA9<l2c}4cyvGc@&x!HAnGg>k?
zyLebPEb28p8vedv{$)5C4((oW<b2wO?VD$&fBT#1)2FxnaqIM7cl~AO^cfpxZaTVp
z)3<-bnE(L-1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7
z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N
z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+
z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0{?S?
Fe*+x4h?)QZ

literal 412
zcmebD)MDUZU|`^9U|?isU<9(j7>UgUWrI{PBZ;#iu>~1f!1`tbHH#vNiy^Vap=v<p
z%OHsdBe8F^@-PSh<qrYz`gUdp1t9GN)UctQhk*&mZUVA5wlgts0@;&52EoAxdpHv>
zgIINV4MCFpV9yBlIXeRb3n=WE7=Ydc(m=-n1B{X3nE)fl#&%HHv4Q!0%A6b<+ClQ%
hV48uUBe!Il?2;k}pc02=ArX$HdD(gS<#{y>i~xB991s8i

diff --git a/tests/data/sen12ms/ROIs2017_winter_lc.tar.gz b/tests/data/sen12ms/ROIs2017_winter_lc.tar.gz
index 988ac796014772820fc36a192a17e269a820ac5f..8425bf9d8315b2dfa3ea69e5912eab0f1c96a21a 100644
GIT binary patch
literal 2009
zcmb2|=3r>E`H{fD{PwbMcJfpC;}0j#xiM|wi5(j@3t9%4bKSDpT4?Dk7UbA+t-Uo#
z^Eel?k(adOgeC*QU7vkZv^@ml9lte6A6%O9`cSL>ga5XfEn1?1Y)AHA7q#12zxVxQ
z^+|Gj_SIi||IN*v|GoW;Idk6CM96<F>pH$#dhy-7&EMR1@4adj^KQM!-o$bfiJq#R
z+Pn7NJ-8x1WOx71+B+{MZ$9}kGgNf4c>j4db^d;Tb@TY|>CgWMv76Wa-+$XC%dFq-
z-F}mu{}0};?0v?4Px{`Uzu%4dtN%XzzW=)H8@}1EfBlUs4+*(@{BL6ZC;9*XzJHI`
zFxzxbuPZEa%dE9`wyrz-_RQR#`^$>9-rrJ|Tes?}=DW07?RuNNxANsSm*(!9ymRNX
z-(SvbJua7`H~aXu?neb*qu!_0746!2r{4ba;`8R+ThBb7xqp{Nx7O$BGxhav9o;;$
zJ}bU<*6r2NdOzIrw|_d8pS!$p)n${jmuz%{Zl0=?T5jcgS?BC!rKxY{AS5E6+4Kg_
zU6wiRS?0u3e&;S*T+N)7mN`#sWsTDF%sH=2d^el;cZaNdilpi*Li@Gw{cEqiDto$f
z_x{-bH&)w+zpwdzcy4w4^!|OBe?Q&Z8~=U%yzJVa#Zh*jvvSMz^ta9W+<UtFYtrh7
z+Zo^X-_SFg{q^{HtJ7b9zTF;gxh767%=+r={5@f{zb-aU&N8sF*?-ISKlguQhEXtL
zL*TzE`}+6uzwX|9@#5j%{A%jUt>v$|@11);SI%^{yZraKS$F<Fc)!QZ{9D`Iw70!w
z)vHT)+<Bia_wAQ!{tel;rR=*8AB?;B_IveS$G}qg@9ld}s;5tWe0i0Yn!en8Uq3my
n`F?r(-km@9f9bc;96FjqM{G8u$m1XWzp8)fQOnODA;16tD9SC~

literal 364
zcmV-y0h9h8iwFSm`p{qi1MSl>OT$1E2k>`ksVx?)gSsdL+yredP1~{6t&>n4+(MBG
zMU9eP>Ea|vIypGFxQeUoSMXE#37q>8d^tOuAR4O_3jZHm-@oq;k_)`%exvI;vg-Fc
zfog}vvtwTto1dG0-1INyj_RDy6dYFZoVdzrSx%~_`+BeBk@Wb8ta{SpzUxX^BHNkf
zVZYVus#a**q_$gK)$X@K_4T=*_UBZiu|-*~OGF|?f|FiGwkA0~l`{GnBQJ}zt`GdP
zV)R#yyf!%#uXUq;VC2`EJQcXU@Oq9?WOLo)jbW50i}N+-QDjk$^PMp7F|H-MZ_;x~
zjcY=``2tZozJo<VSD`<cptpj^j-vS6W%U2s&0KaE#ruo85)IDP{l;Th=U9I_JlgFA
zr@=)(xFYfGga1i0`TV;xng2@ZWB$vS|5?EN|INJ5KL7v#000000000000000%)fWr
KWm1a(C;$M<QM;%B

diff --git a/tests/data/sen12ms/ROIs2017_winter_s1.tar.gz b/tests/data/sen12ms/ROIs2017_winter_s1.tar.gz
index 8bff894ebae70cef0479c5b65fc8afa5cee8b4b7..14c847d3c8ee8971d8804acf05f3abda64538615 100644
GIT binary patch
literal 1992
zcmeH``%ha19L0$QA#uT(z;G~WG7~U3#}Ba9ZI?DnM1~5LjndE!iWpd04IO1t9$jlh
z!(um?UKx~8YFeHGZ3JrDUD~UX(gE!y*in#D3Y%OWwNzJb-w)#t2L6Zb{CZBl$@k=Z
zaDuof0pP8OiguXhnIBi3&~Jd?a(&S|N%i=XvHCk-;M4iZ9a(=|j7g;FzN%pS5Iugp
z@6M5jpI=XSP`4BF=Zn3!2zOsPx*B)dn5f#0@#dU~resKt+%mYnB(KqJgve}u{F;T7
zvTvVRm<qg%rVl{Zup-SBpfuEZJK&&^r?IBj${g}UY>;$3KK--3uX#DCW>At$+L*7E
z&LgOPfI>0QNyPhN03eENK^1&HB0i_u@kbc0K`Y?D@%MBvtl_&-9WiSuR&FR(*xD=|
zw!=%fZ}cq}7I2Tie0b1L_KP($mw6$NhyLczV?=6#sAhqoWG|`l9m2WWlo~6>vrH>|
zzCyVQ#H_)8ertknB1qF--xZ-nAG}*W>0WKoI}=;&o?X=aSBFJC|4Fsf$Ap$2ax-1Z
zEi3msi8sxqYb>4o-Z#Jwy|Bn{h74OO?%4v<sWXgk?=jkE3lUSc@e+89AuJg>RoBzc
zxYsptac<(hD#8|{t9mG3F!8}~v73EhY-XJ$o3h_8p!HVK`q-}@O4Xpi|92H?ZJd17
z_r$-n7FPJT^<tJaB(rdB>Y#V;NeEdaRJwKrCPakM+@}%FifdHhGFA>OFEc%`w(L`-
zJ(IpKGgDc7ulXYk9b6eDHbg|bE^=yj@zl(Q)W*SuKyhr;b3LmK{Bqg3t_h7_fO}5l
zOhzhr><7&yxJ8J+0x$_}#8F$P4fe3sq_}1&4>E(bn({nqpv5qyDJp97gPQPlK$f1%
z|B#$ECD|qI@ZD)*k+F?D{9`A~<Kjt;4cv3Eua?gVlN4}-_ES5imTcb;6hiF~qEH*I
zR*$glGLHo>GtP6GbfOU_+LmMvIO^)nb(z-LRU+ED|5&k=3h?A_Uxldz<u!N}xmli-
zVx(Gh@1o5@ILC>C2|9u>6PbJ5XCSrPlLo^UOBGSSId{NZ{UPS6gs$v@@khP6w0=qk
zbcnyPjzflcrm?HPl==I~w@exBDTh+*tOH7oSZ>26f?I;!Zuw#!Da^I+aja+n+0=7z
zPL53b%6%%myMAwEX^c~=HTAH{x>?80>!wSf2<E7S%J@DBN1<&BOey1s33-b(*slR+
pv6%mKy*Ifq9v9LEw#7l<SzYDxzyE7seduXQ>>J&cQLi42`WL;aF+BhP

literal 364
zcmV-y0h9h8iwFSu`p{qi1MSl>OT$1E2k>`ksVx?)gSsdL+yrgz8k@1zt&>n4+(L&6
zMU0YM>Ea|voE#inT*cM)EBGn=1kU{k-klvz5RFv|h5rw(@85R^$pv2fpp^)Z2jQR>
z$!=Utc*v{m&&^Ob!wbG6dnYsnPpSK!t~}V~lj@tk*{k`)eRYHfz7T>u!GpRW*PG^H
zztvA<Cw5(u+nq#q2c1}ceeS3IIn`=yQBl<;B9<ejl37-ECRv}#S^a{Qms#G_2lcaJ
z^;fODHaVl$y463l^6Pb(DyqJy^_=F&Rdru&4AU|>DqpEQN*yYxe8=p2j2qeRoAq2)
z;|4QtzCe`McW{WA%FG92^j2ZTQL4XP!Ti77EER{T-d{A8=;ln`Z#>3L6`M~-$9w(g
zG&&zdm&Cq(@IPs1pMNov`S)ud^IymO&jRNEZ{~ge0RR9100000000000001B{=Eac
KSo?+mC;$Mo9<%=d

diff --git a/tests/data/sen12ms/ROIs2017_winter_s2.tar.gz b/tests/data/sen12ms/ROIs2017_winter_s2.tar.gz
index e99cd42f2ab680ec3e02cd6008129e4d7d3cc5b7..5338d2cc3951be809cef59f042df31033b22ea2a 100644
GIT binary patch
literal 5131
zcmeI!T~HI}8V7LBIQC<#a>1E8LIoQr6%javAP@+d5d@NuY|FQyfE__xXd0*qABzd2
zPRsGwh<qfN2&7_mGXcSa1gX*Ju`=LPAZ3@2AsCQSz$F6JY=VS@l$+i-=ek#UuHLKX
z{m*aanfd!%de7}j%$pN#J66VbpOzH(48Agbje$i)$kSXPEB;uebuoa%Amx9T6kK=3
zlbMm!xZsa^)qm*QMmp+8YCB3I<^MZAo=+nA9g6q!BgMColx-xxwx#k#@2u<Z&Fuh)
zjb~@|f>PsB$=V-2&5}Ud_xFlgEazCJ)qVR6|E>6`_{TG)QFn{JSnCX*9D#UC{f016
z>~+3%Y}shEjNEVJ6!OY5JJYIw*R!R`UNwpDM5J{T{C@k<T-|ln1+Rq5jt3q_XAP(F
z=7w{j<j2a$65i5+uW9v7wEpy-3c9{~Nnu{K_1l}qv{hB6sI}$xafs1dcKhMWZu`@v
z*~xOcOe$apNG4K1?*%v%oUM1<{F+AZ^jI23*am&4M$CHv1{7@dSDM3i`Ri1^o3GaM
ztF212WJ*6|8y-usecGCCU`7c{L-jyoSkLV17en>aaNuUkjZRqZSedF7-)TJ4Q+?O*
zqEB|_Sw}N&i^vn(Yse!&CY%lmp%`8L3|#^HU_UUxFRymd`;>D;J`}ENiUl4jr-I<p
zQf;tNegrN=P51?(fKtEMD;+2Rk9#J&BV4f1(69%dO-;-O`G^<xxuLn0c@G`LO=+?e
z&q8=cL+WH^W4rKSO@y!sNe&X5QHh#nY)QbF_=<)mR3Lp#18sZ(r)8B1DEH$={sBkh
zDORBP5{hd4xygWP65Yfv5ykRo9XXgasXE86hK}g!Vw2y+c;Hq5+#P9wd+|99RSegn
znRu<HBmv~B7Vr@w35s1|D-d3)X$Xz{bR1*hT|^f2nNDJbAFG8Ki;6Br2WlfKpiguS
zu}m7WPjzYwm-CsPYyio`s&F&GlvAV4z$BcFAw)7n6<&FeoQU3!l2vo0?_d|eY=g|I
zjKkN*K8r8|5y*8-6t$@guEi$R-*Ofe5cVHUFqajgjKF4y9C>Jn8OTJo_~o9g5V#N9
zB7|}gw4H(7feG=88eiSDJxT?7b7OnCd_pP4ae@QUgmog;nZ5a2xQ%>e70@FQXbpbC
z7Bsx}#GabRx#rED#<FY&g_5nLUHT_>>@~j-@}nxsQ~=he7JRj+SjG{4CUjVLb%wEt
z&V4uNaCCgMPFX%*?7Z(iyPK9a`I7o;H$T%PHA)n`Y|6&_^R&}k58zr>wqYP)FL@2{
z^5TZ<`eh6pHmg1iul^u#;rZg7SC-$7bu?KrZ@o|lcXeqiD=p_N>mQ`wGdbM%Q-v?$
ztN-cd8kc}ez$M@ka0&b^0{?T0|8KE-mAB_zdCiXXvYgo4tCt^|f8ZR()qmAI^Q?Il
z>dc^26<I#%U7eYMcxr)QAwfOCwl-0v;>W%hyxPY@znyyi$CF=?N4tFoMY9)IopBaR
zP6|@clFER4)8vVj>SRM-J}qz>NHO(S_NW`IX9BtN*LWO;j8-~hA39H8!=H%k)F}lO
zKU-i8>k)<ZHf~)klvq>PMoQ1`9t%S+`(m~qW%w_mrPIagQ`J@0lQ)7Ep1sWbhGyd~
zezbn5P`fpp>FfMhY{t^TbdJIsxTP#d3-LknjTFzlNHH1&Mp9+DtTkAVg@9#D@XO{d
zW*@@BWdvk9Ae3EJR(8Ur$KPr#qZytp_yD=_h-wM#B1&zPbfj_MxH_UU$%IZ2N1?D4
z)+`*5%ACK?FIWc3Rii`-6ukn>s_+%K`(RE>hH4Y_0285z{Yf<VIL4T7(~vvqUKob=
z5+WPPAzx&Nh?$rLJYZC`vUo~&>=BVIuV#RU*+P&DMRI|Y_zfc6<{Q-fg{Kj$)P_;(
zTY-C+3ZEXM^pHpB7JjNWkSfhh=D|X|q(~vzP<5c~npkRUE`3d@M{B_WwX9m}Z>;|w
zYrw~eTw9Ez{*->ijtTGyO#rna7w}PrV0C03dr={U9}y=E(lUgKe{Q1+hKB8!7(B>j
z>){-Ho)EM*OE*++wbh}gcI>UPs%YKLfGzX$Aks?G8nOddk&8v!%aL&KBt+3kXMj9q
z9`<bKcC6Ul%1x{X7ZYDmu8NrE=uqca(*#n3S;^8^MjlK<e+~<EYGRBsZ@OM(#4&<f
zlyh}M1!)6}5^rV*(uY3aSIm`GI}Z)&E^D6~XtxH-AG?o-SGn^K8^^T;<qJ#GQnu*l
zH}0J2e$0PDdZ&AI=kO*rkTCu9e5in9wyTc~`#feu{dAXmR#!2)T;LcFgxW84bbOPW
zD?H(##*ME+&bUOthcfE3^KZFQ*C#Fkmw-#aCEybHOTg*j{72l!PO;m+$ZmfE9tr~c

literal 361
zcmV-v0hazBiwFSz`p{qi1MSl>OT$1E2k>`ksVx?)gSsdL+yredjm_BV)=7vCZlObk
zB1TEBba4_SP8}RvT*cM)EBGn=1kU{k-W?fE5RFv|h5rw(@85S1k_%jL)Ja^2`{A%3
ziC$b!+>qCU&&^OZ!z;cg`e!r)M{0VGs@&h_S@m>Z?=?K)o*d!6=QbPUxZL+S+0HBv
z`>jDDy0LAO*zG2wH|)mZ>$#uy7gVRSLuFZ4h**J`OnMpF%Ced&82yrwS6NZlNBOg6
z^w*8Nk<F;JY4nec{B~QVnyjyKy`%-QWj&M|<Frba%r`PmQj01w-!t<Z(^kIo=AFxH
z+G6_6mxzk$3>Gn6nf_pm-fOHpN!7P2>HnkcN_m{B{bgN=?k>c`)>GV;vHg5<dN7F2
zqsw7*P3+qT|C1p9{deba{~NrC`#(px|9`XS_a6WN00000000000000002bc|A7rP(
H04M+e<#V<{

diff --git a/tests/datasets/test_sen12ms.py b/tests/datasets/test_sen12ms.py
index 6868b2987ce..f713e7859ce 100644
--- a/tests/datasets/test_sen12ms.py
+++ b/tests/datasets/test_sen12ms.py
@@ -18,20 +18,18 @@ def dataset(
         self, monkeypatch: Generator[MonkeyPatch, None, None], request: SubRequest
     ) -> SEN12MS:
         md5s = [
-            "3079d1c5038fa101ec2072657f2cb1ab",
-            "f11487a4b2e641b64ed80a031c4d121d",
-            "299691b948b37028398d4506d0195c6d",
-            "76e6847b10ee9323ce022508721e2c6c",
-            "dfbe57486455c31ae6f4d243186a8da5",
-            "8d0aae3b12d420cab2feff5035400cbf",
-            "f524074dcd90b9a770031cbfec50db71",
-            "5256cf09bd2a0ec44bdff78f28e6653d",
-            "b85b1641971444c87fedbc7134c437ac",
-            "af28777ee277e3f9577c10a3c6d952eb",
-            "44d18ee9efeb83f921b3b7aa6d511bbf",
-            "00e18016c6af1e55528c535d9b06c35a",
-            "02d5128ac1fc2bf8762091b4f319762d",
-            "02d5128ac1fc2bf8762091b4f319762d",
+            "7f14be13d3f62c09b4dd5b4d55c97fd6",
+            "48182d44b375360381f36d432956b225",
+            "96cf1b8405d4149c6fe61ad7100bd65d",
+            "ba8e7e10fba9eea6900ddc530c86025a",
+            "7ba7c51f2fb3a2074b7bbd3e24f9d70d",
+            "280c9be2d1e13e663824dccd85e1e42f",
+            "a5284baf48534d4bc77acb1b103ff16c",
+            "c6b176fed0cdd5033cb1835506e40ee4",
+            "adc672746b79be4c4edc8b1a564e3ff4",
+            "194fab4a4e067a0452824c4e39f61b77",
+            "7899c0c36c884ae8c991ab8518b0d177",
+            "ccfee543d4351bcc5aa68729e8cc795c",
         ]
 
         monkeypatch.setattr(SEN12MS, "md5s", md5s)  # type: ignore[attr-defined]
diff --git a/tests/test_train.py b/tests/test_train.py
index 70d13c83957..ac0349fe266 100644
--- a/tests/test_train.py
+++ b/tests/test_train.py
@@ -4,6 +4,8 @@
 import sys
 from pathlib import Path
 
+import pytest
+
 
 def test_help() -> None:
     args = [sys.executable, "train.py", "--help"]
@@ -83,3 +85,28 @@ def test_overwrite_experiment_dir(tmp_path: Path) -> None:
         b"The experiment directory, .*, already exists, we might overwrite data in it!",
         ps.stdout,
     )
+
+
+@pytest.mark.parametrize("task", ["cyclone", "sen12ms"])
+def test_tasks(task: str, tmp_path: Path) -> None:
+    experiment_name = "test"
+    output_dir = tmp_path / "output"
+    data_dir = os.path.join("tests", "data")
+    log_dir = tmp_path / "logs"
+    args = [
+        sys.executable,
+        "train.py",
+        "--experiment_name",
+        experiment_name,
+        "--output_dir",
+        str(output_dir),
+        "--data_dir",
+        data_dir,
+        "--log_dir",
+        str(log_dir),
+        "--fast_dev_run",
+        "1",
+        "--task",
+        task,
+    ]
+    subprocess.run(args, check=True)
diff --git a/train.py b/train.py
index afed5a3cc9b..362f62f43a7 100755
--- a/train.py
+++ b/train.py
@@ -180,8 +180,6 @@ def main(args: argparse.Namespace) -> None:
         )
         loss = nn.CrossEntropyLoss()  # type: ignore[attr-defined]
         task = SEN12MSSegmentationTask(model, loss, **dict_args)
-    else:
-        raise ValueError(f"Task {args.task} is not recognized as a valid task.")
 
     ######################################
     # Setup trainer

From 05b4e8b9587f028337eca89385fc2448185f892c Mon Sep 17 00:00:00 2001
From: "Adam J. Stewart" <ajstewart426@gmail.com>
Date: Wed, 21 Jul 2021 15:41:13 +0000
Subject: [PATCH 9/9] Mypy fixes

---
 torchgeo/trainers/cyclone.py | 6 ++----
 torchgeo/trainers/sen12ms.py | 6 ++----
 train.py                     | 5 ++---
 3 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/torchgeo/trainers/cyclone.py b/torchgeo/trainers/cyclone.py
index 6325e10d1b7..6324874013c 100644
--- a/torchgeo/trainers/cyclone.py
+++ b/torchgeo/trainers/cyclone.py
@@ -90,16 +90,14 @@ def configure_optimizers(self) -> Dict[str, Any]:
         """Initialize the optimizer and learning rate scheduler."""
         optimizer = torch.optim.Adam(
             self.model.parameters(),
-            lr=self.hparams["learning_rate"],  # type: ignore[index]
+            lr=self.hparams["learning_rate"],
         )
         return {
             "optimizer": optimizer,
             "lr_scheduler": {
                 "scheduler": ReduceLROnPlateau(
                     optimizer,
-                    patience=self.hparams[
-                        "learning_rate_schedule_patience"
-                    ],  # type: ignore[index]
+                    patience=self.hparams["learning_rate_schedule_patience"],
                 ),
                 "monitor": "val_loss",
             },
diff --git a/torchgeo/trainers/sen12ms.py b/torchgeo/trainers/sen12ms.py
index ce0de1658d0..d1c67692091 100644
--- a/torchgeo/trainers/sen12ms.py
+++ b/torchgeo/trainers/sen12ms.py
@@ -87,16 +87,14 @@ def configure_optimizers(self) -> Dict[str, Any]:
         """Initialize the optimizer and learning rate scheduler."""
         optimizer = torch.optim.Adam(
             self.model.parameters(),
-            lr=self.hparams["learning_rate"],  # type: ignore[index]
+            lr=self.hparams["learning_rate"],
         )
         return {
             "optimizer": optimizer,
             "lr_scheduler": {
                 "scheduler": ReduceLROnPlateau(
                     optimizer,
-                    patience=self.hparams[
-                        "learning_rate_schedule_patience"
-                    ],  # type: ignore[index]
+                    patience=self.hparams["learning_rate_schedule_patience"],
                 ),
                 "monitor": "val_loss",
             },
diff --git a/train.py b/train.py
index 362f62f43a7..8555cb80ec1 100755
--- a/train.py
+++ b/train.py
@@ -4,7 +4,6 @@
 
 import argparse
 import os
-from typing import Optional
 
 import pytorch_lightning as pl
 import torch.nn as nn
@@ -152,8 +151,8 @@ def main(args: argparse.Namespace) -> None:
     # Convert the argparse Namespace into a dictionary so that we can pass as kwargs
     dict_args = vars(args)
 
-    datamodule: Optional[LightningDataModule] = None
-    task: Optional[LightningModule] = None
+    datamodule: LightningDataModule
+    task: LightningModule
     if args.task == "cyclone":
         datamodule = CycloneDataModule(
             args.data_dir,