ssb-sgis 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

sgis/raster/image_collection.py

@@ -6,6 +6,7 @@ import math
 import os
 import random
 import re
+import time
 from collections.abc import Callable
 from collections.abc import Iterable
 from collections.abc import Iterator
@@ -27,8 +28,6 @@ from geopandas import GeoDataFrame
 from geopandas import GeoSeries
 from matplotlib.colors import LinearSegmentedColormap
 from rasterio.enums import MergeAlg
-from rtree.index import Index
-from rtree.index import Property
 from scipy import stats
 from scipy.ndimage import binary_dilation
 from scipy.ndimage import binary_erosion
@@ -49,24 +48,15 @@ except ImportError:
 
 
 try:
-    from rioxarray.exceptions import NoDataInBounds
-    from rioxarray.merge import merge_arrays
-    from rioxarray.rioxarray import _generate_spatial_coords
-except ImportError:
-    pass
-try:
-    import xarray as xr
-    from xarray import DataArray
+    from google.auth import exceptions
 except ImportError:
 
-    class DataArray:
+    class exceptions:
         """Placeholder."""
 
+        class RefreshError:
+            """Placeholder."""
 
-try:
-    import torch
-except ImportError:
-    pass
 
 try:
     from gcsfs.core import GCSFile
@@ -77,26 +67,22 @@ except ImportError:
 
 
 try:
-    from torchgeo.datasets.utils import disambiguate_timestamp
+    from rioxarray.exceptions import NoDataInBounds
+    from rioxarray.merge import merge_arrays
+    from rioxarray.rioxarray import _generate_spatial_coords
 except ImportError:
-
-    class torch:
-        """Placeholder."""
-
-        class Tensor:
-            """Placeholder to reference torch.Tensor."""
-
-
+    pass
 try:
-    from torchgeo.datasets.utils import BoundingBox
+    import xarray as xr
+    from xarray import DataArray
+    from xarray import Dataset
 except ImportError:
 
-    class BoundingBox:
+    class DataArray:
         """Placeholder."""
 
-        def __init__(self, *args, **kwargs) -> None:
-            """Placeholder."""
-            raise ImportError("missing optional dependency 'torchgeo'")
+    class Dataset:
+        """Placeholder."""
 
 
 from ..geopandas_tools.bounds import get_total_bounds
@@ -115,6 +101,12 @@ from .base import _get_shape_from_bounds
 from .base import _get_transform_from_bounds
 from .base import get_index_mapper
 from .indices import ndvi
+from .regex import _any_regex_matches
+from .regex import _extract_regex_match_from_string
+from .regex import _get_first_group_match
+from .regex import _get_non_optional_groups
+from .regex import _get_regexes_matches_for_df
+from .regex import _RegexError
 from .zonal import _aggregate
 from .zonal import _make_geometry_iterrows
 from .zonal import _no_overlap_df
@@ -132,9 +124,6 @@ if is_dapla():
     def _open_func(*args, **kwargs) -> GCSFile:
         return dp.FileClient.get_gcs_file_system().open(*args, **kwargs)
 
-    def _rm_file_func(*args, **kwargs) -> None:
-        return dp.FileClient.get_gcs_file_system().rm_file(*args, **kwargs)
-
     def _read_parquet_func(*args, **kwargs) -> list[str]:
         return dp.read_pandas(*args, **kwargs)
 
@@ -142,22 +131,25 @@ else:
     _ls_func = functools.partial(get_all_files, recursive=False)
     _open_func = open
     _glob_func = glob.glob
-    _rm_file_func = os.remove
     _read_parquet_func = pd.read_parquet
 
-TORCHGEO_RETURN_TYPE = dict[str, torch.Tensor | pyproj.CRS | BoundingBox]
+DATE_RANGES_TYPE = (
+    tuple[str | pd.Timestamp | None, str | pd.Timestamp | None]
+    | tuple[tuple[str | pd.Timestamp | None, str | pd.Timestamp | None], ...]
+)
+
 FILENAME_COL_SUFFIX = "_filename"
