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

sgis/networkanalysis/networkanalysis.py

@@ -57,7 +57,7 @@ class NetworkAnalysis:
         log: A DataFrame with information about each analysis run.
 
     Examples:
-    --------
+    ---------
     Read example data.
 
     >>> import sgis as sg
@@ -191,7 +191,7 @@ class NetworkAnalysis:
             straight lines between origin and destination.
 
         Examples:
-        --------
+        ---------
         Create the NetworkAnalysis instance.
 
         >>> import sgis as sg
@@ -479,7 +479,7 @@ class NetworkAnalysis:
                 that contain weights and all indices of 'origins' and 'destinations'.
 
         Examples:
-        --------
+        ---------
         Create the NetworkAnalysis instance.
 
         >>> import sgis as sg
@@ -692,7 +692,7 @@ class NetworkAnalysis:
             containing the indices of the origins and destinations GeoDataFrames.
 
         Examples:
-        --------
+        ---------
         Create the NetworkAnalysis instance.
 
         >>> import sgis as sg
@@ -820,7 +820,7 @@ class NetworkAnalysis:
             ValueError: if drop_middle_percent is not between 0 and 100.
 
         Examples:
-        --------
+        ---------
         Create the NetworkAnalysis instance.
 
         >>> import sgis as sg
@@ -966,7 +966,7 @@ class NetworkAnalysis:
             precice results.
 
         Examples:
-        --------
+        ---------
         Create the NetworkAnalysis instance.
 
         >>> import sgis as sg
@@ -1027,7 +1027,7 @@ class NetworkAnalysis:
 
             if dissolve:
                 results = results.dissolve(by=["origin", self.rules.weight]).loc[
-                    :, ["geometry"]
+                    :, [results.geometry.name]
                 ]
 
             results = results.reset_index()
@@ -1038,7 +1038,7 @@ class NetworkAnalysis:
             ].rename(columns={"temp_idx": "origin"})[["origin"]]
 
             if len(missing):
-                missing["geometry"] = pd.NA
+                missing[results.geometry.name] = pd.NA
                 results = pd.concat([results, missing], ignore_index=True)
 
             results["origin"] = results["origin"].map(self.origins.idx_dict)
@@ -1093,7 +1093,7 @@ class NetworkAnalysis:
             service_area: Faster method where lines are not cut to get precice results.
 
         Examples:
-        --------
+        ---------
         Create the NetworkAnalysis instance.
 
         >>> import sgis as sg
@@ -1151,7 +1151,7 @@ class NetworkAnalysis:
         if not all(results.geometry.isna()):
             if dissolve:
                 results = results.dissolve(by=["origin", self.rules.weight]).loc[
-                    :, ["geometry"]
+                    :, [results.geometry.name]
                 ]
             else:
                 results = results.dissolve(
@@ -1166,7 +1166,7 @@ class NetworkAnalysis:
             ].rename(columns={"temp_idx": "origin"})[["origin"]]
 
             if len(missing):
-                missing["geometry"] = pd.NA
+                missing[results.geometry.name] = pd.NA
                 results = pd.concat([results, missing], ignore_index=True)
 
             results["origin"] = results["origin"].map(self.origins.idx_dict)
@@ -1329,7 +1329,7 @@ class NetworkAnalysis:
                 df["cost_std"] = results[self.rules.weight].std()
 
         if fun == "service_area":
-            df["percent_missing"] = results["geometry"].isna().mean() * 100
+            df["percent_missing"] = results[results.geometry.name].isna().mean() * 100
         else:
             df["destinations_count"] = len(self.destinations.gdf)
 
@@ -1456,7 +1456,7 @@ class NetworkAnalysis:
         else:
             points = self.origins.gdf
 
-        points = points.drop_duplicates("geometry")
+        points = points.drop_duplicates(points.geometry.name)
 
         self.network.gdf["meters_"] = self.network.gdf.length
 
@@ -1573,7 +1573,7 @@ class NetworkAnalysis:
         This method is best stored in the NetworkAnalysis class,
         since the point classes are instantiated each time an analysis is run.
         """
-        if self.wkts[what] != [geom.wkt for geom in points.geometry]:
+        if not np.array_equal(self.wkts[what], points.geometry.to_wkt().values):
             return True
 
         if not all(x in self.graph.vs["name"] for x in list(points.temp_idx.values)):
@@ -1590,17 +1590,15 @@ class NetworkAnalysis:
         """
         self.wkts = {}
 
