ssb-sgis 1.0.8__py3-none-any.whl → 1.0.9__py3-none-any.whl

sgis/geopandas_tools/conversion.py

@@ -446,12 +446,13 @@ def to_gdf(
     geom_col: str = _find_geometry_column(obj, geometry)  # type: ignore[no-redef]
     index = kwargs.pop("index", None)
 
-    # get done with iterators that get consumed by 'all'
+    # get done with iterators that would get consumed by 'all' later
     if isinstance(obj, Iterator) and not isinstance(obj, Sized):
-        obj = GeoSeries(
-            (_make_one_shapely_geom(g) for g in obj if g is not None), index=index
-        )
-        return GeoDataFrame({geom_col: obj}, geometry=geom_col, crs=crs, **kwargs)
+        obj = list(obj)
+        # obj = GeoSeries(
+        #     (_make_one_shapely_geom(g) for g in obj if g is not None), index=index
+        # )
+        # return GeoDataFrame({geom_col: obj}, geometry=geom_col, crs=crs, **kwargs)
 
     if hasattr(obj, "__len__") and not len(obj):
         return GeoDataFrame({"geometry": []}, crs=crs)

sgis/io/dapla_functions.py

@@ -1,5 +1,7 @@
 """Functions for reading and writing GeoDataFrames in Statistics Norway's GCS Dapla."""
 
+from __future__ import annotations
+
 import json
 import multiprocessing
 import os

sgis/io/opener.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from collections.abc import Generator
 from contextlib import contextmanager
 from typing import Any

sgis/maps/explore.py

@@ -183,9 +183,11 @@ def to_tile(tile: str | xyzservices.TileProvider, max_zoom: int) -> folium.TileL
 
 
 def _single_band_to_arr(band, mask, name, raster_data_dict):
-    try:
+    if band.has_array and mask is None:
         arr = band.values
-    except (ValueError, AttributeError):
+    elif band.has_array:
+        arr = band.clip(mask).values
+    else:
         arr = band.load(indexes=1, bounds=mask).values
     bounds: tuple = (
         _any_to_bbox_crs4326(mask, band.crs)
@@ -533,8 +535,8 @@ class Explore(Map):
                 arr = np.where(arr, 1, 0)
             try:
                 arr = (arr - np.min(arr)) / (np.max(arr) - np.min(arr))
-            except Exception:
-                pass
+            except Exception as e:
+                warnings.warn(str(e), stacklevel=1)
 
             label = raster_data_dict["label"]
             bounds = raster_data_dict["bounds"]
@@ -1066,7 +1068,7 @@ class Explore(Map):
         name: str,
         max_images: int,
         n_added_images: int,
-        rbg_bands: list[str] = (["B02", "B03", "B04"], ["B2", "B3", "B4"]),
+        rbg_bands: list[str] = (("B04", "B02", "B03"), ("B4", "B2", "B3")),
     ) -> tuple[list[dict], int]:
         out = []
 
@@ -1162,17 +1164,25 @@ class Explore(Map):
                     n_added_images += 1
                 continue
 
+            def load(band_id: str) -> Band:
+                band = image[band_id]
+                if band.has_array and mask is not None:
+                    band = band.clip(mask, copy=True)
+                elif not band.has_array:
+                    band = band.load(indexes=1, bounds=mask)
+                return band
+
             for red, blue, green in rbg_bands:
                 try:
-                    red_band = image[red].load(indexes=1, bounds=mask)
+                    red_band = load(red)
                 except KeyError:
                     continue
                 try:
-                    blue_band = image[blue].load(indexes=1, bounds=mask)
+                    blue_band = load(blue)
                 except KeyError:
                     continue
                 try:
-                    green_band = image[green].load(indexes=1, bounds=mask)
+                    green_band = load(green)
                 except KeyError:
                     continue
                 break

sgis/maps/legend.py

@@ -73,8 +73,10 @@ LOWERCASE_WORDS = {
 
 def prettify_label(label: str) -> str:
     """Replace underscores with spaces and capitalize words that are all lowecase."""
+    if len(label) == 1:
+        return label
     return " ".join(
-        word.title() if word.islower() and word not in LOWERCASE_WORDS else word
+        (word.title() if word.islower() and word not in LOWERCASE_WORDS else word)
         for word in label.replace("_", " ").split()
     )
 

sgis/maps/map.py

@@ -232,6 +232,10 @@ class Map:
         self._nan_idx = self._gdf[self._column].isna()
         self._get_unique_values()
 
+    def __getattr__(self, attr: str) -> Any:
+        """Search for attribute in kwargs."""
+        return self.kwargs.get(attr, super().__getattribute__(attr))
+
     def __bool__(self) -> bool:
         """True of any gdfs with more than 0 rows."""
         return bool(len(self._gdfs) + len(self._gdf))

sgis/maps/thematicmap.py

@@ -10,6 +10,8 @@ import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
 
+from ..geopandas_tools.conversion import to_bbox
+from ..helpers import is_property
 from .legend import LEGEND_KWARGS
 from .legend import ContinousLegend
 from .legend import Legend
@@ -37,9 +39,11 @@ MAP_KWARGS = {
     "facecolor",
     "labelcolor",
     "nan_color",
+    # "alpha",
     "title_kwargs",
     "bg_gdf_color",
     "title_position",
+    # "linewidth",
 }
 
 
@@ -49,6 +53,7 @@ class ThematicMap(Map):
     Args:
         *gdfs: One or more GeoDataFrames.
         column: The name of the column to plot.
+        bounds: Optional bounding box for the map.
         title: Title of the plot.
         title_position: Title position. Either "center" (default), "left" or "right".
         size: Width and height of the plot in inches. Fontsize of title and legend is
@@ -155,6 +160,7 @@ class ThematicMap(Map):
         self,
         *gdfs: GeoDataFrame,
         column: str | None = None,
+        bounds: tuple | None = None,
         title: str | None = None,
         title_position: tuple[float, float] | None = None,
         size: int = 25,
@@ -166,7 +172,7 @@ class ThematicMap(Map):
         nan_label: str = "Missing",
         legend_kwargs: dict | None = None,
         title_kwargs: dict | None = None,
-        legend: bool = False,
+        legend: bool = True,
         **kwargs,
     ) -> None:
         """Initialiser."""
@@ -179,9 +185,6 @@ class ThematicMap(Map):
             nan_label=nan_label,
         )
 