+
 DEFAULT_FILENAME_REGEX = r"""
     .*?
-    (?:_(?P<date>\d{8}(?:T\d{6})?))?  # Optional date group
+    (?:_?(?P<date>\d{8}(?:T\d{6})?))?  # Optional underscore and date group
     .*?
-    (?:_(?P<band>B\d{1,2}A|B\d{1,2}))?  # Optional band group
+    (?:_?(?P<band>B\d{1,2}A|B\d{1,2}))?  # Optional underscore and band group
     \.(?:tif|tiff|jp2)$  # End with .tif, .tiff, or .jp2
 """
 DEFAULT_IMAGE_REGEX = r"""
     .*?
-    (?:_(?P<date>\d{8}(?:T\d{6})?))?  # Optional date group
-    (?:_(?P<band>B\d{1,2}A|B\d{1,2}))?  # Optional band group
+    (?:_?(?P<date>\d{8}(?:T\d{6})?))?  # Optional underscore and date group
 """
 
 ALLOWED_INIT_KWARGS = [
@@ -165,13 +157,12 @@ ALLOWED_INIT_KWARGS = [
     "band_class",
     "image_regexes",
     "filename_regexes",
-    "date_format",
-    "cloud_cover_regexes",
     "bounds_regexes",
     "all_bands",
     "crs",
     "masking",
     "_merged",
+    "_add_metadata_attributes",
 ]
 
 
@@ -293,9 +284,38 @@ class ImageCollectionGroupBy:
         return f"{self.__class__.__name__}({len(self)})"
 
 
+def standardize_band_id(x: str) -> str:
+    return x.replace("B", "").replace("A", "").zfill(2)
+
+
+class BandIdDict(dict):
+    """Dict that tells the band initialiser to get the dict value of the band_id."""
+
+    def __init__(self, data: dict | None = None, **kwargs) -> None:
+        """Add dicts or kwargs."""
+        self._standardized_keys = {}
+        for key, value in ((data or {}) | kwargs).items():
+            setattr(self, key, value)
+            self._standardized_keys[standardize_band_id(key)] = value
+
+    def __len__(self) -> int:
+        """Number of items."""
+        return len({key for key in self.__dict__ if key != "_standardized_keys"})
+
+    def __getitem__(self, item: str) -> Any:
+        """Get dict value from key."""
+        try:
+            return getattr(self, item)
+        except AttributeError as e:
+            try:
+                return self._standardized_keys[standardize_band_id(item)]
+            except KeyError:
+                raise KeyError(item, self.__dict__) from e
+
+
 @dataclass(frozen=True)
 class BandMasking:
-    """Basically a frozen dict with forced keys."""
+    """Frozen dict with forced keys."""
 
     band_id: str
     values: tuple[int]
@@ -305,19 +325,27 @@ class BandMasking:
         return getattr(self, item)
 
 
+class NoLevel:
+    """Equivelant to None."""
+
+
 class _ImageBase:
     image_regexes: ClassVar[str | None] = (DEFAULT_IMAGE_REGEX,)
     filename_regexes: ClassVar[str | tuple[str]] = (DEFAULT_FILENAME_REGEX,)
-    date_format: ClassVar[str] = "%Y%m%d"  # T%H%M%S"
+    metadata_attributes: ClassVar[dict | None] = None
     masking: ClassVar[BandMasking | None] = None
 
-    def __init__(self, **kwargs) -> None:
+    def __init__(self, *, bbox=None, **kwargs) -> None:
 
         self._mask = None
         self._bounds = None
         self._merged = False
         self._from_array = False
         self._from_gdf = False
+        self.metadata_attributes = self.metadata_attributes or {}
+        self._path = None
+
+        self._bbox = to_bbox(bbox) if bbox is not None else None
 
         if self.filename_regexes:
             if isinstance(self.filename_regexes, str):
@@ -381,7 +409,6 @@ class _ImageBase:
         for pat in patterns:
             try:
                 return _get_first_group_match(pat, self.name)[group]
-                return re.match(pat, self.name).group(group)
             except (TypeError, KeyError):
                 pass
         if not any(group in _get_non_optional_groups(pat) for pat in patterns):
@@ -394,18 +421,18 @@ class _ImageBase:
         """Create a dataframe with file paths and image paths that match regexes."""
         df = pd.DataFrame({"file_path": file_paths})
 
-        df["filename"] = df["file_path"].apply(lambda x: _fix_path(Path(x).name))
+        df["file_path"] = df["file_path"].apply(_fix_path)
+        df["filename"] = df["file_path"].apply(lambda x: Path(x).name)
 
-        if not self.single_banded:
-            df["image_path"] = df["file_path"].apply(
-                lambda x: _fix_path(str(Path(x).parent))
-            )
-        else:
-            df["image_path"] = df["file_path"]
+        df["image_path"] = df["file_path"].apply(
+            lambda x: _fix_path(str(Path(x).parent))
+        )
 
         if not len(df):
             return df
 
+        df = df[~df["file_path"].isin(df["image_path"])]
+
         if self.filename_patterns:
             df = _get_regexes_matches_for_df(df, "filename", self.filename_patterns)
 
@@ -446,8 +473,19 @@ class _ImageBase:
                 continue
         return copied
 
+    def equals(self, other) -> bool:
+        for key, value in self.__dict__.items():
+            if key.startswith("_"):
+                continue
+            if value != getattr(other, key):
+                print(key, value, getattr(other, key))
+                return False
+        return True
+
 
 class _ImageBandBase(_ImageBase):
+    """Common parent class of Image and Band."""
+
     def intersects(self, other: GeoDataFrame | GeoSeries | Geometry) -> bool:
         if hasattr(other, "crs") and not pyproj.CRS(self.crs).equals(
             pyproj.CRS(other.crs)
@@ -455,6 +493,12 @@ class _ImageBandBase(_ImageBase):
             raise ValueError(f"crs mismatch: {self.crs} and {other.crs}")
         return self.union_all().intersects(to_shapely(other))
 
+    def union_all(self) -> Polygon:
+        try:
+            return box(*self.bounds)
+        except TypeError:
+            return Polygon()
+
     @property
     def mask_percentage(self) -> float:
         return self.mask.values.sum() / (self.mask.width * self.mask.height) * 100
@@ -495,31 +539,57 @@ class _ImageBandBase(_ImageBase):
     def level(self) -> str:
         return self._name_regex_searcher("level", self.image_patterns)
 
-    @property
-    def mint(self) -> float:
-        return disambiguate_timestamp(self.date, self.date_format)[0]
+    def _add_metadata_attributes(self):
 
-    @property
-    def maxt(self) -> float:
-        return disambiguate_timestamp(self.date, self.date_format)[1]
+        missing_attributes = {}
+        for key, value in self.metadata_attributes.items():
+            if getattr(self, key) is None:
+                missing_attributes[key] = value
 
-    def union_all(self) -> Polygon:
-        try:
-            return box(*self.bounds)
-        except TypeError:
-            return Polygon()
+        if not missing_attributes:
+            return
 
-    @property
-    def torch_bbox(self) -> BoundingBox:
-        bounds = GeoSeries([self.union_all()]).bounds
-        return BoundingBox(
-            minx=bounds.minx[0],
-            miny=bounds.miny[0],
-            maxx=bounds.maxx[0],
-            maxy=bounds.maxy[0],
-            mint=self.mint,
-            maxt=self.maxt,
-        )
+        file_contents: list[str] = []
+        for path in self._all_file_paths:
+            if ".xml" not in path:
+                continue
+            with _open_func(path, "rb") as file:
+                file_contents.append(file.read().decode("utf-8"))
+
+        for key, value in missing_attributes.items():
+            results = None
+            for i, filetext in enumerate(file_contents):
+                if isinstance(value, str) and value in dir(self):
+                    method = getattr(self, value)
+                    try:
+                        results = method(filetext)
+                    except _RegexError as e:
+                        if i == len(self._all_file_paths) - 1:
+                            raise e
+                        continue
+                    if results is not None:
+                        break
+
+                if callable(value):
+                    try:
+                        results = value(filetext)
+                    except _RegexError as e:
+                        if i == len(self._all_file_paths) - 1:
+                            raise e
+                        continue
+                    if results is not None:
+                        break
+
+                try:
+                    results = _extract_regex_match_from_string(filetext, value)
+                except _RegexError as e:
+                    if i == len(self._all_file_paths) - 1:
+                        raise e
+
+            if isinstance(results, BandIdDict) and isinstance(self, Band):
+                results = results[self.band_id]
+
+            setattr(self, key, results)
 
 
 class Band(_ImageBandBase):
@@ -561,28 +631,36 @@ class Band(_ImageBandBase):
         res: int | None,
         crs: Any | None = None,
         bounds: tuple[float, float, float, float] | None = None,
-        cmap: str | None = None,
-        name: str | None = None,
+        nodata: int | None = None,
+        mask: "Band | None" = None,
         file_system: GCSFileSystem | None = None,
-        band_id: str | None = None,
         processes: int = 1,
-        bbox: GeoDataFrame | GeoSeries | Geometry | tuple[float] | None = None,
-        mask: "Band | None" = None,
-        nodata: int | None = None,
+        name: str | None = None,
+        band_id: str | None = None,
+        cmap: str | None = None,
+        all_file_paths: list[str] | None = None,
         **kwargs,
     ) -> None:
         """Band initialiser."""
         super().__init__(**kwargs)
 
+        if isinstance(data, (str | Path | os.PathLike)) and any(
+            arg is not None for arg in [crs, bounds]
+        ):
+            raise ValueError("Can only specify 'bounds' and 'crs' if data is an array.")
+
         self._mask = mask
-        self._bbox = to_bbox(bbox) if bbox is not None else None
         self._values = None
-        self._crs = None
         self.nodata = nodata
-
+        self._crs = crs
         bounds = to_bbox(bounds) if bounds is not None else None
-
         self._bounds = bounds
+        self._all_file_paths = all_file_paths
+
+        self._image = None
+
+        for key in self.metadata_attributes:
+            setattr(self, key, None)
 
         if isinstance(data, np.ndarray):
             self.values = data
@@ -610,19 +688,34 @@ class Band(_ImageBandBase):
         self._band_id = band_id
         self.processes = processes
 
-        # if self.filename_regexes:
-        #     if isinstance(self.filename_regexes, str):
-        #         self.filename_regexes = [self.filename_regexes]
-        #     self.filename_patterns = [
-        #         re.compile(pat, flags=re.VERBOSE) for pat in self.filename_regexes
-        #     ]
-        # else:
-        #     self.filename_patterns = None
+        if (
+            kwargs.get("_add_metadata_attributes", True)
+            and self.metadata_attributes
+            and self.path is not None
+        ):
+            if self._all_file_paths is None:
+                self._all_file_paths = _get_all_file_paths(str(Path(self.path).parent))
+            self._add_metadata_attributes()
 
     def __lt__(self, other: "Band") -> bool:
         """Makes Bands sortable by band_id."""
         return self.band_id < other.band_id
 
+    # def __getattribute__(self, attr: str) -> Any:
+    #     # try:
+    #     #     value =
+    #     # except AttributeError:
+    #     #     value = None
+
+    #     if (
+    #         attr in (super().__getattribute__("metadata_attributes") or {})
+    #         and super().__getattribute__(attr) is None
+    #     ):
+    #         if self._all_file_paths is None:
+    #             self._all_file_paths = _get_all_file_paths(str(Path(self.path).parent))
+    #         self._add_metadata_attributes()
+    #     return super().__getattribute__(attr)
+
     @property
     def values(self) -> np.ndarray:
         """The numpy array, if loaded."""
@@ -688,24 +781,22 @@ class Band(_ImageBandBase):
     @property
     def crs(self) -> str | None:
         """Coordinate reference system."""
-        if self._crs is not None:
-            return self._crs
-        with opener(self.path, file_system=self.file_system) as file:
-            with rasterio.open(file) as src:
-                # self._bounds = to_bbox(src.bounds)
-                self._crs = src.crs
+        if self._crs is None:
+            self._add_crs_and_bounds()
         return self._crs
 
     @property
     def bounds(self) -> tuple[int, int, int, int] | None:
         """Bounds as tuple (minx, miny, maxx, maxy)."""
-        if self._bounds is not None:
-            return self._bounds
+        if self._bounds is None:
+            self._add_crs_and_bounds()
+        return self._bounds
+
+    def _add_crs_and_bounds(self) -> None:
         with opener(self.path, file_system=self.file_system) as file:
             with rasterio.open(file) as src:
                 self._bounds = to_bbox(src.bounds)
                 self._crs = src.crs
-        return self._bounds
 
     def get_n_largest(
         self, n: int, precision: float = 0.000001, column: str = "value"
@@ -745,44 +836,29 @@ class Band(_ImageBandBase):
 
         bounds_was_none = bounds is None
 
-        try:
-            if not isinstance(self.values, np.ndarray):
-                raise ValueError()
-            has_array = True
-        except ValueError:  # also catches ArrayNotLoadedError
-            has_array = False
-
-        # get common bounds of function argument 'bounds' and previously set bbox
-        if bounds is None and self._bbox is None:
-            bounds = None
-        elif bounds is not None and self._bbox is None:
-            bounds = to_shapely(bounds).intersection(self.union_all())
-        elif bounds is None and self._bbox is not None:
-            bounds = to_shapely(self._bbox).intersection(self.union_all())
-        else:
-            bounds = to_shapely(bounds).intersection(to_shapely(self._bbox))
+        bounds = _get_bounds(bounds, self._bbox)
 
         should_return_empty: bool = bounds is not None and bounds.area == 0
         if should_return_empty:
             self._values = np.array([])
             if self.mask is not None and not self.is_mask:
                 self._mask = self._mask.load()
-            # self._mask = np.ma.array([], [])
             self._bounds = None
             self.transform = None
+            try:
+                self._image._mask = self._mask
+            except AttributeError:
+                pass
             return self
 
-        if has_array and bounds_was_none:
+        if self.has_array and bounds_was_none:
             return self
 
         # round down/up to integer to avoid precision trouble
         if bounds is not None:
-            #     bounds = to_bbox(bounds)
             minx, miny, maxx, maxy = to_bbox(bounds)
             bounds = (int(minx), int(miny), math.ceil(maxx), math.ceil(maxy))
 
-        boundless = False
-
         if indexes is None:
             indexes = 1
 
@@ -792,7 +868,7 @@ class Band(_ImageBandBase):
         # allow setting a fixed out_shape for the array, in order to make mask same shape as values
         out_shape = kwargs.pop("out_shape", None)
 
-        if has_array:
+        if self.has_array:
             self.values = _clip_loaded_array(
                 self.values, bounds, self.transform, self.crs, out_shape, **kwargs
             )
@@ -849,7 +925,7 @@ class Band(_ImageBandBase):
                         self._values = src.read(
                             indexes=indexes,
                             window=window,
-                            boundless=boundless,
+                            boundless=False,
                             out_shape=out_shape,
                             masked=masked,
                             **kwargs,
@@ -884,13 +960,15 @@ class Band(_ImageBandBase):
             )
             mask_arr = self.mask.values
 
-            # if self.masking:
-            #     mask_arr = np.isin(mask_arr, self.masking["values"])
-
             self._values = np.ma.array(
                 self._values, mask=mask_arr, fill_value=self.nodata
             )
 
+        try:
+            self._image._mask = self._mask
+        except AttributeError:
+            pass
+
         return self
 
     @property
@@ -898,6 +976,16 @@ class Band(_ImageBandBase):
         """True if the band_id is equal to the masking band_id."""
         return self.band_id == self.masking["band_id"]
 
+    @property
+    def has_array(self) -> bool:
+        """Whether the array is loaded."""
+        try:
+            if not isinstance(self.values, np.ndarray):
+                raise ValueError()
+            return True
+        except ValueError:  # also catches ArrayNotLoadedError
+            return False
+
     def write(
         self, path: str | Path, driver: str = "GTiff", compress: str = "LZW", **kwargs
     ) -> None:
@@ -1154,131 +1242,6 @@ class NDVIBand(Band):
     #     return get_cmap(arr)
 
 
-def get_cmap(arr: np.ndarray) -> LinearSegmentedColormap:
-
-    # blue = [[i / 10 + 0.1, i / 10 + 0.1, 1 - (i / 10) + 0.1] for i in range(11)][1:]
-    blue = [
-        [0.1, 0.1, 1.0],
-        [0.2, 0.2, 0.9],
-        [0.3, 0.3, 0.8],
-        [0.4, 0.4, 0.7],
-        [0.6, 0.6, 0.6],
-        [0.6, 0.6, 0.6],
-        [0.7, 0.7, 0.7],
-        [0.8, 0.8, 0.8],
-    ]
-    # gray = list(reversed([[i / 10 - 0.1, i / 10, i / 10 - 0.1] for i in range(11)][1:]))
-    gray = [
-        [0.6, 0.6, 0.6],
-        [0.6, 0.6, 0.6],
-        [0.6, 0.6, 0.6],
-        [0.6, 0.6, 0.6],
-        [0.6, 0.6, 0.6],
-        [0.4, 0.7, 0.4],
-        [0.3, 0.7, 0.3],
-        [0.2, 0.8, 0.2],
-    ]
-    # gray = [[0.6, 0.6, 0.6] for i in range(10)]
-    # green = [[0.2 + i/20, i / 10 - 0.1, + i/20] for i in range(11)][1:]
-    green = [
-        [0.25, 0.0, 0.05],
-        [0.3, 0.1, 0.1],
-        [0.35, 0.2, 0.15],
-        [0.4, 0.3, 0.2],
-        [0.45, 0.4, 0.25],
-        [0.5, 0.5, 0.3],
-        [0.55, 0.6, 0.35],
-        [0.7, 0.9, 0.5],
-    ]
-    green = [
-        [0.6, 0.6, 0.6],
-        [0.4, 0.7, 0.4],
-        [0.3, 0.8, 0.3],
-        [0.25, 0.4, 0.25],
-        [0.2, 0.5, 0.2],
-        [0.10, 0.7, 0.10],
-        [0, 0.9, 0],
-    ]
-
-    def get_start(arr):
-        min_value = np.min(arr)
-        if min_value < -0.75:
-            return 0
-        if min_value < -0.5:
-            return 1
-        if min_value < -0.25:
-            return 2
-        if min_value < 0:
-            return 3
-        if min_value < 0.25:
-            return 4
-        if min_value < 0.5:
-            return 5
-        if min_value < 0.75:
-            return 6
-        return 7
-
-    def get_stop(arr):
-        max_value = np.max(arr)
-        if max_value <= 0.05:
-            return 0
-        if max_value < 0.175:
-            return 1
-        if max_value < 0.25:
-            return 2
-        if max_value < 0.375:
-            return 3
-        if max_value < 0.5:
-            return 4
-        if max_value < 0.75:
-            return 5
-        return 6
-
-    cmap_name = "blue_gray_green"
-
-    start = get_start(arr)
-    stop = get_stop(arr)
-    blue = blue[start]
-    gray = gray[start]
-    # green = green[start]
-    green = green[stop]
-
-    # green[0] = np.arange(0, 1, 0.1)[::-1][stop]
-    # green[1] = np.arange(0, 1, 0.1)[stop]
-    # green[2] = np.arange(0, 1, 0.1)[::-1][stop]
-
-    print(green)
-    print(start, stop)
-    print("blue gray green")
-    print(blue)
-    print(gray)
-    print(green)
-
-    # Define the segments of the colormap
-    cdict = {
-        "red": [
-            (0.0, blue[0], blue[0]),
-            (0.3, gray[0], gray[0]),
-            (0.7, gray[0], gray[0]),
-            (1.0, green[0], green[0]),
-        ],
-        "green": [
-            (0.0, blue[1], blue[1]),
-            (0.3, gray[1], gray[1]),
-            (0.7, gray[1], gray[1]),
-            (1.0, green[1], green[1]),
-        ],
-        "blue": [
-            (0.0, blue[2], blue[2]),
-            (0.3, gray[2], gray[2]),
-            (0.7, gray[2], gray[2]),
-            (1.0, green[2], green[2]),
-        ],
-    }
-
-    return LinearSegmentedColormap(cmap_name, segmentdata=cdict, N=50)
-
-
 def median_as_int_and_minimum_dtype(arr: np.ndarray) -> np.ndarray:
     arr = np.median(arr, axis=0).astype(int)
     min_dtype = rasterio.dtypes.get_minimum_dtype(arr)
@@ -1288,21 +1251,17 @@ def median_as_int_and_minimum_dtype(arr: np.ndarray) -> np.ndarray:
 class Image(_ImageBandBase):
     """Image consisting of one or more Bands."""
 
-    cloud_cover_regexes: ClassVar[tuple[str] | None] = None
     band_class: ClassVar[Band] = Band
 
     def __init__(
         self,
         data: str | Path | Sequence[Band],
         res: int | None = None,
-        crs: Any | None = None,
-        single_banded: bool = False,
         file_system: GCSFileSystem | None = None,
-        df: pd.DataFrame | None = None,
-        all_file_paths: list[str] | None = None,
         processes: int = 1,
-        bbox: GeoDataFrame | GeoSeries | Geometry | tuple | None = None,
+        df: pd.DataFrame | None = None,
         nodata: int | None = None,
+        all_file_paths: list[str] | None = None,
         **kwargs,
     ) -> None:
         """Image initialiser."""
@@ -1310,18 +1269,14 @@ class Image(_ImageBandBase):
 
         self.nodata = nodata
         self._res = res
-        self._crs = crs
+        self._crs = None
         self.file_system = file_system
-        self._bbox = to_bbox(bbox) if bbox is not None else None
-        # self._mask = _mask
-        self.single_banded = single_banded
         self.processes = processes
-        self._all_file_paths = all_file_paths
 
         if hasattr(data, "__iter__") and all(isinstance(x, Band) for x in data):
             self._bands = list(data)
             if res is None:
-                res = list({band.res for band in self._bands})
+                res = list({band.res for band in self.bands})
                 if len(res) == 1:
                     self._res = res[0]
                 else:
@@ -1334,25 +1289,23 @@ class Image(_ImageBandBase):
             raise TypeError("'data' must be string, Path-like or a sequence of Band.")
 
         self._bands = None
-        self._path = str(data)
+        self._path = _fix_path(data)  # str(data).rstrip("/").rstrip(r"\"")
+
+        if all_file_paths is None and self.path:
+            self._all_file_paths = _get_all_file_paths(self.path)
+        elif self.path:
+            self._all_file_paths = [
+                x for x in all_file_paths if self.path in _fix_path(x)
+            ]
+        else:
+            self._all_file_paths = None
 
         if df is None:
-            if is_dapla():
-                file_paths = list(sorted(set(_glob_func(self.path + "/**"))))
-            else:
-                file_paths = list(
-                    sorted(
-                        set(
-                            _glob_func(self.path + "/**/**")
-                            + _glob_func(self.path + "/**/**/**")
-                            + _glob_func(self.path + "/**/**/**/**")
-                            + _glob_func(self.path + "/**/**/**/**/**")
-                        )
-                    )
-                )
-            if not file_paths:
-                file_paths = [self.path]
-            df = self._create_metadata_df(file_paths)
+            # file_paths = _get_all_file_paths(self.path)
+
+            if not self._all_file_paths:
+                self._all_file_paths = [self.path]
+            df = self._create_metadata_df(self._all_file_paths)
 
         df["image_path"] = df["image_path"].astype(str)
 
@@ -1368,27 +1321,24 @@ class Image(_ImageBandBase):
                 df = df.explode(col)
             df = df.loc[lambda x: ~x["filename"].duplicated()].reset_index(drop=True)
 
-        df = df.loc[lambda x: x["image_path"].str.contains(_fix_path(self.path))]
-
-        if self.cloud_cover_regexes:
-            if all_file_paths is None:
-                file_paths = _ls_func(self.path)
-            else:
-                file_paths = [path for path in all_file_paths if self.name in path]
-            self.cloud_coverage_percentage = float(
-                _get_regex_match_from_xml_in_local_dir(
-                    file_paths, regexes=self.cloud_cover_regexes
-                )
-            )
-        else:
-            self.cloud_coverage_percentage = None
+        df = df.loc[lambda x: x["image_path"] == _fix_path(self.path)]
 
         self._df = df
 
+        for key in self.metadata_attributes:
+            setattr(self, key, None)
+
+        if self.metadata_attributes:
+            self._add_metadata_attributes()
+
     @property
     def values(self) -> np.ndarray:
         """3 dimensional numpy array."""
-        return np.array([band.values for band in self])
+        values = [band.values for band in self]
+        if self.mask is not None:
+            mask = [band.mask.values for band in self]
+            return np.ma.array(values, mask=mask, fill_value=self.nodata)
+        return np.array(values)
 
     def ndvi(self, red_band: str, nir_band: str, copy: bool = True) -> NDVIBand:
         """Calculate the NDVI for the Image."""
@@ -1398,13 +1348,6 @@ class Image(_ImageBandBase):
 
         arr: np.ndarray | np.ma.core.MaskedArray = ndvi(red.values, nir.values)
 
-        # if self.nodata is not None and not np.isnan(self.nodata):
-        #     try:
-        #         arr.data[arr.mask] = self.nodata
-        #         arr = arr.copy()
-        #     except AttributeError:
-        #         pass
-
         return NDVIBand(
             arr,
             bounds=red.bounds,
@@ -1445,10 +1388,30 @@ class Image(_ImageBandBase):
             **self._common_init_kwargs,
         )
 
+    def to_xarray(self) -> DataArray:
+        """Convert the raster to  an xarray.DataArray."""
+        name = self.name or self.__class__.__name__.lower()
+        coords = _generate_spatial_coords(
+            self[0].transform, self[0].width, self[0].height
+        )
+        dims = ["band", "y", "x"]
+        return xr.DataArray(
+            self.values,
+            coords=coords,
+            dims=dims,
+            name=name,
+            attrs={"crs": self.crs},
+        )
+
     @property
     def mask(self) -> Band | None:
         """Mask Band."""
         if self._mask is not None:
+            # if not self._mask.has_array:
+            #     try:
+            #         self._mask.values = self[0]._mask.values
+            #     except Exception:
+            #         pass
             return self._mask
         if self.masking is None:
             return None
@@ -1465,6 +1428,7 @@ class Image(_ImageBandBase):
             )
         self._mask = self.band_class(
             mask_paths[0],
+            _add_metadata_attributes=False,
             **self._common_init_kwargs,
         )
 
@@ -1506,34 +1470,11 @@ class Image(_ImageBandBase):
         if self._bands is not None:
             return self._bands
 
-        # if self.masking:
-        #     mask_band_id = self.masking["band_id"]
-        #     mask_paths = [
-        #         path for path in self._df["file_path"] if mask_band_id in path
-        #     ]
-        #     if len(mask_paths) > 1:
-        #         raise ValueError(
-        #             f"Multiple file_paths match mask band_id {mask_band_id}"
-        #         )
-        #     elif not mask_paths:
-        #         raise ValueError(f"No file_paths match mask band_id {mask_band_id}")
-        #     arr = (
-        #         self.band_class(
-        #             mask_paths[0],
-        #             # mask=self.mask,
-        #             **self._common_init_kwargs,
-        #         )
-        #         .load()
-        #         .values
-        #     )
-        #     self._mask = np.ma.array(
-        #         arr, mask=np.isin(arr, self.masking["values"]), fill_value=None
-        #     )
-
         self._bands = [
             self.band_class(
                 path,
                 mask=self.mask,
+                _add_metadata_attributes=False,
                 **self._common_init_kwargs,
             )
             for path in (self._df["file_path"])
@@ -1557,11 +1498,7 @@ class Image(_ImageBandBase):
             self._bands = [
                 band
                 for band in self._bands
-                if any(
-                    # _get_first_group_match(pat, band.name)
-                    re.search(pat, band.name)
-                    for pat in self.filename_patterns
-                )
+                if any(re.search(pat, band.name) for pat in self.filename_patterns)
             ]
 
         if self.image_patterns:
@@ -1570,7 +1507,6 @@ class Image(_ImageBandBase):
                 for band in self._bands
                 if any(
                     re.search(pat, Path(band.path).parent.name)
-                    # _get_first_group_match(pat, Path(band.path).parent.name)
                     for pat in self.image_patterns
                 )
             ]
@@ -1578,6 +1514,21 @@ class Image(_ImageBandBase):
         if self._should_be_sorted:
             self._bands = list(sorted(self._bands))
 
+        for key in self.metadata_attributes:
+            for band in self:
+                value = getattr(self, key)
+                if value is None:
+                    continue
+                if isinstance(value, BandIdDict):
+                    try:
+                        value = value[band.band_id]
+                    except KeyError:
+                        continue
+                setattr(band, key, value)
+
+        for band in self:
+            band._image = self
+
         return self._bands
 
     @property
@@ -1621,7 +1572,14 @@ class Image(_ImageBandBase):
     @property
     def bounds(self) -> tuple[int, int, int, int] | None:
         """Bounds of the Image (minx, miny, maxx, maxy)."""
-        return get_total_bounds([band.bounds for band in self])
+        try:
+            return get_total_bounds([band.bounds for band in self])
+        except exceptions.RefreshError:
+            bounds = []
+            for band in self:
+                time.sleep(0.1)
+                bounds.append(band.bounds)
+            return get_total_bounds(bounds)
 
     def to_gdf(self, column: str = "value") -> GeoDataFrame:
         """Convert the array to a GeoDataFrame of grid polygons and values."""
@@ -1647,7 +1605,7 @@ class Image(_ImageBandBase):
     def __getitem__(
         self, band: str | int | Sequence[str] | Sequence[int]
     ) -> "Band | Image":
-        """Get bands by band_id or integer index.
+        """Get bands by band_id or integer index or a sequence of such.
 
         Returns a Band if a string or int is passed,
         returns an Image if a sequence of strings or integers is passed.
@@ -1743,34 +1701,29 @@ class ImageCollection(_ImageBase):
 
     image_class: ClassVar[Image] = Image
     band_class: ClassVar[Band] = Band
+    _metadata_attribute_collection_type: ClassVar[type] = pd.Series
 
     def __init__(
         self,
-        data: str | Path | Sequence[Image],
+        data: str | Path | Sequence[Image] | Sequence[str | Path],
         res: int,
-        level: str | None,
-        crs: Any | None = None,
-        single_banded: bool = False,
+        level: str | None = NoLevel,
         processes: int = 1,
         file_system: GCSFileSystem | None = None,
-        df: pd.DataFrame | None = None,
-        bbox: Any | None = None,
-        nodata: int | None = None,
         metadata: str | dict | pd.DataFrame | None = None,
+        nodata: int | None = None,
         **kwargs,
     ) -> None:
         """Initialiser."""
         super().__init__(**kwargs)
 
         self.nodata = nodata
-        self.level = level
-        self._crs = crs
+        self.level = level if not isinstance(level, NoLevel) else None
         self.processes = processes
         self.file_system = file_system
         self._res = res
-        self._bbox = to_bbox(bbox) if bbox is not None else None
         self._band_ids = None
-        self.single_banded = single_banded
+        self._crs = None  # crs
 
         if metadata is not None:
             if isinstance(metadata, (str | Path | os.PathLike)):
@@ -1780,45 +1733,43 @@ class ImageCollection(_ImageBase):
         else:
             self.metadata = metadata
 
-        if hasattr(data, "__iter__") and all(isinstance(x, Image) for x in data):
+        self._df = None
+        self._all_file_paths = None
+        self._images = None
+
+        if hasattr(data, "__iter__") and not isinstance(data, str):
             self._path = None
-            self.images = [x.copy() for x in data]
-            return
-        else:
-            self._images = None
+            if all(isinstance(x, Image) for x in data):
+                self.images = [x.copy() for x in data]
+                return
+            elif all(isinstance(x, (str | Path | os.PathLike)) for x in data):
+                self._all_file_paths = list(
+                    itertools.chain.from_iterable(
+                        _get_all_file_paths(str(path)) for path in data
+                    )
+                )
+                self._df = self._create_metadata_df([str(x) for x in data])
+                return
 
         if not isinstance(data, (str | Path | os.PathLike)):
             raise TypeError("'data' must be string, Path-like or a sequence of Image.")
 
         self._path = str(data)
 
-        if is_dapla():
-            self._all_file_paths = list(sorted(set(_glob_func(self.path + "/**"))))
-        else:
-            self._all_file_paths = list(
-                sorted(
-                    set(
-                        _glob_func(self.path + "/**/**")
-                        + _glob_func(self.path + "/**/**/**")
-                        + _glob_func(self.path + "/**/**/**/**")
-                        + _glob_func(self.path + "/**/**/**/**/**")
-                    )
-                )
-            )
+        self._all_file_paths = _get_all_file_paths(self.path)
 
         if self.level:
             self._all_file_paths = [
                 path for path in self._all_file_paths if self.level in path
             ]
 
-        if df is not None:
-            self._df = df
-        else:
-            self._df = self._create_metadata_df(self._all_file_paths)
+        self._df = self._create_metadata_df(self._all_file_paths)
 
     @property
     def values(self) -> np.ndarray:
         """4 dimensional numpy array."""
+        if isinstance(self[0].values, np.ma.core.MaskedArray):
+            return np.ma.array([img.values for img in self])
         return np.array([img.values for img in self])
 
     @property
@@ -1826,21 +1777,6 @@ class ImageCollection(_ImageBase):
         """4 dimensional numpy array."""
         return np.array([img.mask.values for img in self])
 
-    # def ndvi(
-    #     self, red_band: str, nir_band: str, copy: bool = True
-    # ) -> "ImageCollection":
-    #     # copied = self.copy() if copy else self
-
-    #     with joblib.Parallel(n_jobs=self.processes, backend="loky") as parallel:
-    #         ndvi_images = parallel(
-    #             joblib.delayed(_img_ndvi)(
-    #                 img, red_band=red_band, nir_band=nir_band, copy=False
-    #             )
-    #             for img in self
-    #         )
-
-    #     return ImageCollection(ndvi_images, single_banded=True)
-
     def groupby(self, by: str | list[str], **kwargs) -> ImageCollectionGroupBy:
         """Group the Collection by Image or Band attribute(s)."""
         df = pd.DataFrame(
@@ -1882,7 +1818,6 @@ class ImageCollection(_ImageBase):
         copied.images = [
             self.image_class(
                 [band],
-                single_banded=True,
                 masking=self.masking,
                 band_class=self.band_class,
                 **self._common_init_kwargs,
@@ -1892,6 +1827,60 @@ class ImageCollection(_ImageBase):
             for img in self
             for band in img
         ]
+        for img in copied:
+            assert len(img) == 1
+            try:
+                img._path = img[0].path
+            except PathlessImageError:
+                pass
+        return copied
+
+    def apply(self, func: Callable, **kwargs) -> "ImageCollection":
+        """Apply a function to all bands in each image of the collection."""
+        for img in self:
+            img._bands = [func(band, **kwargs) for band in img]
+        return self
+
+    def get_unique_band_ids(self) -> list[str]:
+        """Get a list of unique band_ids across all images."""
+        return list({band.band_id for img in self for band in img})
+
+    def filter(
+        self,
+        bands: str | list[str] | None = None,
+        date_ranges: DATE_RANGES_TYPE = None,
+        bbox: GeoDataFrame | GeoSeries | Geometry | tuple[float] | None = None,
+        intersects: GeoDataFrame | GeoSeries | Geometry | tuple[float] | None = None,
+        max_cloud_coverage: int | None = None,
+        copy: bool = True,
+    ) -> "ImageCollection":
+        """Filter images and bands in the collection."""
+        copied = self.copy() if copy else self
+
+        if date_ranges:
+            copied = copied._filter_dates(date_ranges)
+
+        if max_cloud_coverage is not None:
+            copied.images = [
+                image
+                for image in copied.images
+                if image.cloud_coverage_percentage < max_cloud_coverage
+            ]
+
+        if bbox is not None:
+            copied = copied._filter_bounds(bbox)
+            copied._set_bbox(bbox)
+
+        if intersects is not None:
+            copied = copied._filter_bounds(intersects)
+
+        if bands is not None:
+            if isinstance(bands, str):
+                bands = [bands]
+            bands = set(bands)
+            copied._band_ids = bands
+            copied.images = [img[bands] for img in copied.images if bands in img]
+
         return copied
 
     def merge(
@@ -1903,7 +1892,10 @@ class ImageCollection(_ImageBase):
         **kwargs,
     ) -> Band:
         """Merge all areas and all bands to a single Band."""
-        bounds = to_bbox(bounds) if bounds is not None else self._bbox
+        bounds = _get_bounds(bounds, self._bbox)
+        if bounds is not None:
+            bounds = to_bbox(bounds)
+
         crs = self.crs
 
         if indexes is None:
@@ -1971,7 +1963,9 @@ class ImageCollection(_ImageBase):
         **kwargs,
     ) -> Image:
         """Merge all areas to a single tile, one band per band_id."""
-        bounds = to_bbox(bounds) if bounds is not None else self._bbox
+        bounds = _get_bounds(bounds, self._bbox)
+        if bounds is not None:
+            bounds = to_bbox(bounds)
         bounds = self.bounds if bounds is None else bounds
         out_bounds = bounds
         crs = self.crs
@@ -2027,11 +2021,12 @@ class ImageCollection(_ImageBase):
                     bounds=out_bounds,
                     crs=crs,
                     band_id=band_id,
+                    _add_metadata_attributes=False,
                     **self._common_init_kwargs,
                 )
             )
 
