ssb-sgis 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

sgis/raster/raster.py

@@ -1,11 +1,17 @@
 import functools
 import numbers
+import os
 import re
 import warnings
-from collections.abc import Callable, Iterable
-from copy import copy, deepcopy
+from collections.abc import Callable
+from collections.abc import Iterable
+from collections.abc import Iterator
+from copy import copy
+from copy import deepcopy
 from json import loads
 from pathlib import Path
+from typing import Any
+from typing import ClassVar
 
 import geopandas as gpd
 import matplotlib.pyplot as plt
@@ -13,17 +19,25 @@ import numpy as np
 import pandas as pd
 import pyproj
 import rasterio
+import rasterio.windows
 import shapely
 from typing_extensions import Self  # TODO: imperter fra typing når python 3.11
 
-
 try:
     import xarray as xr
     from xarray import DataArray
 except ImportError:
 
     class DataArray:
-        pass
+        """Placeholder."""
+
+
+try:
+    from dapla.gcs import GCSFileSystem
+except ImportError:
+
+    class GCSFileSystem:
+        """Placeholder."""
 
 
 try:
@@ -31,7 +45,8 @@ try:
 except ImportError:
     pass
 from affine import Affine
-from geopandas import GeoDataFrame, GeoSeries
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
 from pandas.api.types import is_list_like
 from rasterio import features
 from rasterio.enums import MergeAlg
@@ -39,22 +54,26 @@ from rasterio.io import DatasetReader
 from rasterio.vrt import WarpedVRT
 from rasterio.warp import reproject
 from shapely import Geometry
-from shapely.geometry import Point, Polygon, shape
-
-from ..geopandas_tools.conversion import to_bbox, to_gdf, to_shapely
-from ..geopandas_tools.general import is_bbox_like, is_wkt
+from shapely.geometry import Point
+from shapely.geometry import Polygon
+from shapely.geometry import shape
+
+from ..geopandas_tools.conversion import to_bbox
+from ..geopandas_tools.conversion import to_gdf
+from ..geopandas_tools.conversion import to_shapely
+from ..geopandas_tools.general import is_bbox_like
+from ..geopandas_tools.general import is_wkt
 from ..helpers import is_property
 from ..io.opener import opener