-        if not legend:
-            self.legend = None
-
         self.title = title
         self._size = size
         self._dark = dark
@@ -222,21 +225,23 @@ class ThematicMap(Map):
         if not self.cmap and not self._is_categorical:
             self._choose_cmap()
 
+        if not legend:
+            self.legend = None
+        else:
+            self._create_legend()
+
         self._dark_or_light()
-        self._create_legend()
 
         if cmap:
             self._cmap = cmap
 
         for key, value in kwargs.items():
             if key not in MAP_KWARGS:
-                raise TypeError(
-                    f"{self.__class__.__name__} got an unexpected keyword argument {key}"
-                )
-            try:
-                setattr(self, key, value)
-            except Exception:
+                self.kwargs[key] = value
+            elif is_property(self, key):
                 setattr(self, f"_{key}", value)
+            else:
+                setattr(self, key, value)
 
         for key, value in legend_kwargs.items():
             if key not in LEGEND_KWARGS:
@@ -249,6 +254,13 @@ class ThematicMap(Map):
                 except Exception:
                     setattr(self.legend, f"_{key}", value)
 
+        self.bounds = (
+            to_bbox(bounds) if bounds is not None else to_bbox(self._gdf.total_bounds)
+        )
+        self.minx, self.miny, self.maxx, self.maxy = self.bounds
+        self.diffx = self.maxx - self.minx
+        self.diffy = self.maxy - self.miny
+
     @property
     def valid_keywords(self) -> set[str]:
         """List all valid keywords for the class initialiser."""
@@ -285,16 +297,17 @@ class ThematicMap(Map):
             self._background_gdfs = pd.concat(
                 [self._background_gdfs, gdf], ignore_index=True
             )
-        self.minx, self.miny, self.maxx, self.maxy = self._gdf.total_bounds
-        self.diffx = self.maxx - self.minx
-        self.diffy = self.maxy - self.miny
+        if self.bounds is None:
+            self.bounds = to_bbox(self._gdf.total_bounds)
         return self
 
     def plot(self, **kwargs) -> None:
         """Creates the final plot.
 
         This method should be run after customising the map, but before saving.
+
         """