-        self.wkts["network"] = [geom.wkt for geom in self.network.gdf.geometry]
+        self.wkts["network"] = self.network.gdf.geometry.to_wkt().values
 
         if not hasattr(self, "origins"):
             return
 
-        self.wkts["origins"] = [geom.wkt for geom in self.origins.gdf.geometry]
+        self.wkts["origins"] = self.origins.gdf.geometry.to_wkt().values
 
         if self.destinations is not None:
-            self.wkts["destinations"] = [
-                geom.wkt for geom in self.destinations.gdf.geometry
-            ]
+            self.wkts["destinations"] = self.destinations.gdf.geometry.to_wkt().values
 
     @staticmethod
     def _sort_breaks(breaks: str | list | tuple | int | float) -> list[float | int]:

sgis/networkanalysis/networkanalysisrules.py

@@ -50,7 +50,7 @@ class NetworkAnalysisRules:
             to 1, the weight will be equal to the straigt line distance.
 
     Examples:
-    --------
+    ---------
     Read testdata.
 
     >>> import sgis as sg

sgis/networkanalysis/traveling_salesman.py

@@ -32,7 +32,7 @@ def traveling_salesman_problem(
         List of Points making up the traveling salesman's path.
 
     Examples:
-    --------
+    ---------
     >>> import sgis as sg
     >>> from shapely.geometry import LineString
     >>> points = sg.to_gdf(

sgis/parallel/parallel.py

@@ -2,6 +2,7 @@ import functools
 import inspect
 import itertools
 import multiprocessing
+import pickle
 import warnings
 from collections.abc import Callable
 from collections.abc import Collection
@@ -31,7 +32,6 @@ try:
     from ..io.dapla_functions import read_geopandas
     from ..io.dapla_functions import write_geopandas
 
-    # from ..io.write_municipality_data import write_municipality_data
 except ImportError:
     pass
 
@@ -39,11 +39,8 @@ except ImportError:
 try:
     from dapla import read_pandas
     from dapla import write_pandas
-    from dapla.gcs import GCSFileSystem
 except ImportError:
-
-    class GCSFileSystem:
-        """Placeholder."""
+    pass
 
 
 class Parallel:
@@ -132,7 +129,7 @@ class Parallel:
             'iterable'.
 
         Examples:
-        --------
+        ---------
         Multiply each list element by 2.
 
         >>> iterable = [1, 2, 3]
@@ -183,7 +180,7 @@ class Parallel:
         func_with_kwargs = functools.partial(func, **kwargs)
 
         if self.processes == 1:
-            return list(map(func_with_kwargs, iterable))
+            return [func_with_kwargs(item) for item in iterable]
 
         iterable = list(iterable)
 
@@ -192,23 +189,42 @@ class Parallel:
 
         if not processes:
             return []
+        elif processes == 1:
+            return [func_with_kwargs(item) for item in iterable]
 
-        if self.backend == "multiprocessing":
-            with multiprocessing.get_context(self.context).Pool(
-                processes, maxtasksperchild=self.maxtasksperchild, **self.kwargs
-            ) as pool:
-                try:
-                    return pool.map(
-                        func_with_kwargs, iterable, chunksize=self.chunksize
-                    )
-                except Exception as e:
-                    pool.terminate()
-                    raise e
+        try:
+            if self.backend == "multiprocessing":
+                with multiprocessing.get_context(self.context).Pool(
+                    processes, maxtasksperchild=self.maxtasksperchild, **self.kwargs
+                ) as pool:
+                    try:
+                        return pool.map(
+                            func_with_kwargs, iterable, chunksize=self.chunksize
+                        )
+                    except Exception as e:
+                        pool.terminate()
+                        raise e
 
-        with joblib.Parallel(
-            n_jobs=processes, backend=self.backend, **self.kwargs
-        ) as parallel:
-            return parallel(joblib.delayed(func)(item, **kwargs) for item in iterable)
+            with joblib.Parallel(
+                n_jobs=processes, backend=self.backend, **self.kwargs
+            ) as parallel:
+                return parallel(
+                    joblib.delayed(func)(item, **kwargs) for item in iterable
+                )
+        except pickle.PickleError as e:
+            unpicklable = []
+            for k, v in locals().items():
+                try:
+                    pickle.dumps(v)
+                except pickle.PickleError:
+                    unpicklable.append(k)
+                except TypeError:
+                    pass
+            if unpicklable:
+                raise pickle.PickleError(
+                    f"Cannot unpickle objects: {unpicklable}"
+                ) from e
+            raise e
 
     def starmap(
         self,
@@ -236,7 +252,7 @@ class Parallel:
             'iterable'.
 
         Examples:
-        --------
+        ---------
         Multiply each list element by 2.
 
         >>> iterable = [(1, 2), (2, 3), (3, 4)]
@@ -786,7 +802,11 @@ def _write_one_muni(
 
     if not len(gdf_muni):
         if write_empty:
-            gdf_muni = gdf_muni.drop(columns="geometry", errors="ignore")
+            try:
+                geom_col = gdf.geometry.name
+            except AttributeError:
+                geom_col = "geometry"
+            gdf_muni = gdf_muni.drop(columns=geom_col, errors="ignore")
             gdf_muni["geometry"] = None
             write_pandas(gdf_muni, out)
         return
@@ -814,7 +834,11 @@ def _write_one_muni_with_neighbors(
 
     if not len(gdf_neighbor):
         if write_empty:
-            gdf_neighbor = gdf_neighbor.drop(columns="geometry", errors="ignore")
+            try:
+                geom_col = gdf.geometry.name
+            except AttributeError:
+                geom_col = "geometry"
+            gdf_neighbor = gdf_neighbor.drop(columns=geom_col, errors="ignore")
             gdf_neighbor["geometry"] = None
             write_pandas(gdf_neighbor, out)
         return
@@ -860,7 +884,9 @@ def _fix_missing_muni_numbers(
         )
 
     try:
-        municipalities = municipalities[[muni_number_col, "geometry"]].to_crs(gdf.crs)
+        municipalities = municipalities[
+            [muni_number_col, municipalities.geometry.name]
+        ].to_crs(gdf.crs)
     except Exception as e:
         raise e.__class__(e, to_print) from e
 
@@ -950,7 +976,18 @@ def _clean_intersection(
     df1: GeoDataFrame, df2: GeoDataFrame, to_print: str | None = None
 ) -> GeoDataFrame:
     print(to_print, "- intersection chunk len:", len(df1))
-    return clean_overlay(df1, df2, how="intersection")
+    cols_to_keep = df1.columns.union(df2.columns.difference({df2.geometry.name}))
+    df1["_range_idx"] = range(len(df1))
+    joined = df1.sjoin(df2, predicate="within", how="left")
+    within = joined.loc[joined["_range_idx"].notna(), cols_to_keep]
+    not_within = joined.loc[joined["_range_idx"].isna(), df1.columns]
+    return pd.concat(
+        [
+            within,
+            clean_overlay(not_within, df2, how="intersection"),
+        ],
+        ignore_index=True,
+    )
 
 
 def chunkwise(

sgis/raster/__init__.py

@@ -1,6 +0,0 @@
-try:
-    from .torchgeo import SENTINEL2_FILENAME_REGEX
-    from .torchgeo import SENTINEL_2_BANDS
-    from .torchgeo import SENTINEL_2_RBG_BANDS
-except ImportError:
-    pass

sgis/raster/base.py

@@ -1,8 +1,216 @@
+import json
+import numbers
+import warnings
+from collections.abc import Callable
 from contextlib import contextmanager
+from typing import Any
 
+import joblib
 import numpy as np
 import pandas as pd
 import rasterio
+from affine import Affine
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
+from rasterio import features
+from rasterio.enums import MergeAlg
+from shapely import Geometry
+from shapely.geometry import shape
+
+from ..geopandas_tools.conversion import to_bbox
+
+
+def _get_transform_from_bounds(
+    obj: GeoDataFrame | GeoSeries | Geometry | tuple, shape: tuple[float, ...]
+) -> Affine:
+    minx, miny, maxx, maxy = to_bbox(obj)
+    if len(shape) == 2:
+        height, width = shape
+    elif len(shape) == 3:
+        _, height, width = shape
+    else:
+        return None
+        # raise ValueError(shape)
+    return rasterio.transform.from_bounds(minx, miny, maxx, maxy, width, height)
+
+
+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
+
+    minx, miny, maxx, maxy = to_bbox(obj)
+
+    # minx = math.floor(minx / res) * res
+    # maxx = math.ceil(maxx / res) * res
+    # miny = math.floor(miny / res) * res
+    # maxy = math.ceil(maxy / res) * res
+
+    # # Compute output array shape. We guarantee it will cover the output
+    # # bounds completely
+    # width = round((maxx - minx) // res)
+    # height = round((maxy - miny) // res)
+
+    # if not isinstance(indexes, int):
+    #     return len(indexes), height, width
+    # return height, width
+
+    diffx = maxx - minx
+    diffy = maxy - miny
+    width = int(diffx / resx)
+    height = int(diffy / resy)
+    if not isinstance(indexes, int):
+        return len(indexes), width, height
+    return height, width
+
+
+def _array_to_geojson(
+    array: np.ndarray, transform: Affine, processes: int
+) -> list[tuple]:
+    if hasattr(array, "mask"):
+        if isinstance(array.mask, np.ndarray):
+            mask = array.mask == False
+        else:
+            mask = None
+        array = array.data
+    else:
+        mask = None
+
+    try:
+        return _array_to_geojson_loop(array, transform, mask, processes)
+    except ValueError:
+        try:
+            array = array.astype(np.float32)
+            return _array_to_geojson_loop(array, transform, mask, processes)
+
+        except Exception as err:
+            raise err.__class__(array.shape, err) from err
+
+
+def _array_to_geojson_loop(array, transform, mask, processes):
+    if processes == 1:
+        return [
+            (value, shape(geom))
+            for geom, value in features.shapes(array, transform=transform, mask=mask)
+        ]
+    else:
+        with joblib.Parallel(n_jobs=processes, backend="threading") as parallel:
+            return parallel(
+                joblib.delayed(_value_geom_pair)(value, geom)
+                for geom, value in features.shapes(
+                    array, transform=transform, mask=mask
+                )
+            )
+
+
+def _value_geom_pair(value, geom):
+    return (value, shape(geom))
+
+
+def _gdf_to_arr(
+    gdf: GeoDataFrame,
+    res: int | float,
+    fill: int = 0,
+    all_touched: bool = False,
+    merge_alg: Callable = MergeAlg.replace,
+    default_value: int = 1,
+    dtype: Any | None = None,
+) -> np.ndarray:
+    """Construct Raster from a GeoDataFrame or GeoSeries.
+
+    The GeoDataFrame should have
+
+    Args:
+        gdf: The GeoDataFrame to rasterize.
+        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.
+
+    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 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]
+
+    if isinstance(values, pd.MultiIndex):
+        raise ValueError("Index cannot be MultiIndex.")
+
+    shape = _get_shape_from_bounds(gdf.total_bounds, res=res, indexes=1)
+    transform = _get_transform_from_bounds(gdf.total_bounds, shape)
+
+    return features.rasterize(
+        _gdf_to_geojson_with_col(gdf, values),
+        out_shape=shape,
+        transform=transform,
+        fill=fill,
+        all_touched=all_touched,
+        merge_alg=merge_alg,
+        default_value=default_value,
+        dtype=dtype,
+    )
+
+
+def _gdf_to_geojson_with_col(gdf: GeoDataFrame, values: np.ndarray) -> list[dict]:
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=UserWarning)
+        return [
+            (feature["geometry"], val)
+            for val, feature in zip(
+                values, json.loads(gdf.to_json())["features"], strict=False
+            )
+        ]
+
+
+def _shapely_to_raster(
+    geometry: Geometry,
+    res: int | float,
+    fill: int = 0,
+    all_touched: bool = False,
+    merge_alg: Callable = MergeAlg.replace,
+    default_value: int = 1,
+    dtype: Any | None = None,
+) -> np.array:
+    shape = _get_shape_from_bounds(geometry.bounds, res=res, indexes=1)
+    transform = _get_transform_from_bounds(geometry.bounds, shape)
+
+    return features.rasterize(
+        [(geometry, default_value)],
+        out_shape=shape,
+        transform=transform,
+        fill=fill,
+        all_touched=all_touched,
+        merge_alg=merge_alg,
+        default_value=default_value,
+        dtype=dtype,
+    )
 
 
 @contextmanager