-        # return self.image_class(
+        # return self.image_class( # TODO
         image = Image(
             bands,
             band_class=self.band_class,
@@ -2129,14 +2124,13 @@ class ImageCollection(_ImageBase):
         **kwargs,
     ) -> "ImageCollection":
         """Load all image Bands with threading."""
+        if (
+            bounds is None
+            and indexes is None
+            and all(band.has_array for img in self for band in img)
+        ):
+            return self
         with joblib.Parallel(n_jobs=self.processes, backend="threading") as parallel:
-            if self.masking:
-                parallel(
-                    joblib.delayed(_load_band)(
-                        img.mask, bounds=bounds, indexes=indexes, **kwargs
-                    )
-                    for img in self
-                )
             parallel(
                 joblib.delayed(_load_band)(
                     band, bounds=bounds, indexes=indexes, **kwargs
@@ -2147,7 +2141,7 @@ class ImageCollection(_ImageBase):
 
         return self
 
-    def set_bbox(
+    def _set_bbox(
         self, bbox: GeoDataFrame | GeoSeries | Geometry | tuple[float]
     ) -> "ImageCollection":
         """Set the mask to be used to clip the images to."""
@@ -2156,86 +2150,18 @@ class ImageCollection(_ImageBase):
         if self._images is not None:
             for img in self._images:
                 img._bbox = self._bbox
-                if img._bands is not None:
-                    for band in img:
-                        band._bbox = self._bbox
-                        bounds = box(*band._bbox).intersection(box(*band.bounds))
-                        band._bounds = to_bbox(bounds) if not bounds.is_empty else None
-
-        return self
+                if img.bands is None:
+                    continue
+                for band in img:
+                    band._bbox = self._bbox
+                    bounds = box(*band._bbox).intersection(box(*band.bounds))
+                    band._bounds = to_bbox(bounds) if not bounds.is_empty else None
 
-    def apply(self, func: Callable, **kwargs) -> "ImageCollection":
-        """Apply a function to all bands in each image of the collection."""
-        for img in self:
-            img.bands = [func(band, **kwargs) for band in img]
         return self
 
-    def filter(
-        self,
-        bands: str | list[str] | None = None,
-        exclude_bands: str | list[str] | None = None,
-        date_ranges: (
-            tuple[str | None, str | None]
-            | tuple[tuple[str | None, str | None], ...]
-            | None
-        ) = None,
-        bbox: GeoDataFrame | GeoSeries | Geometry | tuple[float] | None = None,
-        intersects: GeoDataFrame | GeoSeries | Geometry | tuple[float] | None = None,
-        max_cloud_coverage: int | None = None,
-        copy: bool = True,
-    ) -> "ImageCollection":
-        """Filter images and bands in the collection."""
-        copied = self.copy() if copy else self
-
-        if isinstance(bbox, BoundingBox):
-            date_ranges = (bbox.mint, bbox.maxt)
-
-        if date_ranges:
-            copied = copied._filter_dates(date_ranges)
-
-        if max_cloud_coverage is not None:
-            copied.images = [
-                image
-                for image in copied.images
-                if image.cloud_coverage_percentage < max_cloud_coverage
-            ]
-
-        if bbox is not None:
-            copied = copied._filter_bounds(bbox)
-            copied.set_bbox(bbox)
-
-        if intersects is not None:
-            copied = copied._filter_bounds(intersects)
-
-        if bands is not None:
-            if isinstance(bands, str):
-                bands = [bands]
-            bands = set(bands)
-            copied._band_ids = bands
-            copied.images = [img[bands] for img in copied.images if bands in img]
-
-        if exclude_bands is not None:
-            if isinstance(exclude_bands, str):
-                exclude_bands = {exclude_bands}
-            else:
-                exclude_bands = set(exclude_bands)
-            include_bands: list[list[str]] = [
-                [band_id for band_id in img.band_ids if band_id not in exclude_bands]
-                for img in copied
-            ]
-            copied.images = [
-                img[bands]
-                for img, bands in zip(copied.images, include_bands, strict=False)
-                if bands
-            ]
-
-        return copied
-
     def _filter_dates(
         self,
-        date_ranges: (
-            tuple[str | None, str | None] | tuple[tuple[str | None, str | None], ...]
-        ),
+        date_ranges: DATE_RANGES_TYPE = None,
     ) -> "ImageCollection":
         if not isinstance(date_ranges, (tuple, list)):
             raise TypeError(
@@ -2247,13 +2173,7 @@ class ImageCollection(_ImageBase):
                 "Cannot set date_ranges when the class's image_regexes attribute is None"
             )
 
-        self.images = [
-            img
-            for img in self
-            if _date_is_within(
-                img.path, date_ranges, self.image_patterns, self.date_format
-            )
-        ]
+        self.images = [img for img in self if _date_is_within(img.date, date_ranges)]
         return self
 
     def _filter_bounds(
@@ -2277,6 +2197,38 @@ class ImageCollection(_ImageBase):
         ]
         return self
 
+    def to_xarray(self, **kwargs) -> DataArray:
+        """Convert the raster to  an xarray.DataArray."""
+        # arrs = []
+        # for img in self:
+        #     for band in img:
+        #         arr = band.load(**kwargs).values
+        #         arrs.append(arr)
+
+        # n_images = len(self)
+        # n_bands = len(img)
+        # height, width = arr.shape
+
+        # arr_4d = np.array(arrs).reshape(n_images, n_bands, height, width)
+
+        try:
+            name = Path(self.path).stem
+        except TypeError:
+            name = self.__class__.__name__.lower()
+
+        first_band = self[0][0]
+        coords = _generate_spatial_coords(
+            first_band.transform, first_band.width, first_band.height
+        )
+        dims = ["image", "band", "y", "x"]
+        return xr.DataArray(
+            self.values,
+            coords=coords,
+            dims=dims,
+            name=name,
+            attrs={"crs": self.crs},
+        )
+
     def to_gdfs(self, column: str = "value") -> dict[str, GeoDataFrame]:
         """Convert each band in each Image to a GeoDataFrame."""
         out = {}
@@ -2289,12 +2241,10 @@ class ImageCollection(_ImageBase):
                 except AttributeError:
                     name = f"{self.__class__.__name__}({i})"
 
-                band.load()
+                # band.load()
 
                 if name not in out:
                     out[name] = band.to_gdf(column=column)
-                else:
-                    out[name] = f"{self.__class__.__name__}({i})"
         return out
 
     def sample(self, n: int = 1, size: int = 500) -> "ImageCollection":
@@ -2363,11 +2313,16 @@ class ImageCollection(_ImageBase):
         """Number of images."""
         return len(self.images)
 
-    def __getitem__(
-        self,
-        item: int | slice | Sequence[int | bool] | BoundingBox | Sequence[BoundingBox],
-    ) -> Image | TORCHGEO_RETURN_TYPE:
-        """Select one Image by integer index, or multiple Images by slice, list of int or torchgeo.BoundingBox."""
+    def __getattr__(self, attr: str) -> Any:
+        """Make iterable of metadata_attribute."""
+        if attr in (self.metadata_attributes or {}):
+            return self._metadata_attribute_collection_type(
+                [getattr(img, attr) for img in self]
+            )
+        return super().__getattribute__(attr)
+
+    def __getitem__(self, item: int | slice | Sequence[int | bool]) -> Image:
+        """Select one Image by integer index, or multiple Images by slice, list of int."""
         if isinstance(item, int):
             return self.images[item]
 
@@ -2392,90 +2347,23 @@ class ImageCollection(_ImageBase):
             ]
             return copied
 
-        if not isinstance(item, BoundingBox) and not (
-            isinstance(item, Iterable)
-            and len(item)
-            and all(isinstance(x, BoundingBox) for x in item)
-        ):
-            copied = self.copy()
-            if callable(item):
-                item = [item(img) for img in copied]
-
-            # check for base bool and numpy bool
-            if all("bool" in str(type(x)) for x in item):
-                copied.images = [img for x, img in zip(item, copied, strict=True) if x]
+        copied = self.copy()
+        if callable(item):
+            item = [item(img) for img in copied]
 
-            else:
-                copied.images = [copied.images[i] for i in item]
-            return copied
+        # check for base bool and numpy bool
+        if all("bool" in str(type(x)) for x in item):
+            copied.images = [img for x, img in zip(item, copied, strict=True) if x]
 
-        if isinstance(item, BoundingBox):
-            date_ranges: tuple[str] = (item.mint, item.maxt)
-            data: torch.Tensor = numpy_to_torch(
-                np.array(
-                    [
-                        band.values
-                        for band in self.filter(
-                            bbox=item, date_ranges=date_ranges
-                        ).merge_by_band(bounds=item)
-                    ]
-                )
-            )
         else:
-            bboxes: list[Polygon] = [to_bbox(x) for x in item]
-            date_ranges: list[list[str, str]] = [(x.mint, x.maxt) for x in item]
-            data: torch.Tensor = torch.cat(
-                [
-                    numpy_to_torch(
-                        np.array(
-                            [
-                                band.values
-                                for band in self.filter(
-                                    bbox=bbox, date_ranges=date_range
-                                ).merge_by_band(bounds=bbox)
-                            ]
-                        )
-                    )
-                    for bbox, date_range in zip(bboxes, date_ranges, strict=True)
-                ]
-            )
-
-        crs = get_common_crs(self.images)
-
-        key = "image"  # if self.is_image else "mask"
-        sample = {key: data, "crs": crs, "bbox": item}
-
-        return sample
-
-    @property
-    def mint(self) -> float:
-        """Min timestamp of the images combined."""
-        return min(img.mint for img in self)
-
-    @property
-    def maxt(self) -> float:
-        """Max timestamp of the images combined."""
-        return max(img.maxt for img in self)
-
-    @property
-    def band_ids(self) -> list[str]:
-        """Sorted list of unique band_ids."""
-        return list(sorted({band.band_id for img in self for band in img}))
-
-    @property
-    def file_paths(self) -> list[str]:
-        """Sorted list of all file paths, meaning all band paths."""
-        return list(sorted({band.path for img in self for band in img}))
+            copied.images = [copied.images[i] for i in item]
+        return copied
 
     @property
     def dates(self) -> list[str]:
         """List of image dates."""
         return [img.date for img in self]
 
-    def dates_as_int(self) -> list[int]:
-        """List of image dates as 8-length integers."""
-        return [int(img.date[:8]) for img in self]
-
     @property
     def image_paths(self) -> list[str]:
         """List of image paths."""
@@ -2510,14 +2398,21 @@ class ImageCollection(_ImageBase):
                 image._bands = [band for band in image if band.band_id is not None]
 
         if self.metadata is not None:
+            attributes_to_add = ["crs", "bounds"] + list(self.metadata_attributes)
             for img in self:
                 for band in img:
-                    for key in ["crs", "bounds"]:
+                    for key in attributes_to_add:
                         try:
                             value = self.metadata[band.path][key]
                         except KeyError:
-                            value = self.metadata[key][band.path]
-                        setattr(band, f"_{key}", value)
+                            try:
+                                value = self.metadata[key][band.path]
+                            except KeyError:
+                                continue
+                        try:
+                            setattr(band, key, value)
+                        except Exception:
+                            setattr(band, f"_{key}", value)
 
         self._images = [img for img in self if len(img)]
 
@@ -2552,28 +2447,6 @@ class ImageCollection(_ImageBase):
         if not all(isinstance(x, Image) for x in self._images):
             raise TypeError("images should be a sequence of Image.")
 
-    @property
-    def index(self) -> Index:
-        """Spatial index that makes torchgeo think this class is a RasterDataset."""
-        try:
-            if len(self) == len(self._index):
-                return self._index
-        except AttributeError:
-            self._index = Index(interleaved=False, properties=Property(dimension=3))
-
-            for i, img in enumerate(self.images):
-                if img.date:
-                    try:
-                        mint, maxt = disambiguate_timestamp(img.date, self.date_format)
-                    except (NameError, TypeError):
-                        mint, maxt = 0, 1
-                else:
-                    mint, maxt = 0, 1
-                # important: torchgeo has a different order of the bbox than shapely and geopandas
-                minx, miny, maxx, maxy = img.bounds
-                self._index.insert(i, (minx, maxx, miny, maxy, mint, maxt))
-            return self._index
-
     def __repr__(self) -> str:
         """String representation."""
         return f"{self.__class__.__name__}({len(self)}, path='{self.path}')"
@@ -2603,6 +2476,7 @@ class ImageCollection(_ImageBase):
         p: float = 0.95,
         ylim: tuple[float, float] | None = None,
         figsize: tuple[int] = (20, 8),
+        rounding: int = 3,
     ) -> None:
         """Plot each individual pixel in a dotplot for all dates.
 
@@ -2616,6 +2490,7 @@ class ImageCollection(_ImageBase):
             p: p-value for the confidence interval.
             ylim: Limits of the y-axis.
             figsize: Figure size as tuple (width, height).
+            rounding: rounding of title n
 
         """
         if by is None and all(band.band_id is not None for img in self for band in img):
@@ -2625,13 +2500,16 @@ class ImageCollection(_ImageBase):
 
         alpha = 1 - p
 
-        for img in self:
-            for band in img:
-                band.load()
+        # for img in self:
+        #     for band in img:
+        #         band.load()
 
         for group_values, subcollection in self.groupby(by):
             print("group_values:", *group_values)
 
+            if "date" in x_var and subcollection._should_be_sorted:
+                subcollection._images = list(sorted(subcollection._images))
+
             y = np.array([band.values for img in subcollection for band in img])
             if "date" in x_var and subcollection._should_be_sorted:
                 x = np.array(
@@ -2685,6 +2563,10 @@ class ImageCollection(_ImageBase):
                     )[0]
                     predicted = np.array([intercept + coef * x for x in this_x])
 
+                    predicted_start = predicted[0]
+                    predicted_end = predicted[-1]
+                    predicted_change = predicted_end - predicted_start
+
                     # Degrees of freedom
                     dof = len(this_x) - 2
 
@@ -2708,8 +2590,6 @@ class ImageCollection(_ImageBase):
                     ci_lower = predicted - t_val * pred_stderr
                     ci_upper = predicted + t_val * pred_stderr
 
-                    rounding = int(np.log(1 / abs(coef)))
-
                     fig = plt.figure(figsize=figsize)
                     ax = fig.add_subplot(1, 1, 1)
 
@@ -2723,21 +2603,169 @@ class ImageCollection(_ImageBase):
                         alpha=0.2,
                         label=f"{int(alpha*100)}% CI",
                     )