+        kwargs = kwargs | self.kwargs
         __test = kwargs.pop("__test", False)
         include_legend = bool(kwargs.pop("legend", self.legend))
 
@@ -379,6 +392,13 @@ class ThematicMap(Map):
 
         if hasattr(self, "_background_gdfs"):
             self._actually_add_background()
+        elif self.bounds is not None:
+            self.ax.set_xlim(
+                [self.minx - self.diffx * 0.03, self.maxx + self.diffx * 0.03]
+            )
+            self.ax.set_ylim(
+                [self.miny - self.diffy * 0.03, self.maxy + self.diffy * 0.03]
+            )
 
         if self.title:
             self.ax.set_title(
@@ -468,18 +488,10 @@ class ThematicMap(Map):
 
     def _create_legend(self) -> None:
         """Instantiate the Legend class."""
-        if self.legend is None:
-            return
-        kwargs = {}
-        if self._dark:
-            kwargs["facecolor"] = "#0f0f0f"
-            kwargs["labelcolor"] = "#fefefe"
-            kwargs["title_color"] = "#fefefe"
-
         if self._is_categorical:
-            self.legend = Legend(title=self._column, size=self._size, **kwargs)
+            self.legend = Legend(title=self._column, size=self._size)
         else:
-            self.legend = ContinousLegend(title=self._column, size=self._size, **kwargs)
+            self.legend = ContinousLegend(title=self._column, size=self._size)
 
     def _choose_cmap(self) -> None:
         """Kwargs is to catch start and stop points for the cmap in __init__."""
@@ -524,16 +536,32 @@ class ThematicMap(Map):
             if not self._is_categorical:
                 self.change_cmap("viridis")
 
+            if self.legend is not None:
+                for key, color in {
+                    "facecolor": "#0f0f0f",
+                    "labelcolor": "#fefefe",
+                    "title_color": "#fefefe",
+                }.items():
+                    setattr(self.legend, key, color)
+
         else:
             self.facecolor, self.title_color, self.bg_gdf_color = (
                 "#fefefe",
                 "#0f0f0f",
-                "#dbdbdb",
+                "#e8e6e6",
             )
             self.nan_color = "#c2c2c2"
             if not self._is_categorical:
                 self.change_cmap("RdPu", start=23)
 
+            if self.legend is not None:
+                for key, color in {
+                    "facecolor": "#fefefe",
+                    "labelcolor": "#0f0f0f",
+                    "title_color": "#0f0f0f",
+                }.items():
+                    setattr(self.legend, key, color)
+
     @property
     def dark(self) -> bool:
         """Whether to use dark background and light text colors."""
@@ -543,7 +571,6 @@ class ThematicMap(Map):
     def dark(self, new_value: bool):
         self._dark = new_value
         self._dark_or_light()
-        self._create_legend()
 
     @property
     def title_fontsize(self) -> int:

sgis/raster/base.py

@@ -9,6 +9,7 @@ import joblib
 import numpy as np
 import pandas as pd
 import rasterio
+import shapely
 from affine import Affine
 from geopandas import GeoDataFrame
 from geopandas import GeoSeries
@@ -20,8 +21,21 @@ from shapely.geometry import shape
 from ..geopandas_tools.conversion import to_bbox
 
 
+def _get_res_from_bounds(
+    obj: GeoDataFrame | GeoSeries | Geometry | tuple, shape: tuple[int, ...]
+) -> tuple[int, int] | None:
+    minx, miny, maxx, maxy = to_bbox(obj)
+    try:
+        height, width = shape[-2:]
+    except IndexError:
+        return None
+    resx = (maxx - minx) / width
+    resy = (maxy - miny) / height
+    return resx, resy
+
+
 def _get_transform_from_bounds(
-    obj: GeoDataFrame | GeoSeries | Geometry | tuple, shape: tuple[float, ...]
+    obj: GeoDataFrame | GeoSeries | Geometry | tuple, shape: tuple[int, ...]
 ) -> Affine:
     minx, miny, maxx, maxy = to_bbox(obj)
     if len(shape) == 2:
@@ -34,12 +48,16 @@ def _get_transform_from_bounds(
     return rasterio.transform.from_bounds(minx, miny, maxx, maxy, width, height)
 
 
+def _res_as_tuple(res: int | float | tuple[int | float]) -> tuple[int | float]:
+    return (res, res) if isinstance(res, numbers.Number) else res
+
+
 def _get_shape_from_bounds(
     obj: GeoDataFrame | GeoSeries | Geometry | tuple,
     res: int,
     indexes: int | tuple[int],
 ) -> tuple[int, int]:
-    resx, resy = (res, res) if isinstance(res, numbers.Number) else res
+    resx, resy = _res_as_tuple(res)
 
     minx, miny, maxx, maxy = to_bbox(obj)
 
@@ -111,7 +129,9 @@ def _value_geom_pair(value, geom):
 
 def _gdf_to_arr(
     gdf: GeoDataFrame,
-    res: int | float,
+    res: int | float | None = None,
+    out_shape: tuple[int, int] | None = None,
+    bounds: tuple[float] | None = None,
     fill: int = 0,
     all_touched: bool = False,
     merge_alg: Callable = MergeAlg.replace,
@@ -125,6 +145,7 @@ def _gdf_to_arr(
     Args:
         gdf: The GeoDataFrame to rasterize.
         res: Resolution of the raster in units of the GeoDataFrame's coordinate reference system.
+        bounds: Optional bounds to box 'gdf' into (so both clip and extend to).
         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).
@@ -134,6 +155,7 @@ def _gdf_to_arr(
             (default is 1).
         dtype: Data type of the output array. If None, it will be
             determined automatically.
+        out_shape: Optional 2 dimensional shape of the resulting array.
 
     Returns:
         A Raster instance based on the specified GeoDataFrame and parameters.
@@ -142,33 +164,48 @@ def _gdf_to_arr(
         TypeError: If 'transform' is provided in kwargs, as this is
         computed based on the GeoDataFrame bounds and resolution.
     """
+    if res is not None and out_shape is not None:
+        raise TypeError("Cannot specify both 'res' and 'out_shape'")
+    if res is None and out_shape is None:
+        raise TypeError("Must specify either 'res' or 'out_shape'")
+
     if isinstance(gdf, GeoSeries):
-        values = gdf.index
         gdf = gdf.to_frame("geometry")
-    elif isinstance(gdf, GeoDataFrame):
-        if len(gdf.columns) > 2:
-            raise ValueError(
-                "gdf should have only a geometry column and one numeric column to "
-                "use as array values. "
-                "Alternatively only a geometry column and a numeric index."
-            )
-        elif len(gdf.columns) == 1:
-            values = gdf.index
-        else:
-            col: str = next(
-                iter([col for col in gdf if col != gdf._geometry_column_name])
-            )
-            values = gdf[col]
+    elif not isinstance(gdf, GeoDataFrame):
+        raise TypeError(type(gdf))
+
+    if bounds is not None:
+        gdf = gdf.clip(bounds)
+        bounds_gdf = GeoDataFrame({"geometry": [shapely.box(*bounds)]}, crs=gdf.crs)
+
+    if len(gdf.columns) > 2:
+        raise ValueError(
+            "gdf should have only a geometry column and one numeric column to "
+            "use as array values. "
+            "Alternatively only a geometry column and a numeric index."
+        )
+    elif len(gdf.columns) == 1:
+        values = np.full(len(gdf), default_value)
+    else:
+        col: str = next(iter(gdf.columns.difference({gdf.geometry.name})))
+        values = gdf[col].values
+
+    if bounds is not None:
+        gdf = pd.concat([bounds_gdf, gdf])
+        values = np.concatenate([np.array([fill]), values])
+
+    if out_shape is None:
+        assert res is not None
+        out_shape = _get_shape_from_bounds(gdf.total_bounds, res=res, indexes=1)
 
-    if isinstance(values, pd.MultiIndex):
-        raise ValueError("Index cannot be MultiIndex.")
+    if not len(gdf):
+        return np.full(out_shape, fill)
 
-    shape = _get_shape_from_bounds(gdf.total_bounds, res=res, indexes=1)
-    transform = _get_transform_from_bounds(gdf.total_bounds, shape)
+    transform = _get_transform_from_bounds(gdf.total_bounds, out_shape)
 
     return features.rasterize(
         _gdf_to_geojson_with_col(gdf, values),
-        out_shape=shape,
+        out_shape=out_shape,
         transform=transform,
         fill=fill,
         all_touched=all_touched,