-from .base import ALLOWED_KEYS, NESSECARY_META, get_index_mapper, memfile_from_array
-from .gradient import get_gradient
-from .zonal import (
-    _aggregate,
-    _no_overlap_df,
-    make_geometry_iterrows,
-    prepare_zonal,
-    zonal_post,
-)
-
+from .base import ALLOWED_KEYS
+from .base import NESSECARY_META
+from .base import get_index_mapper
+from .base import memfile_from_array
+from .zonal import _aggregate
+from .zonal import _make_geometry_iterrows
+from .zonal import _no_overlap_df
+from .zonal import _prepare_zonal
+from .zonal import _zonal_post
 
 numpy_func_message = (
     "aggfunc must be functions or strings of numpy functions or methods."
@@ -68,11 +87,11 @@ class Raster:
     'from_gdf'.
 
 
-    Examples
-    --------
-
+    Examples:
+    ---------
     Read tif file.
 
+    >>> import sgis as sg
     >>> path = 'https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/raster/dtm_10.tif'
     >>> raster = sg.Raster.from_path(path)
     >>> raster
@@ -83,8 +102,8 @@ class Raster:
     The array is stored in the array attribute.
 
     >>> raster.load()
-    >>> raster.array[raster.array < 0] = 0
-    >>> raster.array
+    >>> raster.values[raster.values < 0] = 0
+    >>> raster.values
     [[[  0.    0.    0.  ... 158.4 155.6 152.6]
     [  0.    0.    0.  ... 158.  154.8 151.9]
     [  0.    0.    0.  ... 158.5 155.1 152.3]
@@ -147,14 +166,8 @@ class Raster:
 
     """
 
-    # attributes conserning file path
-    filename_regex: str | None = None
-    date_format: str | None = None
-    contains: str | None = None
-    endswith: str = ".tif"
-
-    # attributes conserning rasterio metadata
-    _profile = {
+    # attributes concerning rasterio metadata
+    _profile: ClassVar[dict[str, str | None]] = {
         "driver": "GTiff",
         "compress": "LZW",
         "nodata": None,
@@ -164,43 +177,58 @@ class Raster:
         "indexes": None,
     }
 
-    # driver: str = "GTiff"
-    # compress: str = "LZW"
-    # _nodata: int | float | None = None
-    # _dtype: type | None = None
-
     def __init__(
         self,
-        raster=None,
+        data: Self | str | np.ndarray | None = None,
         *,
-        path: str | None = None,
-        # indexes: int | list[int] | None = None,
-        array: np.ndarray | None = None,
-        file_system=None,
+        file_system: GCSFileSystem | None = None,
+        filename_regex: str | None = None,
         **kwargs,
-    ):
-        if raster is not None:
-            if not isinstance(raster, Raster):
-                raise TypeError(
-                    "Raster should be constructed with the classmethods (from_...)."
-                )
-            for key, value in raster.__dict__.items():
-                setattr(raster, key, value)
+    ) -> None:
+        """Note: use the classmethods from_path, from_array, from_gdf etc. instead of the initialiser.
+
+        Args:
+            data: A file path, an array or a Raster object.
+            file_system: Optional GCSFileSystem.
+            filename_regex: Regular expression to match file name attributes (date, band, tile, resolution).
+            **kwargs: Arguments concerning file metadata or
+                spatial properties of the image.
+        """
+        warnings.warn("This class is deprecated in favor of Band", stacklevel=1)
+        self.filename_regex = filename_regex
+        if filename_regex:
+            self.filename_pattern = re.compile(self.filename_regex, re.VERBOSE)
+        else:
+            self.filename_pattern = None
+
+        if isinstance(data, Raster):
+            for key, value in data.__dict__.items():
+                setattr(data, key, value)
             return
 
-        if path is None and not any([kwargs.get("transform"), kwargs.get("bounds")]):
+        if isinstance(data, (str | Path | os.PathLike)):
+            self.path = data
+
+        else:
+            self.path = None
+
+        if isinstance(data, (np.ndarray)):
+            self.values = data
+        else:
+            self.values = None
+
+        if self.path is None and not any(
+            [kwargs.get("transform"), kwargs.get("bounds")]
+        ):
             raise TypeError(
                 "Must specify either bounds or transform when constructing raster from array."
             )
 
-        # add class profile first to override with args and kwargs
+        # add class profile first, then override with args and kwargs
         self.update(**self._profile)
 
         self._crs = kwargs.pop("crs", self._crs if hasattr(self, "_crs") else None)
         self._bounds = None
-
-        self.path = path
-        self.array = array
         self.file_system = file_system
         self._indexes = self._get_indexes(kwargs.pop("indexes", self.indexes))
 
@@ -220,21 +248,28 @@ class Raster:
         cls,
         path: str,
         res: int | None = None,
-        file_system=None,
+        file_system: GCSFileSystem | None = None,
+        filename_regex: str | None = None,
         **kwargs,
-    ):
+    ) -> Self:
         """Construct Raster from file path.
 
         Args:
             path: Path to a raster image file.
+            res: Spatial resolution when reading the image.
+            file_system: Optional file system.
+            filename_regex: Regular expression with optional match groups.
+            **kwargs: Arguments concerning file metadata or
+                spatial properties of the image.
 
         Returns:
             A Raster instance.
         """
         return cls(
-            path=str(path),
+            str(path),
             file_system=file_system,
             res=res,
+            filename_regex=filename_regex,
             **kwargs,
         )
 
@@ -242,19 +277,18 @@ class Raster:
     def from_array(
         cls,
         array: np.ndarray,
-        crs,
+        crs: Any,
         *,
         transform: Affine | None = None,
         bounds: tuple | Geometry | None = None,
         copy: bool = True,
         **kwargs,
-    ):
+    ) -> Self:
         """Construct Raster from numpy array.
 
-        Metadata must be specified, either individually or in a dictionary
-        (hint: use the 'meta' attribute of an existing Raster object if applicable).
-        The necessary metadata is 'crs' and either 'transform' (Affine object) or 'bounds',
-        which transform will then be created from.
+        Must also specify nessecary spatial properties
+        The necessary metadata is 'crs' and either 'transform' (Affine object)
+        or 'bounds', which transform will then be created from.
 
         Args:
             array: 2d or 3d numpy ndarray.
@@ -263,7 +297,9 @@ class Raster:
                 of bounds.
             bounds: Minimum and maximum x and y coordinates. Can be specified instead
                 of transform.
-            name: Optional name to give the raster.
+            copy: Whether to copy the array.
+            **kwargs: Arguments concerning file metadata or
+                spatial properties of the image.
 
         Returns:
             A Raster instance.
@@ -295,7 +331,7 @@ class Raster:
 
         crs = pyproj.CRS(crs) if crs else None
 
-        return cls(array=array, crs=crs, transform=transform, bounds=bounds, **kwargs)
+        return cls(array, crs=crs, transform=transform, bounds=bounds, **kwargs)
 
     @classmethod
     def from_gdf(
@@ -303,21 +339,38 @@ class Raster:
         gdf: GeoDataFrame,
         columns: str | Iterable[str],
         res: int,
-        fill=0,
-        all_touched=False,
-        merge_alg=MergeAlg.replace,
-        default_value=1,
-        dtype=None,
+        fill: int = 0,
+        all_touched: bool = False,
+        merge_alg: Callable = MergeAlg.replace,
+        default_value: int = 1,
+        dtype: Any | None = None,
         **kwargs,
-    ):
+    ) -> Self:
         """Construct Raster from a GeoDataFrame.
 
         Args:
-            gdf: The GeoDataFrame.
-            column: The column to be used as values for the array.
-            res: Resolution of the raster in units of gdf's coordinate
-                reference system.
+            gdf: The GeoDataFrame to rasterize.
+            columns: Column(s) in the GeoDataFrame whose values are used to populate the raster.
+                This can be a single column name or a list of column names.
+            res: Resolution of the raster in units of the GeoDataFrame's coordinate reference system.
+            fill: Fill value for areas outside of input geometries (default is 0).
+            all_touched: Whether to consider all pixels touched by geometries,
+                not just those whose center is within the polygon (default is False).
+            merge_alg: Merge algorithm to use when combining geometries
+                (default is 'MergeAlg.replace').
+            default_value: Default value to use for the rasterized pixels
+                (default is 1).
+            dtype: Data type of the output array. If None, it will be
+                determined automatically.
+            **kwargs: Additional keyword arguments passed to the raster
+                creation process, e.g., custom CRS or transform settings.
 
+        Returns:
+            A Raster instance based on the specified GeoDataFrame and parameters.
+
+        Raises:
+            TypeError: If 'transform' is provided in kwargs, as this is
+            computed based on the GeoDataFrame bounds and resolution.
         """
         if not isinstance(gdf, GeoDataFrame):
             gdf = to_gdf(gdf)
@@ -362,10 +415,10 @@ class Raster:
             assert len(array.shape) == 3
             name = kwargs.get("name", None)
 
-        return cls.from_array(array=array, name=name, **kwargs)
+        return cls.from_array(array, name=name, **kwargs)
 
     @classmethod
-    def from_dict(cls, dictionary: dict):
+    def from_dict(cls, dictionary: dict) -> Self:
         """Construct Raster from metadata dict to fastpass the initializer.
 
         This is the fastest way to create a Raster since a metadata lookup is not
@@ -387,6 +440,7 @@ class Raster:
         return cls(**dictionary)
 
     def update(self, **kwargs) -> Self:
+        """Update attributes of the Raster."""
         for key, value in kwargs.items():
             self._validate_key(key)
             if is_property(self, key):
@@ -394,7 +448,9 @@ class Raster:
             setattr(self, key, value)
         return self
 
-    def write(self, path: str, window=None, **kwargs) -> None:
+    def write(
+        self, path: str, window: rasterio.windows.Window | None = None, **kwargs
+    ) -> None:
         """Write the raster as a single file.
 
         Multiband arrays will result in a multiband image file.
@@ -402,26 +458,29 @@ class Raster:
         Args:
             path: File path to write to.
             window: Optional window to clip the image to.
+            **kwargs: Keyword arguments passed to rasterio.open.
+                Thise will override the items in the Raster's profile,
+                if overlapping.
         """
-
-        if self.array is None:
+        if self.values is None:
             raise AttributeError("The image hasn't been loaded.")
 
         profile = self.profile | kwargs
 
-        with opener(path, file_system=self.file_system) as file:
+        with opener(path, "wb", file_system=self.file_system) as file:
             with rasterio.open(file, "w", **profile) as dst:
                 self._write(dst, window)
 
         self.path = str(path)
 
-    def load(self, **kwargs) -> Self:
+    def load(self, reload: bool = False, **kwargs) -> Self:
         """Load the entire image as an np.array.
 
         The array is stored in the 'array' attribute
         of the Raster.
 
         Args:
+            reload: Whether to reload the array if already loaded.
             **kwargs: Keyword arguments passed to the rasterio read
                 method.
         """
@@ -430,13 +489,14 @@ class Raster:
         if "window" in kwargs:
             raise ValueError("Got an unexpected keyword argument 'window'")
 
-        self._read_tif(**kwargs)
+        if reload or self.values is None:
+            self._read_tif(**kwargs)
 
         return self
 
     def clip(
         self,
-        mask,
+        mask: Any,
         masked: bool = False,
         boundless: bool = True,
         **kwargs,
@@ -448,6 +508,13 @@ class Raster:
 
         Args:
             mask: Geometry-like object or bounding box.
+            masked: If 'masked' is True the return value will be a masked
+                array. Otherwise (default) the return value will be a
+                regular array. Masks will be exactly the inverse of the
+                GDAL RFC 15 conforming arrays returned by read_masks().
+            boundless: If True, windows that extend beyond the dataset's extent
+                are permitted and partially or completely filled arrays will
+                be returned as appropriate.
             **kwargs: Keyword arguments passed to the mask function
                 from the rasterio.mask module.
 
@@ -462,17 +529,18 @@ class Raster:
         except ValueError:
             mask = mask.set_crs(self.crs)
 
-        # if not self.crs.equals(pyproj.CRS(mask.crs)):
-        #     raise ValueError("crs mismatch.")
-
         self._read_with_mask(mask=mask, masked=masked, boundless=boundless, **kwargs)
 
         return self
 
-    def intersects(self, other) -> bool:
+    def intersects(self, other: Any) -> bool:
+        """Returns True if the image bounds intersect with 'other'."""
         return self.unary_union.intersects(to_shapely(other))
 
-    def sample(self, n=1, size=20, mask=None, copy=True, **kwargs) -> Self:
+    def sample(
+        self, n: int = 1, size: int = 20, mask: Any = None, copy: bool = True, **kwargs
+    ) -> Self:
+        """Take a random spatial sample of the image."""
         if mask is not None:
             points = GeoSeries(self.unary_union).clip(mask).sample_points(n)
         else:
@@ -508,19 +576,21 @@ class Raster:
             A GeoDataFrame with aggregated values per polygon.
         """
         idx_mapper, idx_name = get_index_mapper(polygons)
-        polygons, aggfunc, func_names = prepare_zonal(polygons, aggfunc)
-        poly_iter = make_geometry_iterrows(polygons)
+        polygons, aggfunc, func_names = _prepare_zonal(polygons, aggfunc)
+        poly_iter = _make_geometry_iterrows(polygons)
 
         aggregated = []
         for i, poly in poly_iter:
             clipped = self.clip(poly)
-            if not np.size(clipped.array):
+            if not np.size(clipped.values):
                 aggregated.append(_no_overlap_df(func_names, i, date=self.date))
             aggregated.append(
-                _aggregate(clipped.array, array_func, aggfunc, func_names, self.date, i)
+                _aggregate(
+                    clipped.values, array_func, aggfunc, func_names, self.date, i
+                )
             )
 
-        return zonal_post(
+        return _zonal_post(
             aggregated,
             polygons=polygons,
             idx_mapper=idx_mapper,
@@ -528,73 +598,23 @@ class Raster:
             dropna=dropna,
         )
 
-    def gradient(self, degrees: bool = False, copy: bool = False) -> Self:
-        """Get the slope of an elevation raster.
-
-        Calculates the absolute slope between the grid cells
-        based on the image resolution.
-
-        For multiband images, the calculation is done for each band.
-
-        Args:
-            degrees: If False (default), the returned values will be in ratios,
-                where a value of 1 means 1 meter up per 1 meter forward. If True,
-                the values will be in degrees from 0 to 90.
-            copy: Whether to copy or overwrite the original Raster.
-                Defaults to False to save memory.
-
-        Returns:
-            The class instance with new array values, or a copy if copy is True.
-
-        Examples
-        --------
-        Making an array where the gradient to the center is always 10.
-
-        >>> import sgis as sg
-        >>> import numpy as np
-        >>> arr = np.array(
-        ...         [
-        ...             [100, 100, 100, 100, 100],
-        ...             [100, 110, 110, 110, 100],
-        ...             [100, 110, 120, 110, 100],
-        ...             [100, 110, 110, 110, 100],
-        ...             [100, 100, 100, 100, 100],
-        ...         ]
-        ...     )
-
-        Now let's create a Raster from this array with a resolution of 10.
-
-        >>> r = sg.Raster.from_array(arr, crs=None, bounds=(0, 0, 50, 50))
-
-        The gradient will be 1 (1 meter up for every meter forward).
-        The calculation is by default done in place to save memory.
-
-        >>> r.gradient()
-        >>> r.array
-        array([[0., 1., 1., 1., 0.],
-            [1., 1., 1., 1., 1.],
-            [1., 1., 0., 1., 1.],
-            [1., 1., 1., 1., 1.],
-            [0., 1., 1., 1., 0.]])
-        """
-        return get_gradient(self, degrees=degrees, copy=copy)
-
     def to_xarray(self) -> DataArray:
+        """Convert the raster to  an xarray.DataArray."""
         self._check_for_array()
         self.name = self.name or self.__class__.__name__.lower()
         coords = _generate_spatial_coords(self.transform, self.width, self.height)
-        if len(self.array.shape) == 2:
+        if len(self.values.shape) == 2:
             dims = ["y", "x"]
             # dims = ["band", "y", "x"]
-            # array = np.array([self.array])
+            # array = np.array([self.values])
             # assert len(array.shape) == 3
-        elif len(self.array.shape) == 3:
+        elif len(self.values.shape) == 3:
             dims = ["band", "y", "x"]
-            # array = self.array
+            # array = self.values
         else:
             raise ValueError("Array must be 2 or 3 dimensional.")
         return xr.DataArray(
-            self.array,
+            self.values,
             coords=coords,
             dims=dims,
             name=self.name,
@@ -602,6 +622,7 @@ class Raster:
         )  # .transpose("y", "x")
 
     def to_dict(self) -> dict:
+        """Get a dictionary of Raster attributes."""
         out = {}
         for col in self.ALL_ATTRS:
             try:
@@ -642,11 +663,11 @@ class Raster:
             column = [column] * len(array_list)
 
         gdfs = []
-        for i, (column, array) in enumerate(zip(column, array_list, strict=True)):
+        for i, (col, array) in enumerate(zip(column, array_list, strict=True)):
             gdf = gpd.GeoDataFrame(
                 pd.DataFrame(
                     self._array_to_geojson(array, self.transform),
-                    columns=[column, "geometry"],
+                    columns=[col, "geometry"],
                 ),
                 geometry="geometry",
                 crs=self.crs,
@@ -658,20 +679,20 @@ class Raster:
 
     def set_crs(
         self,
-        crs,
+        crs: pyproj.CRS | Any,
         allow_override: bool = False,
     ) -> Self:
         """Set coordinate reference system."""
         if not allow_override and self.crs is not None:
             raise ValueError("Cannot overwrite crs when allow_override is False.")
 
-        if self.array is None:
+        if self.values is None:
             raise ValueError("array must be loaded/clipped before set_crs")
 
         self._crs = pyproj.CRS(crs)
         return self
 
-    def to_crs(self, crs, **kwargs) -> Self:
+    def to_crs(self, crs: pyproj.CRS | Any, **kwargs) -> Self:
         """Reproject the raster.
 
         Args:
@@ -687,7 +708,7 @@ class Raster:
         # ):
         #     return self
 
-        if self.array is None:
+        if self.values is None:
             project = pyproj.Transformer.from_crs(
                 pyproj.CRS(self._prev_crs), pyproj.CRS(crs), always_xy=True
             ).transform
@@ -719,16 +740,16 @@ class Raster:
             # self._bounds = shapely.transform(old_box, project)
         else:
             was_2d = len(self.shape) == 2
-            self.array, transform = reproject(
-                source=self.array,
+            self.values, transform = reproject(
+                source=self.values,
                 src_crs=self._prev_crs,
                 src_transform=self.transform,
                 dst_crs=pyproj.CRS(crs),
                 **kwargs,
             )
-            if was_2d and len(self.array.shape) == 3:
-                assert self.array.shape[0] == 1
-                self.array = self.array[0]
+            if was_2d and len(self.values.shape) == 3:
+                assert self.values.shape[0] == 1
+                self.values = self.values[0]
 
             self._bounds = rasterio.transform.array_bounds(
                 self.height, self.width, transform
@@ -739,18 +760,18 @@ class Raster:
 
         return self
 
-    def plot(self, mask=None) -> None:
-        self._check_for_array()
+    def plot(self, mask: Any | None = None) -> None:
         """Plot the images. One image per band."""
+        self._check_for_array()
         if mask is not None:
             raster = self.copy().clip(mask)
         else:
             raster = self
 
         if len(raster.shape) == 2:
-            array = np.array([raster.array])
+            array = np.array([raster.values])
         else:
-            array = raster.array
+            array = raster.values
 
         for arr in array:
             ax = plt.axes()
@@ -760,28 +781,32 @@ class Raster:
             plt.close()
 
     def astype(self, dtype: type) -> Self:
-        if self.array is None:
+        """Convert the datatype of the array."""
+        if self.values is None:
             raise ValueError("Array is not loaded.")
-        if not rasterio.dtypes.can_cast_dtype(self.array, dtype):
-            min_dtype = rasterio.dtypes.get_minimum_dtype(self.array)
+        if not rasterio.dtypes.can_cast_dtype(self.values, dtype):
+            min_dtype = rasterio.dtypes.get_minimum_dtype(self.values)
             raise ValueError(f"Cannot cast to dtype. Minimum dtype is {min_dtype}")
-        self.array = self.array.astype(dtype)
+        self.values = self.values.astype(dtype)
         self._dtype = dtype
         return self
 
     def as_minimum_dtype(self) -> Self:
-        min_dtype = rasterio.dtypes.get_minimum_dtype(self.array)
-        self.array = self.array.astype(min_dtype)
+        """Convert the array to the minimum dtype without overflow."""
+        min_dtype = rasterio.dtypes.get_minimum_dtype(self.values)
+        self.values = self.values.astype(min_dtype)
         return self
 
     def min(self) -> int | None:
-        if np.size(self.array):
-            return np.min(self.array)
+        """Minimum value in the array."""
+        if np.size(self.values):
+            return np.min(self.values)
         return None
 
     def max(self) -> int | None:
-        if np.size(self.array):
-            return np.max(self.array)
+        """Maximum value in the array."""
+        if np.size(self.values):
+            return np.max(self.values)
         return None
 
     def _add_meta(self) -> Self:
@@ -798,20 +823,23 @@ class Raster:
         return self
 
     def array_list(self) -> list[np.ndarray]:
+        """Get a list of 2D arrays."""
         self._check_for_array()
-        if len(self.array.shape) == 2:
-            return [self.array]
-        elif len(self.array.shape) == 3:
-            return list(self.array)
+        if len(self.values.shape) == 2:
+            return [self.values]
+        elif len(self.values.shape) == 3:
+            return list(self.values)
         else:
             raise ValueError
 
     @property
     def indexes(self) -> int | tuple[int] | None:
+        """Band indexes of the image."""
         return self._indexes
 
     @property
     def name(self) -> str | None:
+        """Name of the file in the file path, if any."""
         try:
             return self._name
         except AttributeError:
@@ -821,35 +849,30 @@ class Raster:
                 return None
 
     @name.setter
-    def name(self, value):
+    def name(self, value) -> None:
         self._name = value
-        return self._name
 
     @property
-    def date(self):
+    def date(self) -> str | None:
+        """Date in the image file name, if filename_regex is present."""
         try:
-            pattern = re.compile(self.filename_regex, re.VERBOSE)
-            return re.match(pattern, Path(self.path).name).group("date")
+            return re.match(self.filename_pattern, Path(self.path).name).group("date")
         except (AttributeError, TypeError):
             return None
 
     @property
     def band(self) -> str | None:
+        """Band name of the image file name, if filename_regex is present."""
         try:
-            pattern = re.compile(self.filename_regex, re.VERBOSE)
-            return re.match(pattern, Path(self.path).name).group("band")
+            return re.match(self.filename_pattern, Path(self.path).name).group("band")
         except (AttributeError, TypeError):
             return None
 
-    # @property
-    # def band_color(self):
-    #     """To be implemented in subclasses."""
-    #     pass
-
     @property
-    def dtype(self):
+    def dtype(self) -> Any:
+        """Data type of the array."""
         try:
-            return self.array.dtype
+            return self.values.dtype
         except AttributeError:
             try:
                 return self._dtype
@@ -857,12 +880,12 @@ class Raster:
                 return None
 
     @dtype.setter
-    def dtype(self, new_dtype):
-        self.array = self.array.astype(new_dtype)
-        return self.array.dtype
+    def dtype(self, new_dtype: Any) -> None:
+        self.values = self.values.astype(new_dtype)
 
     @property
     def nodata(self) -> int | None:
+        """No data value."""
         try:
             return self._nodata
         except AttributeError:
@@ -870,12 +893,15 @@ class Raster:
 
     @property
     def tile(self) -> str | None:
-        if self.bounds is None:
+        """Tile name from regex."""
+        try:
+            return re.match(self.filename_pattern, Path(self.path).name).group("tile")
+        except (AttributeError, TypeError):
             return None
-        return f"{int(self.bounds[0])}_{int(self.bounds[1])}"
 
     @property
     def meta(self) -> dict:
+        """Metadata dict."""
         return {
             "path": self.path,
             "type": self.__class__.__name__,
@@ -886,6 +912,7 @@ class Raster:
 
     @property
     def profile(self) -> dict:
+        """Profile of the image file."""
         # TODO: .crs blir feil hvis warpa. Eller?
         return {
             "driver": self.driver,
@@ -902,14 +929,16 @@ class Raster:
 
     @property
     def read_kwargs(self) -> dict:
+        """Keywords passed to the read method of rasterio.io.DatasetReader."""
         return {
             "indexes": self.indexes,
             "fill_value": self.nodata,
-            "masked": True,
+            "masked": False,
         }
 
     @property
     def res(self) -> float | None:
+        """Get the spatial resolution of the image."""
         if hasattr(self, "_res") and self._res is not None:
             return self._res
         if self.width is None:
@@ -919,17 +948,19 @@ class Raster:
 
     @property
     def height(self) -> int | None:
-        if self.array is None:
+        """Get the height of the image as number of pixels."""
+        if self.values is None:
             try:
                 return self._height
             except AttributeError:
                 return None
-        i = 1 if len(self.array.shape) == 3 else 0
-        return self.array.shape[i]
+        i = 1 if len(self.values.shape) == 3 else 0
+        return self.values.shape[i]
 
     @property
     def width(self) -> int | None:
-        if self.array is None:
+        """Get the width of the image as number of pixels."""
+        if self.values is None:
             try:
                 return self._width
             except AttributeError:
@@ -940,15 +971,16 @@ class Raster:
                     return self._width
                 except Exception:
                     return None
-        i = 2 if len(self.array.shape) == 3 else 1
-        return self.array.shape[i]
+        i = 2 if len(self.values.shape) == 3 else 1
+        return self.values.shape[i]
 
     @property
     def count(self) -> int:
-        if self.array is not None:
-            if len(self.array.shape) == 3:
-                return self.array.shape[0]
-            if len(self.array.shape) == 2:
+        """Get the number of bands in the image."""
+        if self.values is not None:
+            if len(self.values.shape) == 3:
+                return self.values.shape[0]
+            if len(self.values.shape) == 2:
                 return 1
         if not hasattr(self._indexes, "__iter__"):
             return 1
@@ -957,14 +989,15 @@ class Raster:
     @property
     def shape(self) -> tuple[int]:
         """Shape that is consistent with the array, whether it is loaded or not."""
-        if self.array is not None:
-            return self.array.shape
+        if self.values is not None:
+            return self.values.shape
         if hasattr(self._indexes, "__iter__"):
             return self.count, self.width, self.height
         return self.width, self.height
 
     @property
     def transform(self) -> Affine | None:
+        """Get the Affine transform of the image."""
         try:
             return rasterio.transform.from_bounds(*self.bounds, self.width, self.height)
         except (ZeroDivisionError, TypeError):
@@ -973,13 +1006,15 @@ class Raster:
 
     @property
     def bounds(self) -> tuple[float, float, float, float] | None:
+        """Get the bounds of the image."""
         try:
             return to_bbox(self._bounds)
         except (AttributeError, TypeError):
             return None
 
     @property
-    def crs(self):
+    def crs(self) -> pyproj.CRS | None:
+        """Get the coordinate reference system of the image."""
         try:
             return self._warped_crs
         except AttributeError:
@@ -990,24 +1025,29 @@ class Raster:
 
     @property
     def area(self) -> float:
+        """Get the area of the image."""
         return shapely.area(self.unary_union)
 
     @property
     def length(self) -> float:
+        """Get the circumfence of the image."""
         return shapely.length(self.unary_union)
 
     @property
     def unary_union(self) -> Polygon:
+        """Get the image bounds as a Polygon."""
         return shapely.box(*self.bounds)
 
     @property
     def centroid(self) -> Point:
+        """Get the centerpoint of the image."""
         x = (self.bounds[0] + self.bounds[2]) / 2
         y = (self.bounds[1] + self.bounds[3]) / 2
         return Point(x, y)
 
     @property
     def properties(self) -> list[str]:
+        """List of all properties of the class."""
         out = []
         for attr in dir(self):
             try:
@@ -1018,11 +1058,12 @@ class Raster:
         return out
 
     def indexes_as_tuple(self) -> tuple[int, ...]:
+        """Get the band index(es) as a tuple of integers."""
         if len(self.shape) == 2:
             return (1,)
         return tuple(i + 1 for i in range(self.shape[0]))
 
-    def copy(self, deep=True):
+    def copy(self, deep: bool = True) -> "Raster":
         """Returns a (deep) copy of the class instance.
 
         Args:
@@ -1033,14 +1074,15 @@ class Raster:
         else:
             return copy(self)
 
-    def equals(self, other) -> bool:
+    def equals(self, other: Any) -> bool:
+        """Check if the Raster is equal to another Raster."""
         if not isinstance(other, Raster):
             raise NotImplementedError("other must be of type Raster")
         if type(other) != type(self):
             return False
-        if self.array is None and other.array is not None:
+        if self.values is None and other.values is not None:
             return False
-        if self.array is not None and other.array is None:
+        if self.values is not None and other.values is None:
             return False
 
         for method in dir(self):
@@ -1049,7 +1091,7 @@ class Raster:
             if getattr(self, method) != getattr(other, method):
                 return False
 
-        return np.array_equal(self.array, other.array)
+        return np.array_equal(self.values, other.values)
 
     def __repr__(self) -> str:
         """The print representation."""
@@ -1059,39 +1101,55 @@ class Raster:
             res = int(self.res)
         except TypeError:
             res = None
-        return f"{self.__class__.__name__}(shape=({shp}), res={res}, name={self.name}, path={self.path})"
+        return f"{self.__class__.__name__}(shape=({shp}), res={res}, band={self.band})"
+
+    def __iter__(self) -> Iterator[np.ndarray]:
+        """Iterate over the arrays."""
+        if len(self.values.shape) == 2:
+            return iter([self.values])
+        if len(self.values.shape) == 3:
+            return iter(self.values)
+        raise ValueError(
+            f"Array should have shape length 2 or 3. Got {len(self.values.shape)}"
+        )
 
-    def __mul__(self, scalar):
+    def __mul__(self, scalar: int | float) -> "Raster":
+        """Multiply the array values with *."""
         self._check_for_array()
-        self.array = self.array * scalar
+        self.values = self.values * scalar
         return self
 
-    def __add__(self, scalar):
+    def __add__(self, scalar: int | float) -> "Raster":
+        """Add to the array values with +."""
         self._check_for_array()
-        self.array = self.array + scalar
+        self.values = self.values + scalar
         return self
 
-    def __sub__(self, scalar):
+    def __sub__(self, scalar: int | float) -> "Raster":
+        """Subtract the array values with -."""
         self._check_for_array()
-        self.array = self.array - scalar
+        self.values = self.values - scalar
         return self
 
-    def __truediv__(self, scalar):
+    def __truediv__(self, scalar: int | float) -> "Raster":
+        """Divide the array values with /."""
         self._check_for_array()
-        self.array = self.array / scalar
+        self.values = self.values / scalar
         return self
 
-    def __floordiv__(self, scalar):
+    def __floordiv__(self, scalar: int | float) -> "Raster":
+        """Floor divide the array values with //."""
         self._check_for_array()
-        self.array = self.array // scalar
+        self.values = self.values // scalar
         return self
 
-    def __pow__(self, exponent):
+    def __pow__(self, exponent: int | float) -> "Raster":
+        """Exponentiate the array values with **."""
         self._check_for_array()
-        self.array = self.array**exponent
+        self.values = self.values**exponent
         return self
 
-    def _has_nessecary_attrs(self, dict_like) -> bool:
+    def _has_nessecary_attrs(self, dict_like: dict) -> bool:
         """Check if Raster init got enough kwargs to not need to read src."""
         try:
             self._validate_dict(dict_like)
@@ -1101,17 +1159,17 @@ class Raster:
         except AttributeError:
             return False
 
-    def _return_self_or_copy(self, array, copy: bool):
+    def _return_self_or_copy(self, array: np.ndarray, copy: bool) -> "Raster":
         if not copy:
-            self.array = array
+            self.values = array
             return self
         else:
             copy = self.copy()
-            copy.array = array
+            copy.values = array
             return copy
 
     @classmethod
-    def _validate_dict(cls, dict_like) -> None:
+    def _validate_dict(cls, dict_like: dict) -> None:
         missing = []
         for attr in NESSECARY_META:
             if any(
@@ -1127,14 +1185,14 @@ class Raster:
             raise AttributeError(f"Missing nessecary key(s) {', '.join(missing)}")
 
     @classmethod
-    def _validate_key(cls, key) -> None:
+    def _validate_key(cls, key: str) -> None:
         if key not in ALLOWED_KEYS:
             raise ValueError(
                 f"Got an unexpected key {key!r}. Allowed keys are ",
                 ", ".join(ALLOWED_KEYS),
             )
 
-    def _get_shape_from_res(self, res) -> tuple[int] | None:
+    def _get_shape_from_res(self, res: int) -> tuple[int] | None:
         if res is None:
             return None
         if hasattr(res, "__iter__") and len(res) == 2:
@@ -1147,36 +1205,38 @@ class Raster:
             return len(self.indexes), width, height
         return width, height
 
-    def _write(self, dst, window):
-        if np.ma.is_masked(self.array):
-            if len(self.array.shape) == 2:
+    def _write(
+        self, dst: rasterio.io.DatasetReader, window: rasterio.windows.Window
+    ) -> None:
+        if np.ma.is_masked(self.values):
+            if len(self.values.shape) == 2:
                 return dst.write(
-                    self.array.filled(self.nodata), indexes=1, window=window
+                    self.values.filled(self.nodata), indexes=1, window=window
                 )
 
             for i in range(len(self.indexes_as_tuple())):
                 dst.write(
-                    self.array[i].filled(self.nodata),
+                    self.values[i].filled(self.nodata),
                     indexes=i + 1,
                     window=window,
                 )
 
         else:
-            if len(self.array.shape) == 2:
-                return dst.write(self.array, indexes=1, window=window)
+            if len(self.values.shape) == 2:
+                return dst.write(self.values, indexes=1, window=window)
 
             for i, idx in enumerate(self.indexes_as_tuple()):
-                dst.write(self.array[i], indexes=idx, window=window)
+                dst.write(self.values[i], indexes=idx, window=window)
 
-    def _get_indexes(self, indexes):
+    def _get_indexes(self, indexes: int | tuple[int] | None) -> int | tuple[int] | None:
         if isinstance(indexes, numbers.Number):
             return int(indexes)
         if indexes is None:
-            if self.array is not None and len(self.array.shape) == 3:
-                return tuple(i + 1 for i in range(self.array.shape[0]))
-            elif self.array is not None and len(self.array.shape) == 2:
+            if self.values is not None and len(self.values.shape) == 3:
+                return tuple(i + 1 for i in range(self.values.shape[0]))
+            elif self.values is not None and len(self.values.shape) == 2:
                 return 1
-            elif self.array is not None:
+            elif self.values is not None:
                 raise ValueError("Array must be 2 or 3 dimensional.")
             else:
                 return None
@@ -1188,7 +1248,7 @@ class Raster:
                 f"Got {type(indexes)}: {indexes}"
             ) from e
 
-    def _return_gdf(self, obj) -> GeoDataFrame:
+    def _return_gdf(self, obj: Any) -> GeoDataFrame:
         if isinstance(obj, str) and not is_wkt(obj):
             return self._read_tif(obj)
         elif isinstance(obj, Raster):
@@ -1210,34 +1270,42 @@ class Raster:
             warnings.filterwarnings("ignore", category=UserWarning)
             return [
                 (feature["geometry"], val)
-                for val, feature in zip(gdf[column], loads(gdf.to_json())["features"])
+                for val, feature in zip(
+                    gdf[column], loads(gdf.to_json())["features"], strict=False
+                )
             ]
 
     @staticmethod
-    def _array_to_geojson(array: np.ndarray, transform: Affine):
+    def _array_to_geojson(array: np.ndarray, transform: Affine) -> list[tuple]:
+        if np.ma.is_masked(array):
+            array = array.data
         try:
             return [
                 (value, shape(geom))
-                for geom, value in features.shapes(array, transform=transform)
+                for geom, value in features.shapes(
+                    array, transform=transform, mask=None
+                )
             ]
         except ValueError:
             array = array.astype(np.float32)
             return [
                 (value, shape(geom))
-                for geom, value in features.shapes(array, transform=transform)
+                for geom, value in features.shapes(
+                    array, transform=transform, mask=None
+                )
             ]
 
-    def _add_indexes_from_array(self, indexes):
+    def _add_indexes_from_array(self, indexes: int | tuple[int]) -> int | tuple[int]:
         if indexes is not None:
             return indexes
-        elif len(self.array.shape) == 3:
-            return tuple(x + 1 for x in range(len(self.array)))
-        elif len(self.array.shape) == 2:
+        elif len(self.values.shape) == 3:
+            return tuple(x + 1 for x in range(len(self.values)))
+        elif len(self.values.shape) == 2:
             return 1
         else:
             raise ValueError
 
-    def _add_meta_from_src(self, src):
+    def _add_meta_from_src(self, src: rasterio.io.DatasetReader) -> None:
         if not hasattr(self, "_bounds") or self._bounds is None:
             self._bounds = tuple(src.bounds)
 
@@ -1259,10 +1327,15 @@ class Raster:
         #     except AttributeError:
         #         pass
 
-        for attr in ["_indexes", "_nodata"]:
-            if not hasattr(self, attr) or getattr(self, attr) is None:
-                new_value = getattr(src, attr.replace("_", ""))
-                setattr(self, attr, new_value)
+        if not hasattr(self, "_indexes") or self._indexes is None:
+            new_value = src.indexes
+            if new_value == 1 or new_value == (1,):
+                new_value = 1
+            self._indexes = new_value
+
+        if not hasattr(self, "_nodata") or self._nodata is None:
+            new_value = src.nodata
+            self._nodata = new_value
 
         # if not hasattr(self, "_indexes") or self._indexes is None:
         #     self._indexes = src.indexes
@@ -1293,7 +1366,7 @@ class Raster:
         return self._read(self.path, **kwargs)
 
     @functools.lru_cache(maxsize=128)
-    def _read(self, path, **kwargs):
+    def _read(self, path: str | Path, **kwargs) -> None:
         with opener(path, file_system=self.file_system) as file:
             with rasterio.open(file) as src:
                 self._add_meta_from_src(src)
@@ -1302,7 +1375,7 @@ class Raster:
                 if hasattr(self, "_warped_crs"):
                     src = WarpedVRT(src, crs=self.crs)
 
-                self.array = src.read(
+                self.values = src.read(
                     out_shape=out_shape,
                     **(self.read_kwargs | kwargs),
                 )
@@ -1311,7 +1384,9 @@ class Raster:
                 else:
                     self = self.as_minimum_dtype()
 
-    def _read_with_mask(self, mask, masked, boundless, **kwargs):
+    def _read_with_mask(
+        self, mask: Any, masked: bool, boundless: bool, **kwargs
+    ) -> None:
         kwargs["mask"] = mask
 
         def _read(self, src, mask, **kwargs):
@@ -1332,11 +1407,17 @@ class Raster:
             if hasattr(self, "_warped_crs"):
                 src = WarpedVRT(src, crs=self.crs)
 
-            self.array = src.read(out_shape=out_shape, **kwargs)
+            self.values = src.read(out_shape=out_shape, **kwargs)
 
             if not masked:
-                self.array[self.array.mask] = self.nodata
-                self.array = self.array.data
+                try:
+                    self.values[self.values.mask] = self.nodata
+                    self.values = self.values.data
+                except AttributeError:
+                    pass
+                    # self.values = np.ma.masked_array(self.values, mask=mask)
+                    # self.values[self.values.mask] = self.nodata
+                    # self.values = self.values.data
 
             if boundless:
                 self._bounds = src.window_bounds(window=window)
@@ -1347,7 +1428,7 @@ class Raster:
                 else:
                     self._bounds = intersected.bounds
 
-            if not np.size(self.array):
+            if not np.size(self.values):
                 return
 
             if self._dtype:
@@ -1355,8 +1436,8 @@ class Raster:
             else:
                 self = self.as_minimum_dtype()
 
-        if self.array is not None:
-            with memfile_from_array(self.array, **self.profile) as src:
+        if self.values is not None:
+            with memfile_from_array(self.values, **self.profile) as src:
                 _read(self, src, **kwargs)
         else:
             with opener(self.path, file_system=self.file_system) as file:
@@ -1364,7 +1445,7 @@ class Raster:
                     _read(self, src, **kwargs)
 
     def _check_for_array(self, text=""):
-        if self.array is None:
+        if self.values is None:
             raise ValueError("Arrays are not loaded. " + text)