-                    plt.title(f"Coefficient: {round(coef, rounding)}")
+                    plt.title(
+                        f"coef: {round(coef, int(np.log(1 / abs(coef))))}, "
+                        f"pred change: {round(predicted_change, rounding)}, "
+                        f"pred start: {round(predicted_start, rounding)}, "
+                        f"pred end: {round(predicted_end, rounding)}"
+                    )
                     plt.xlabel(x_var)
                     plt.ylabel(y_label)
                     plt.show()
 
 
-def concat_image_collections(collections: Sequence[ImageCollection]) -> ImageCollection:
-    """Union multiple ImageCollections together.
+def _get_all_regex_matches(xml_file: str, regexes: tuple[str]) -> tuple[str]:
+    for regex in regexes:
+        try:
+            return re.search(regex, xml_file)
+        except (TypeError, AttributeError):
+            continue
+    raise ValueError(
+        f"Could not find processing_baseline info from {regexes} in {xml_file}"
+    )
 
-    Same as using the union operator |.
-    """
-    resolutions = {x.res for x in collections}
-    if len(resolutions) > 1:
-        raise ValueError(f"resoultion mismatch. {resolutions}")
-    images = list(itertools.chain.from_iterable([x.images for x in collections]))
+
+class Sentinel2Config:
+    """Holder of Sentinel 2 regexes, band_ids etc."""
+
+    image_regexes: ClassVar[str] = (config.SENTINEL2_IMAGE_REGEX,)
+    filename_regexes: ClassVar[str] = (
+        config.SENTINEL2_FILENAME_REGEX,
+        config.SENTINEL2_CLOUD_FILENAME_REGEX,
+    )
+    metadata_attributes: ClassVar[
+        dict[str, Callable | functools.partial | tuple[str]]
+    ] = {
+        "processing_baseline": functools.partial(
+            _extract_regex_match_from_string,
+            regexes=(r"<PROCESSING_BASELINE>(.*?)</PROCESSING_BASELINE>",),
+        ),
+        "cloud_coverage_percentage": "_get_cloud_coverage_percentage",
+        "is_refined": functools.partial(
+            _any_regex_matches, regexes=(r'<Image_Refining flag="REFINED">',)
+        ),
+        "boa_add_offset": "_get_boa_add_offset_dict",
+    }
+    all_bands: ClassVar[list[str]] = list(config.SENTINEL2_BANDS)
+    rbg_bands: ClassVar[list[str]] = config.SENTINEL2_RBG_BANDS
+    ndvi_bands: ClassVar[list[str]] = config.SENTINEL2_NDVI_BANDS
+    l2a_bands: ClassVar[dict[str, int]] = config.SENTINEL2_L2A_BANDS
+    l1c_bands: ClassVar[dict[str, int]] = config.SENTINEL2_L1C_BANDS
+    masking: ClassVar[BandMasking] = BandMasking(
+        band_id="SCL", values=(3, 8, 9, 10, 11)
+    )
+
+    def _get_cloud_coverage_percentage(self, xml_file: str) -> float:
+        return float(
+            _extract_regex_match_from_string(
+                xml_file,
+                (
+                    r"<Cloud_Coverage_Assessment>([\d.]+)</Cloud_Coverage_Assessment>",
+                    r"<CLOUDY_PIXEL_OVER_LAND_PERCENTAGE>([\d.]+)</CLOUDY_PIXEL_OVER_LAND_PERCENTAGE>",
+                ),
+            )
+        )
+
+    def _get_boa_add_offset_dict(self, xml_file: str) -> BandIdDict:
+        pat = re.compile(
+            r"""
+    <BOA_ADD_OFFSET\s*
+    band_id="(?P<band_id>\d+)"\s*
+    >\s*(?P<value>-?\d+)\s*
+    </BOA_ADD_OFFSET>
+    """,
+            flags=re.VERBOSE,
+        )
+
+        try:
+            matches = [x.groupdict() for x in re.finditer(pat, xml_file)]
+        except (TypeError, AttributeError, KeyError) as e:
+            raise _RegexError(f"Could not find boa_add_offset info from {pat}") from e
+        if not matches:
+            raise _RegexError(f"Could not find boa_add_offset info from {pat}")
+        return BandIdDict(
+            pd.DataFrame(matches).set_index("band_id")["value"].astype(int).to_dict()
+        )
+
+
+class Sentinel2CloudlessConfig(Sentinel2Config):
+    """Holder of regexes, band_ids etc. for Sentinel 2 cloudless mosaic."""
+
+    image_regexes: ClassVar[str] = (config.SENTINEL2_MOSAIC_IMAGE_REGEX,)
+    filename_regexes: ClassVar[str] = (config.SENTINEL2_MOSAIC_FILENAME_REGEX,)
+    masking: ClassVar[None] = None
+    all_bands: ClassVar[list[str]] = [
+        x.replace("B0", "B") for x in Sentinel2Config.all_bands
+    ]
+    rbg_bands: ClassVar[list[str]] = [
+        x.replace("B0", "B") for x in Sentinel2Config.rbg_bands
+    ]
+    ndvi_bands: ClassVar[list[str]] = [
+        x.replace("B0", "B") for x in Sentinel2Config.ndvi_bands
+    ]
+
+
+class Sentinel2Band(Sentinel2Config, Band):
+    """Band with Sentinel2 specific name variables and regexes."""
+
+
+class Sentinel2Image(Sentinel2Config, Image):
+    """Image with Sentinel2 specific name variables and regexes."""
+
+    band_class: ClassVar[Sentinel2Band] = Sentinel2Band
+
+    def ndvi(
+        self,
+        red_band: str = Sentinel2Config.ndvi_bands[0],
+        nir_band: str = Sentinel2Config.ndvi_bands[1],
+        copy: bool = True,
+    ) -> NDVIBand:
+        """Calculate the NDVI for the Image."""
+        return super().ndvi(red_band=red_band, nir_band=nir_band, copy=copy)
+
+
+class Sentinel2Collection(Sentinel2Config, ImageCollection):
+    """ImageCollection with Sentinel2 specific name variables and path regexes."""
+
+    image_class: ClassVar[Sentinel2Image] = Sentinel2Image
+    band_class: ClassVar[Sentinel2Band] = Sentinel2Band
+
+    def __init__(self, data: str | Path | Sequence[Image], **kwargs) -> None:
+        """ImageCollection with Sentinel2 specific name variables and path regexes."""
+        level = kwargs.get("level", NoLevel)
+        if isinstance(level, type) and isinstance(level(), NoLevel):
+            raise ValueError("Must specify level for Sentinel2Collection.")
+        super().__init__(data=data, **kwargs)
+
+
+class Sentinel2CloudlessBand(Sentinel2CloudlessConfig, Band):
+    """Band for cloudless mosaic with Sentinel2 specific name variables and regexes."""
+
+
+class Sentinel2CloudlessImage(Sentinel2CloudlessConfig, Sentinel2Image):
+    """Image for cloudless mosaic with Sentinel2 specific name variables and regexes."""
+
+    band_class: ClassVar[Sentinel2CloudlessBand] = Sentinel2CloudlessBand
+
+    ndvi = Sentinel2Image.ndvi
+
+
+class Sentinel2CloudlessCollection(Sentinel2CloudlessConfig, ImageCollection):
+    """ImageCollection with Sentinel2 specific name variables and regexes."""
+
+    image_class: ClassVar[Sentinel2CloudlessImage] = Sentinel2CloudlessImage
+    band_class: ClassVar[Sentinel2Band] = Sentinel2CloudlessBand
+
+
+def concat_image_collections(collections: Sequence[ImageCollection]) -> ImageCollection:
+    """Union multiple ImageCollections together.
+
+    Same as using the union operator |.
+    """
+    resolutions = {x.res for x in collections}
+    if len(resolutions) > 1:
+        raise ValueError(f"resoultion mismatch. {resolutions}")
+    images = list(itertools.chain.from_iterable([x.images for x in collections]))
     levels = {x.level for x in collections}
     level = next(iter(levels)) if len(levels) == 1 else None
     first_collection = collections[0]
