ssb-sgis 1.0.12__tar.gz → 1.0.13__tar.gz

{ssb_sgis-1.0.12 → ssb_sgis-1.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ssb-sgis
-Version: 1.0.12
+Version: 1.0.13
 Summary: GIS functions used at Statistics Norway.
 Home-page: https://github.com/statisticsnorway/ssb-sgis
 License: MIT

{ssb_sgis-1.0.12 → ssb_sgis-1.0.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ssb-sgis"
-version = "1.0.12"
+version = "1.0.13"
 description = "GIS functions used at Statistics Norway."
 authors = ["Morten Letnes <morten.letnes@ssb.no>"]
 license = "MIT"

{ssb_sgis-1.0.12 → ssb_sgis-1.0.13}/src/sgis/maps/explore.py

@@ -183,7 +183,9 @@ def to_tile(tile: str | xyzservices.TileProvider, max_zoom: int) -> folium.TileL
     return folium.TileLayer(provider, name=name, attr=attr, max_zoom=max_zoom)
 
 
-def _single_band_to_arr(band, mask, name, raster_data_dict):
+def _single_band_to_arr_is_too_much_nodata(
+    band, mask, name, raster_data_dict, max_nodata_percentage
+) -> bool:
     if band.has_array and mask is None:
         arr = band.values
     elif band.has_array:
@@ -191,8 +193,8 @@ def _single_band_to_arr(band, mask, name, raster_data_dict):
     else:
         arr = band.load(indexes=1, bounds=mask).values
 
-    if _is_too_much_nodata([arr], band.nodata):
-        return False
+    if _is_too_much_nodata([arr], band.nodata, max_nodata_percentage):
+        return True
 
     bounds: tuple = (
         _any_to_bbox_crs4326(mask, band.crs)
@@ -216,25 +218,28 @@ def _single_band_to_arr(band, mask, name, raster_data_dict):
     except Exception:
         raster_data_dict["date"] = None
 
-    return True
+    return False
 
 
 def _is_too_much_nodata(
     arrays: list[np.ndarray],
-    nodata: int | None = None,
-    max_nodata_percentage: int = 100,
+    nodata: int | None,
+    max_nodata_percentage: int,
 ) -> bool:
     return (
         any(arr.shape[0] == 0 for arr in arrays)
         or any(
             (
                 isinstance(arr, np.ma.core.MaskedArray)
-                and np.mean((arr.mask) | (arr.data == nodata) | (np.isnan(arr.data)))
+                and np.mean(((arr.mask) | (arr.data == nodata) | (np.isnan(arr.data))))
                 > (max_nodata_percentage / 100)
             )
             for arr in arrays
         )
-        or any(np.mean(arr == nodata) > (max_nodata_percentage / 100) for arr in arrays)
+        or any(
+            np.mean((arr == nodata) | (np.isnan(arr))) > (max_nodata_percentage / 100)
+            for arr in arrays
+        )
     )
 
 
@@ -271,6 +276,7 @@ class Explore(Map):
         decimals: int = 6,
         max_images: int = 10,
         max_nodata_percentage: int = 100,
+        display: bool = True,
         **kwargs,
     ) -> None:
         """Initialiser.
@@ -299,6 +305,7 @@ class Explore(Map):
             decimals: Number of decimals in the coordinates.
             max_nodata_percentage: Maximum percentage nodata values (e.g. clouds) ro allow in
                 image arrays.
+            display: Whether to display the map interactively.
             **kwargs: Additional keyword arguments. Can also be geometry-like objects
                 where the key is the label.
         """
@@ -314,6 +321,7 @@ class Explore(Map):
         self.decimals = decimals
         self.max_images = max_images
         self.max_nodata_percentage = max_nodata_percentage
+        self.display = display
         self.legend = None
 
         self.browser = browser
@@ -457,8 +465,7 @@ class Explore(Map):
 
         if center is None:
             self.to_show = self._gdfs
-            self._explore(**kwargs)
-            return
+            return self._explore(**kwargs)
 
         size = size if size else 1000
 
@@ -622,6 +629,8 @@ class Explore(Map):
                 f.write(self.map._repr_html_())
         elif self.browser:
             run_html_server(self.map._repr_html_())
+        elif not self.display:
+            return
         else:
             display(self.map)
 
@@ -1345,7 +1354,10 @@ def _add_one_image(
     if len(image) < 3:
         for band in image:
             name = _determine_label(band, band.name or name)
-            _single_band_to_arr(band, mask, name, raster_data_dict)
+            if _single_band_to_arr_is_too_much_nodata(
+                band, mask, name, raster_data_dict, max_nodata_percentage
+            ):
+                return
         return raster_data_dict
 
     def load(band_id: str) -> Band:
@@ -1428,8 +1440,10 @@ def _image_collection_to_background_map(
             return out
 
         raster_data_dict = {}
-        out.append(raster_data_dict)
-        _single_band_to_arr(band, mask, name, raster_data_dict)
+        if not _single_band_to_arr_is_too_much_nodata(
+            band, mask, name, raster_data_dict, max_nodata_percentage
+        ):
+            out.append(raster_data_dict)
         return out
 
     else:
@@ -1462,7 +1476,7 @@ def _image_collection_to_background_map(
                 continue
             i = 1
             while x["label"] in {y["label"] for y in out}:
-                x["label"] = x["label"].rstrip(f"_{i}", "") + f"_{i + 1}"
+                x["label"] = x["label"].rstrip(f"_{i}") + f"_{i + 1}"
                 i += 1
 
             n_added_images += 1

{ssb_sgis-1.0.12 → ssb_sgis-1.0.13}/src/sgis/raster/image_collection.py

@@ -499,6 +499,14 @@ class _ImageBase:
             "metadata": self.metadata,
         }
 
+    @property
+    def _common_init_kwargs_after_load(self) -> dict:
+        return {
+            k: v
+            for k, v in self._common_init_kwargs.items()
+            if k not in {"res", "metadata"}
+        }
+
     @property
     def path(self) -> str:
         try:
@@ -1136,8 +1144,8 @@ class Band(_ImageBandBase):
                 if self.nodata is None or np.isnan(self.nodata):
                     self.nodata = src.nodata
                 else:
-                    dtype_min_value = _get_dtype_min(src.dtypes[0])
-                    dtype_max_value = _get_dtype_max(src.dtypes[0])
+                    dtype_min_value = _get_dtype_min_value(src.dtypes[0])
+                    dtype_max_value = _get_dtype_max_value(src.dtypes[0])
                     if self.nodata > dtype_max_value or self.nodata < dtype_min_value:
                         src._dtypes = tuple(
                             rasterio.dtypes.get_minimum_dtype(self.nodata)
@@ -1240,17 +1248,17 @@ class Band(_ImageBandBase):
         if self.crs is None:
             raise ValueError("Cannot write None crs to image.")
 
-        if self.nodata:
-            # TODO take out .data if masked?
-            values_with_nodata = np.concatenate(
-                [self.values.flatten(), np.array([self.nodata])]
-            )
-        else:
-            values_with_nodata = self.values
+        try:
+            data = self.values.data
+        except AttributeError:
+            data = self.values
+        data = np.array([np.min(data), np.max(data), self.nodata or 0])
+        min_dtype = rasterio.dtypes.get_minimum_dtype(data)
+
         profile = {
             "driver": driver,
             "compress": compress,
-            "dtype": rasterio.dtypes.get_minimum_dtype(values_with_nodata),
+            "dtype": min_dtype,
             "crs": self.crs,
             "transform": self.transform,
             "nodata": self.nodata,
@@ -1263,7 +1271,7 @@ class Band(_ImageBandBase):
             with rasterio.open(f, "w", **profile) as dst:
 
                 if dst.nodata is None:
-                    dst.nodata = _get_dtype_min(dst.dtypes[0])
+                    dst.nodata = _get_dtype_min_value(dst.dtypes[0])
 
                 if (
                     isinstance(self.values, np.ma.core.MaskedArray)
@@ -1515,12 +1523,6 @@ class NDVIBand(Band):
     cmap: str = "Greens"
 
 
-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)
-    return arr.astype(min_dtype)
-
-
 class Image(_ImageBandBase):
     """Image consisting of one or more Bands."""
 
@@ -1742,7 +1744,7 @@ class Image(_ImageBandBase):
             arr,
             bounds=red.bounds,
             crs=red.crs,
-            **{k: v for k, v in red._common_init_kwargs.items() if k != "res"},
+            **red._common_init_kwargs_after_load,
         )
 
     def get_brightness(
@@ -1773,7 +1775,7 @@ class Image(_ImageBandBase):
             brightness,
             bounds=red.bounds,
             crs=self.crs,
-            **{k: v for k, v in self._common_init_kwargs.items() if k != "res"},
+            **self._common_init_kwargs_after_load,
         )
 
     def to_xarray(self) -> DataArray:
@@ -2102,7 +2104,7 @@ class ImageCollection(_ImageBase):
 
         for attr in by:
             if attr == "bounds":
-                # need integers to check equality when grouping
+                # need integers to properly check equality when grouping
                 df[attr] = [
                     tuple(int(x) for x in band.bounds) for img in self for band in img
                 ]
@@ -2322,9 +2324,8 @@ class ImageCollection(_ImageBase):
             arr,
             bounds=bounds,
             crs=crs,
-            **{k: v for k, v in self._common_init_kwargs.items() if k != "res"},
+            **self._common_init_kwargs_after_load,
         )
-
         band._merged = True
         return band
 
@@ -2390,19 +2391,20 @@ class ImageCollection(_ImageBase):
 
             arrs.append(arr)
             bands.append(
-                self.band_class(
+                # self.band_class(
+                Band(
                     arr,
                     bounds=out_bounds,
                     crs=crs,
                     band_id=band_id,
-                    **{k: v for k, v in self._common_init_kwargs.items() if k != "res"},
+                    **self._common_init_kwargs_after_load,
                 )
             )
 
         # return self.image_class( # TODO
         image = Image(
             bands,
-            band_class=self.band_class,
+            # band_class=self.band_class,
             **self._common_init_kwargs,
         )
 
@@ -2431,25 +2433,17 @@ class ImageCollection(_ImageBase):
                 continue
 
             _bounds = to_bbox(_bounds)
-            arr = np.array(
-                [
-                    (
-                        # band.load(
-                        #     bounds=(_bounds if _bounds is not None else None),
-                        #     **kwargs,
-                        # )
-                        # if not band.has_array
-                        # else
-                        band
-                    ).values
-                    for img in collection
-                    for band in img
-                ]
-            )
+            collection.load(bounds=(_bounds if _bounds is not None else None), **kwargs)
+            arr = np.array([band.values for img in collection for band in img])
             arr = numpy_func(arr, axis=0)
             if as_int:
                 arr = arr.astype(int)
-                min_dtype = rasterio.dtypes.get_minimum_dtype(arr)
+                try:
+                    data = arr.data
+                except AttributeError:
+                    data = arr
+                data = np.array([np.min(data), np.max(data), self.nodata or 0])
+                min_dtype = rasterio.dtypes.get_minimum_dtype(data)
                 arr = arr.astype(min_dtype)
 
             if len(arr.shape) == 2:
@@ -3429,24 +3423,20 @@ def _date_is_within(
     return False
 
 
-def _get_dtype_min(dtype: str | type) -> int | float:
+def _get_dtype_min_value(dtype: str | type) -> int | float:
     try:
         return np.iinfo(dtype).min
     except ValueError:
         return np.finfo(dtype).min
 
 
-def _get_dtype_max(dtype: str | type) -> int | float:
+def _get_dtype_max_value(dtype: str | type) -> int | float:
     try:
         return np.iinfo(dtype).max
     except ValueError:
         return np.finfo(dtype).max
 
 
-def _intesects(x, other) -> bool:
-    return box(*x.bounds).intersects(other)
-
-
 def _copy_and_add_df_parallel(
     group_values: tuple[Any, ...],
     group_df: pd.DataFrame,