@@ -2816,7 +2844,7 @@ def _clip_loaded_array(
     out_shape: tuple[int, int],
     **kwargs,
 ) -> np.ndarray:
-    # xarray needs a numpy array of polygon(s)
+    # xarray needs a numpy array of polygons
     bounds_arr: np.ndarray = GeoSeries([to_shapely(bounds)]).values
     try:
 
@@ -2837,6 +2865,29 @@ def _clip_loaded_array(
         return np.array([])
 
 
+def _fix_path(path: str) -> str:
+    return (
+        str(path).replace("\\", "/").replace(r"\"", "/").replace("//", "/").rstrip("/")
+    )
+
+
+def _get_all_file_paths(path: str) -> list[str]:
+    if is_dapla():
+        return list(sorted(set(_glob_func(path + "/**"))))
+    else:
+        return list(
+            sorted(
+                set(
+                    _glob_func(path + "/**")
+                    + _glob_func(path + "/**/**")
+                    + _glob_func(path + "/**/**/**")
+                    + _glob_func(path + "/**/**/**/**")
+                    + _glob_func(path + "/**/**/**/**/**")
+                )
+            )
+        )
+
+
 def _get_images(
     image_paths: list[str],
     *,
@@ -2874,21 +2925,6 @@ def _get_images(
     return images
 
 
-def numpy_to_torch(array: np.ndarray) -> torch.Tensor:
-    """Convert numpy array to a pytorch tensor."""
-    # fix numpy dtypes which are not supported by pytorch tensors
-    if array.dtype == np.uint16:
-        array = array.astype(np.int32)
-    elif array.dtype == np.uint32:
-        array = array.astype(np.int64)
-
-    return torch.tensor(array)
-
-
-class _RegexError(ValueError):
-    pass
-
-
 class ArrayNotLoadedError(ValueError):
     """Arrays are not loaded."""
 
@@ -2904,10 +2940,12 @@ class PathlessImageError(ValueError):
         """String representation."""
         if self.instance._merged:
             what = "that have been merged"
-        elif self.isinstance._from_array:
+        elif self.instance._from_array:
             what = "from arrays"
-        elif self.isinstance._from_gdf:
+        elif self.instance._from_gdf:
             what = "from GeoDataFrames"
+        else:
+            raise ValueError(self.instance)
 
         return (
             f"{self.instance.__class__.__name__} instances {what} "
@@ -2915,165 +2953,32 @@ class PathlessImageError(ValueError):
         )
 
 
-def _get_regex_match_from_xml_in_local_dir(
-    paths: list[str], regexes: str | tuple[str]
-) -> str | dict[str, str]:
-    for i, path in enumerate(paths):
-        if ".xml" not in path:
-            continue
-        with _open_func(path, "rb") as file:
-            filebytes: bytes = file.read()
-            try:
-                return _extract_regex_match_from_string(
-                    filebytes.decode("utf-8"), regexes
-                )
-            except _RegexError as e:
-                if i == len(paths) - 1:
-                    raise e
-
-
-def _extract_regex_match_from_string(
-    xml_file: str, regexes: tuple[str | re.Pattern]
-) -> str | dict[str, str]:
-    if all(isinstance(x, str) for x in regexes):
-        for regex in regexes:
-            try:
-                return re.search(regex, xml_file).group(1)
-            except (TypeError, AttributeError):
-                continue
-        raise _RegexError()
-
-    out = {}
-    for regex in regexes:
-        try:
-            matches = re.search(regex, xml_file)
-            out |= matches.groupdict()
-        except (TypeError, AttributeError):
-            continue
-    if not out:
-        raise _RegexError()
-    return out
-
-
-def _fix_path(path: str) -> str:
-    return (
-        str(path).replace("\\", "/").replace(r"\"", "/").replace("//", "/").rstrip("/")
-    )
-
-
-def _get_regexes_matches_for_df(
-    df, match_col: str, patterns: Sequence[re.Pattern]
-) -> pd.DataFrame:
-    if not len(df):
-        return df
-
-    non_optional_groups = list(
-        set(
-            itertools.chain.from_iterable(
-                [_get_non_optional_groups(pat) for pat in patterns]
-            )
-        )
-    )
-
-    if not non_optional_groups:
-        return df
-
-    assert df.index.is_unique
-    keep = []
-    for pat in patterns:
-        for i, row in df[match_col].items():
-            matches = _get_first_group_match(pat, row)
-            if all(group in matches for group in non_optional_groups):
-                keep.append(i)
-
-    return df.loc[keep]
-
-
-def _get_non_optional_groups(pat: re.Pattern | str) -> list[str]:
-    return [
-        x
-        for x in [
-            _extract_group_name(group)
-            for group in pat.pattern.split("\n")
-            if group
-            and not group.replace(" ", "").startswith("#")
-            and not group.replace(" ", "").split("#")[0].endswith("?")
-        ]
-        if x is not None
-    ]
-
-
-def _extract_group_name(txt: str) -> str | None:
-    try:
-        return re.search(r"\(\?P<(\w+)>", txt)[1]
-    except TypeError:
-        return None
-
-
-def _get_first_group_match(pat: re.Pattern, text: str) -> dict[str, str]:
-    groups = pat.groupindex.keys()
-    all_matches: dict[str, str] = {}
-    for x in pat.findall(text):
-        for group, value in zip(groups, x, strict=True):
-            if value and group not in all_matches:
-                all_matches[group] = value
-    return all_matches
-
-
 def _date_is_within(
-    path,
-    date_ranges: (
-        tuple[str | None, str | None] | tuple[tuple[str | None, str | None], ...] | None
-    ),
-    image_patterns: Sequence[re.Pattern],
-    date_format: str,
+    date: str | None,
+    date_ranges: DATE_RANGES_TYPE,
 ) -> bool:
-    for pat in image_patterns:
-
-        try:
-            date = _get_first_group_match(pat, Path(path).name)["date"]
-            break
-        except KeyError:
-            date = None
+    if date_ranges is None:
+        return True
 
     if date is None:
         return False
 
-    if date_ranges is None:
-        return True
+    date = pd.Timestamp(date)
 
-    if all(x is None or isinstance(x, (str, float)) for x in date_ranges):
+    if all(x is None or isinstance(x, str) for x in date_ranges):
         date_ranges = (date_ranges,)
 
-    if all(isinstance(x, float) for date_range in date_ranges for x in date_range):
-        date = disambiguate_timestamp(date, date_format)
-    else:
-        date = date[:8]
-
     for date_range in date_ranges:
         date_min, date_max = date_range
 
-        if isinstance(date_min, float) and isinstance(date_max, float):
-            if date[0] >= date_min + 0.0000001 and date[1] <= date_max - 0.0000001:
-                return True
-            continue
+        if date_min is not None:
+            date_min = pd.Timestamp(date_min)
+        if date_max is not None:
+            date_max = pd.Timestamp(date_max)
 
-        try:
-            date_min = date_min or "00000000"
-            date_max = date_max or "99999999"
-            if not (
-                isinstance(date_min, str)
-                and len(date_min) == 8
-                and isinstance(date_max, str)
-                and len(date_max) == 8
-            ):
-                raise ValueError()
-        except ValueError as err:
-            raise TypeError(
-                "date_ranges should be a tuple of two 8-charactered strings (start and end date)."
-                f"Got {date_range} of type {[type(x) for x in date_range]}"
-            ) from err
-        if date >= date_min and date <= date_max:
+        if (date_min is None or date >= date_min) and (
+            date_max is None or date <= date_max
+        ):
             return True
 
     return False
@@ -3093,10 +2998,6 @@ def _get_dtype_max(dtype: str | type) -> int | float:
         return np.finfo(dtype).max
 
 
-def _img_ndvi(img, **kwargs):
-    return Image([img.ndvi(**kwargs)])
-
-
 def _intesects(x, other) -> bool:
     return box(*x.bounds).intersects(other)
 
@@ -3116,6 +3017,17 @@ def _copy_and_add_df_parallel(
     return (i, copied)
 
 
+def _get_bounds(bounds, bbox) -> None | Polygon:
+    if bounds is None and bbox is None:
+        return None
+    elif bounds is not None and bbox is None:
+        return to_shapely(bounds)  # .intersection(self.union_all())
+    elif bounds is None and bbox is not None:
+        return to_shapely(bbox)  # .intersection(self.union_all())
+    else:
+        return to_shapely(bounds).intersection(to_shapely(bbox))
+
+
 def _get_single_value(values: tuple):
     if len(set(values)) == 1:
         return next(iter(values))
@@ -3173,85 +3085,126 @@ def array_buffer(arr: np.ndarray, distance: int) -> np.ndarray:
         return binary_erosion(arr, structure=structure).astype(dtype)
 
 
-class Sentinel2Config:
-    """Holder of Sentinel 2 regexes, band_ids etc."""
-
-    image_regexes: ClassVar[str] = (config.SENTINEL2_IMAGE_REGEX,)
-    filename_regexes: ClassVar[str] = (
-        config.SENTINEL2_FILENAME_REGEX,
-        config.SENTINEL2_CLOUD_FILENAME_REGEX,
-    )
-    all_bands: ClassVar[list[str]] = list(config.SENTINEL2_BANDS)
-    rbg_bands: ClassVar[list[str]] = config.SENTINEL2_RBG_BANDS
-    ndvi_bands: ClassVar[list[str]] = config.SENTINEL2_NDVI_BANDS
-    l2a_bands: ClassVar[dict[str, int]] = config.SENTINEL2_L2A_BANDS
-    l1c_bands: ClassVar[dict[str, int]] = config.SENTINEL2_L1C_BANDS
-    date_format: ClassVar[str] = "%Y%m%d"  # T%H%M%S"
-    masking: ClassVar[BandMasking] = BandMasking(
-        band_id="SCL", values=(3, 8, 9, 10, 11)
-    )
-
-
-class Sentinel2CloudlessConfig(Sentinel2Config):
-    """Holder of regexes, band_ids etc. for Sentinel 2 cloudless mosaic."""
+def get_cmap(arr: np.ndarray) -> LinearSegmentedColormap:
 
-    image_regexes: ClassVar[str] = (config.SENTINEL2_MOSAIC_IMAGE_REGEX,)
-    filename_regexes: ClassVar[str] = (config.SENTINEL2_MOSAIC_FILENAME_REGEX,)
-    masking: ClassVar[None] = None
-    date_format: ClassVar[str] = "%Y%m%d"
-    all_bands: ClassVar[list[str]] = [
-        x.replace("B0", "B") for x in Sentinel2Config.all_bands
+    # blue = [[i / 10 + 0.1, i / 10 + 0.1, 1 - (i / 10) + 0.1] for i in range(11)][1:]
+    blue = [
+        [0.1, 0.1, 1.0],
+        [0.2, 0.2, 0.9],
+        [0.3, 0.3, 0.8],
+        [0.4, 0.4, 0.7],
+        [0.6, 0.6, 0.6],
+        [0.6, 0.6, 0.6],
+        [0.7, 0.7, 0.7],
+        [0.8, 0.8, 0.8],
     ]
-    rbg_bands: ClassVar[list[str]] = [
-        x.replace("B0", "B") for x in Sentinel2Config.rbg_bands
+    # gray = list(reversed([[i / 10 - 0.1, i / 10, i / 10 - 0.1] for i in range(11)][1:]))
+    gray = [
+        [0.6, 0.6, 0.6],
+        [0.6, 0.6, 0.6],
+        [0.6, 0.6, 0.6],
+        [0.6, 0.6, 0.6],
+        [0.6, 0.6, 0.6],
+        [0.4, 0.7, 0.4],
+        [0.3, 0.7, 0.3],
+        [0.2, 0.8, 0.2],
     ]
-    ndvi_bands: ClassVar[list[str]] = [
-        x.replace("B0", "B") for x in Sentinel2Config.ndvi_bands
+    # gray = [[0.6, 0.6, 0.6] for i in range(10)]
+    # green = [[0.2 + i/20, i / 10 - 0.1, + i/20] for i in range(11)][1:]
+    green = [
+        [0.25, 0.0, 0.05],
+        [0.3, 0.1, 0.1],
+        [0.35, 0.2, 0.15],
+        [0.4, 0.3, 0.2],
+        [0.45, 0.4, 0.25],
+        [0.5, 0.5, 0.3],
+        [0.55, 0.6, 0.35],
+        [0.7, 0.9, 0.5],
+    ]
+    green = [
+        [0.6, 0.6, 0.6],
+        [0.4, 0.7, 0.4],
+        [0.3, 0.8, 0.3],
+        [0.25, 0.4, 0.25],
+        [0.2, 0.5, 0.2],
+        [0.10, 0.7, 0.10],
+        [0, 0.9, 0],
     ]
 
+    def get_start(arr):
+        min_value = np.min(arr)
+        if min_value < -0.75:
+            return 0
+        if min_value < -0.5:
+            return 1
+        if min_value < -0.25:
+            return 2
+        if min_value < 0:
+            return 3
+        if min_value < 0.25:
+            return 4
+        if min_value < 0.5:
+            return 5
+        if min_value < 0.75:
+            return 6
+        return 7
 
-class Sentinel2Band(Sentinel2Config, Band):
-    """Band with Sentinel2 specific name variables and regexes."""
-
-
-class Sentinel2Image(Sentinel2Config, Image):
-    """Image with Sentinel2 specific name variables and regexes."""
-
-    cloud_cover_regexes: ClassVar[tuple[str]] = config.CLOUD_COVERAGE_REGEXES
-    band_class: ClassVar[Sentinel2Band] = Sentinel2Band
-
-    def ndvi(
-        self,
-        red_band: str = Sentinel2Config.ndvi_bands[0],
-        nir_band: str = Sentinel2Config.ndvi_bands[1],
-        copy: bool = True,
-    ) -> NDVIBand:
-        """Calculate the NDVI for the Image."""
-        return super().ndvi(red_band=red_band, nir_band=nir_band, copy=copy)
-
-
-class Sentinel2Collection(Sentinel2Config, ImageCollection):
-    """ImageCollection with Sentinel2 specific name variables and regexes."""
-
-    image_class: ClassVar[Sentinel2Image] = Sentinel2Image
-    band_class: ClassVar[Sentinel2Band] = Sentinel2Band
-
-
-class Sentinel2CloudlessBand(Sentinel2CloudlessConfig, Band):
-    """Band for cloudless mosaic with Sentinel2 specific name variables and regexes."""
-
+    def get_stop(arr):
+        max_value = np.max(arr)
+        if max_value <= 0.05:
+            return 0
+        if max_value < 0.175:
+            return 1
+        if max_value < 0.25:
+            return 2
+        if max_value < 0.375:
+            return 3
+        if max_value < 0.5:
+            return 4
+        if max_value < 0.75:
+            return 5
+        return 6
 
-class Sentinel2CloudlessImage(Sentinel2CloudlessConfig, Sentinel2Image):
-    """Image for cloudless mosaic with Sentinel2 specific name variables and regexes."""
+    cmap_name = "blue_gray_green"
 
-    cloud_cover_regexes: ClassVar[None] = None
-    band_class: ClassVar[Sentinel2CloudlessBand] = Sentinel2CloudlessBand
+    start = get_start(arr)
+    stop = get_stop(arr)
+    blue = blue[start]
+    gray = gray[start]
+    # green = green[start]
+    green = green[stop]
 
-    ndvi = Sentinel2Image.ndvi
+    # green[0] = np.arange(0, 1, 0.1)[::-1][stop]
+    # green[1] = np.arange(0, 1, 0.1)[stop]
+    # green[2] = np.arange(0, 1, 0.1)[::-1][stop]
 
+    print(green)
+    print(start, stop)
+    print("blue gray green")
+    print(blue)
+    print(gray)
+    print(green)
 
-class Sentinel2CloudlessCollection(Sentinel2CloudlessConfig, ImageCollection):
-    """ImageCollection with Sentinel2 specific name variables and regexes."""
+    # Define the segments of the colormap
+    cdict = {
+        "red": [
+            (0.0, blue[0], blue[0]),
+            (0.3, gray[0], gray[0]),
+            (0.7, gray[0], gray[0]),
+            (1.0, green[0], green[0]),
+        ],
+        "green": [
+            (0.0, blue[1], blue[1]),
+            (0.3, gray[1], gray[1]),
+            (0.7, gray[1], gray[1]),
+            (1.0, green[1], green[1]),
+        ],
+        "blue": [
+            (0.0, blue[2], blue[2]),
+            (0.3, gray[2], gray[2]),
+            (0.7, gray[2], gray[2]),
+            (1.0, green[2], green[2]),
+        ],
+    }
 
-    image_class: ClassVar[Sentinel2CloudlessImage] = Sentinel2CloudlessImage
-    band_class: ClassVar[Sentinel2Band] = Sentinel2CloudlessBand
+    return LinearSegmentedColormap(cmap_name, segmentdata=cdict, N=50)