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

sgis/geopandas_tools/conversion.py

@@ -7,14 +7,27 @@ import geopandas as gpd
 import numpy as np
 import pandas as pd
 import pyproj
+import rasterio
 import shapely
+from affine import Affine
 from geopandas import GeoDataFrame, GeoSeries
 from pandas.api.types import is_array_like, is_dict_like, is_list_like
+from pyproj import CRS
+from rasterio import features
 from shapely import Geometry, box, wkb, wkt
-from shapely.geometry import Point
+from shapely.errors import GEOSException
+from shapely.geometry import Point, shape
 from shapely.ops import unary_union
 
 
+try:
+    from torchgeo.datasets.geo import RasterDataset
+except ImportError:
+
+    class RasterDataset:
+        """Placeholder"""
+
+
 @staticmethod
 def crs_to_string(crs):
     if crs is None:
@@ -189,16 +202,18 @@ def coordinate_array(
 
 
 def to_gdf(
-    obj: Geometry
-    | str
-    | bytes
-    | list
-    | tuple
-    | dict
-    | GeoSeries
-    | pd.Series
-    | pd.DataFrame
-    | Iterator,
+    obj: (
+        Geometry
+        | str
+        | bytes
+        | list
+        | tuple
+        | dict
+        | GeoSeries
+        | pd.Series
+        | pd.DataFrame
+        | Iterator
+    ),
     crs: str | tuple[str] | None = None,
     geometry: str | tuple[str] | int | None = None,
     **kwargs,
@@ -316,6 +331,37 @@ def to_gdf(
         geom_col = geometry or "geometry"
         return _geoseries_to_gdf(obj, geom_col, crs, **kwargs)
 
+    if crs is None:
+        try:
+            crs = obj.crs
+        except AttributeError:
+            try:
+                matches = re.search(r"SRID=(\d+);", obj)
+            except TypeError:
+                try:
+                    matches = re.search(r"SRID=(\d+);", obj[0])
+                except Exception:
+                    pass
+            try:
+                crs = CRS(int("".join(x for x in matches.group(0) if x.isnumeric())))
+            except Exception:
+                pass
+
+    if isinstance(obj, RasterDataset):
+        # read the entire dataset
+        obj = obj[obj.bounds]
+        crs = obj["crs"]
+        array = np.array(obj["image"])
+        transform = get_transform_from_bounds(obj["bbox"], shape=array.shape)
+        return gpd.GeoDataFrame(
+            pd.DataFrame(
+                _array_to_geojson(array, transform),
+                columns=["value", "geometry"],
+            ),
+            geometry="geometry",
+            crs=crs,
+        )
+
     if is_array_like(geometry) and len(geometry) == len(obj):
         geometry = GeoSeries(
             _make_one_shapely_geom(g) for g in geometry if g is not None
@@ -425,6 +471,33 @@ def to_gdf(
     return GeoDataFrame(geometry=geoseries, crs=crs, **kwargs)
 
 
+def _array_to_geojson(array: np.ndarray, transform: Affine):
+    try:
+        return [
+            (value, shape(geom))
+            for geom, value in features.shapes(array, transform=transform)
+        ]
+    except ValueError:
+        array = array.astype(np.float32)
+        return [
+            (value, shape(geom))
+            for geom, value in features.shapes(array, transform=transform)
+        ]
+
+
+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:
+        width, height = shape
+    elif len(shape) == 3:
+        _, width, height = shape
+    else:
+        raise ValueError
+    return rasterio.transform.from_bounds(minx, miny, maxx, maxy, width, height)
+
+
 def make_shapely_geoms(obj):
     if _is_one_geometry(obj):
         return _make_one_shapely_geom(obj)
@@ -583,7 +656,14 @@ def _make_one_shapely_geom(obj):
     Works recursively if the object is a nested iterable.
     """
     if isinstance(obj, str):
-        return wkt.loads(obj)
+        try:
+            return wkt.loads(obj)
+        except GEOSException:
+            if obj.startswith("geography"):
+                matches = re.search(r"SRID=(\d+);", obj)
+                srid = matches.group(0)
+                _, _wkt = obj.split(srid)
+                return wkt.loads(_wkt)
 
     if isinstance(obj, bytes):
         return wkb.loads(obj)

sgis/geopandas_tools/duplicates.py

@@ -6,10 +6,18 @@ from geopandas import GeoDataFrame, GeoSeries
 from shapely import STRtree, difference, make_valid, simplify, unary_union
 from shapely.errors import GEOSException
 
-from .buffer_dissolve_explode import parallel_unary_union_geoseries
-from .general import _determine_geom_type_args, _push_geom_col, clean_geoms
+from .general import (
+    _determine_geom_type_args,
+    _push_geom_col,
+    clean_geoms,
+    parallel_unary_union_geoseries,
+)
 from .geometry_types import get_geom_type, make_all_singlepart, to_single_geom_type
 from .overlay import _run_overlay_dask, clean_overlay, make_valid_and_keep_geom_type
+from .sfilter import sfilter_inverse, sfilter_split
+
+
+PRECISION = 1e-3
 
 
 def update_geometries(
@@ -18,6 +26,7 @@ def update_geometries(
     keep_geom_type: bool | None = None,
     grid_size: int | None = None,
     n_jobs: int = 1,
+    predicate: str | None = "intersects",
 ) -> GeoDataFrame:
     """Puts geometries on top of each other rowwise.
 
@@ -81,40 +90,43 @@ def update_geometries(
     if len(gdf) <= 1:
         return gdf
 
-    gdf = make_all_singlepart(clean_geoms(gdf))
+    copied = make_all_singlepart(clean_geoms(gdf))
 
-    gdf, geom_type, keep_geom_type = _determine_geom_type_args(
-        gdf, geom_type, keep_geom_type
+    copied, geom_type, keep_geom_type = _determine_geom_type_args(
+        copied, geom_type, keep_geom_type
     )
 
-    geom_col = gdf._geometry_column_name
-    index_mapper = {i: idx for i, idx in enumerate(gdf.index)}
-    gdf = gdf.reset_index(drop=True)
+    geom_col = copied._geometry_column_name
+    index_mapper = {i: idx for i, idx in enumerate(copied.index)}
+    copied = copied.reset_index(drop=True)
 
-    tree = STRtree(gdf.geometry.values)
-    left, right = tree.query(gdf.geometry.values, predicate="intersects")
+    tree = STRtree(copied.geometry.values)
+    left, right = tree.query(copied.geometry.values, predicate=predicate)
     indices = pd.Series(right, index=left).loc[lambda x: x.index > x.values]
 
     # select geometries from 'right', index from 'left', dissolve by 'left'
+    erasers = pd.Series(copied.geometry.loc[indices.values].values, index=indices.index)
     if n_jobs > 1:
         erasers = parallel_unary_union_geoseries(
-            pd.Series(gdf.geometry.loc[indices.values].values, index=indices.index),
+            erasers,
             level=0,
             n_jobs=n_jobs,
             grid_size=grid_size,
-            # index=indices.index.unique(),
         )
         erasers = pd.Series(erasers, index=indices.index.unique())
     else:
-        erasers = (
-            pd.Series(gdf.geometry.loc[indices.values].values, index=indices.index)
+        only_one = erasers.groupby(level=0).transform("size") == 1
+        one_hit = erasers[only_one]
+        many_hits = (
+            erasers[~only_one]
             .groupby(level=0)
             .agg(lambda x: make_valid(unary_union(x, grid_size=grid_size)))
         )
+        erasers = pd.concat([one_hit, many_hits]).sort_index()
 
     # match up the aggregated erasers by index
     if n_jobs > 1:
-        arr1 = gdf.geometry.loc[erasers.index].to_numpy()
+        arr1 = copied.geometry.loc[erasers.index].to_numpy()
         arr2 = erasers.to_numpy()
         try:
             erased = _run_overlay_dask(
@@ -134,28 +146,39 @@ def update_geometries(
     else:
         erased = make_valid(
             difference(
-                gdf.geometry.loc[erasers.index],
+                copied.geometry.loc[erasers.index],
                 erasers,
                 grid_size=grid_size,
             )
         )
 
-    gdf.loc[erased.index, geom_col] = erased
+    copied.loc[erased.index, geom_col] = erased
+
+    copied = copied.loc[~copied.is_empty]
 
-    gdf = gdf.loc[~gdf.is_empty]
+    copied.index = copied.index.map(index_mapper)
 
-    gdf.index = gdf.index.map(index_mapper)
+    # TODO check why polygons dissappear in rare cases. For now, just add back the missing
+    dissapeared = sfilter_inverse(gdf, copied.buffer(-PRECISION))
+    copied = pd.concat([copied, dissapeared])
+
+    # TODO fix dupliates again with dissolve?
+    # dups = get_intersections(copied, geom_type="polygon")
+    # dups["_cluster"] = get_cluster_mapper(dups.geometry.values)
+    # no_dups = dissexp(dups, by="_cluster").drop(columns="_cluster")
+    # copied = clean_overlay(copied, no_dups, how="update", geom_type="polygon")
 
     if keep_geom_type:
-        gdf = to_single_geom_type(gdf, geom_type)
+        copied = to_single_geom_type(copied, geom_type)
 
-    return gdf
+    return copied
 
 
 def get_intersections(
     gdf: GeoDataFrame,
     geom_type: str | None = None,
     keep_geom_type: bool | None = None,
+    predicate: str | None = "intersects",
     n_jobs: int = 1,
 ) -> GeoDataFrame:
     """Find geometries that intersect in a GeoDataFrame.
@@ -248,6 +271,7 @@ def get_intersections(
         geom_type,
         keep_geom_type,
         n_jobs=n_jobs,
+        predicate=predicate,
     ).pipe(clean_geoms)
 
     duplicated_geoms.index = duplicated_geoms["orig_idx"].values
@@ -260,7 +284,7 @@ def get_intersections(
 
 
 def _get_intersecting_geometries(
-    gdf: GeoDataFrame, geom_type, keep_geom_type, n_jobs
+    gdf: GeoDataFrame, geom_type, keep_geom_type, n_jobs, predicate
 ) -> GeoDataFrame:
     right = gdf[[gdf._geometry_column_name]]
     right["idx_right"] = right.index
@@ -280,6 +304,7 @@ def _get_intersecting_geometries(
             left,
             right,
             how="intersection",
+            predicate=predicate,
             geom_type=geom_type,
             keep_geom_type=keep_geom_type,
             n_jobs=n_jobs,
@@ -296,7 +321,12 @@ def _get_intersecting_geometries(
                 continue
             intersected += [
                 clean_overlay(
-                    left, right, how="intersection", geom_type=geom_type, n_jobs=n_jobs
+                    left,
+                    right,
+                    how="intersection",
+                    predicate=predicate,
+                    geom_type=geom_type,
+                    n_jobs=n_jobs,
                 )
             ]
         intersected = pd.concat(intersected, ignore_index=True).loc[are_not_identical]

sgis/geopandas_tools/general.py

@@ -299,6 +299,16 @@ def sort_large_first(gdf: GeoDataFrame | GeoSeries) -> GeoDataFrame | GeoSeries:
     return gdf.iloc[list(sorted_areas)]
 
 
+def sort_df(
+    df: pd.DataFrame | GeoDataFrame, sort_col: pd.Series
+) -> pd.DataFrame | GeoDataFrame:
+    value_mapper: dict[int, Any] = dict(enumerate(sort_col.values))
+    sorted_indices = dict(
+        reversed(sorted(value_mapper.items(), key=lambda item: item[1]))
+    )
+    return df.iloc[list(sorted_indices)]
+
+
 def sort_long_first(gdf: GeoDataFrame | GeoSeries) -> GeoDataFrame | GeoSeries:
     """Sort GeoDataFrame by length in decending order.
 
@@ -736,6 +746,31 @@ def parallel_unary_union(
 def parallel_unary_union_geoseries(
     ser: GeoSeries, n_jobs: int = 1, grid_size=None, **kwargs
 ) -> list[Geometry]:
+
+    is_one_hit = ser.groupby(**kwargs).transform("size") == 1
+
+    one_hit = ser.loc[is_one_hit]
+    many_hits = ser.loc[~is_one_hit]
+
+    with joblib.Parallel(n_jobs=n_jobs, backend="threading") as parallel:
+        delayed_operations = []
+        for _, geoms in many_hits.groupby(**kwargs):
+            delayed_operations.append(
+                joblib.delayed(merge_geometries)(geoms, grid_size=grid_size)
+            )
+
+        dissolved = pd.Series(
+            parallel(delayed_operations),
+            index=is_one_hit[lambda x: x == False].index.unique(),
+        )
+
+    return pd.concat([dissolved, one_hit]).sort_index().values
+
+
+def parallel_unary_union_geoseries(
+    ser: GeoSeries, n_jobs: int = 1, grid_size=None, **kwargs
+) -> list[Geometry]:
+
     with joblib.Parallel(n_jobs=n_jobs, backend="threading") as parallel:
         delayed_operations = []
         for _, geoms in ser.groupby(**kwargs):

sgis/geopandas_tools/neighbors.py

@@ -7,9 +7,12 @@ GeoDataFrames.
 The results of all functions will be identical with GeoDataFrame and GeoSeries as input
 types.
 """
+
 import numpy as np
+import shapely
 from geopandas import GeoDataFrame, GeoSeries
-from pandas import DataFrame, Series
+from pandas import DataFrame, Series, concat
+from shapely import STRtree
 from sklearn.neighbors import NearestNeighbors
 
 from .conversion import coordinate_array
@@ -237,6 +240,33 @@ def get_all_distances(
     )
 
 
+def sjoin_within_distance(
+    gdf: GeoDataFrame | GeoSeries,
+    neighbors: GeoDataFrame | GeoSeries,
+    distance: int | float,
+    distance_col: str = "distance",
+    **kwargs,
+) -> GeoDataFrame:
+    """Sjoin with a buffer on the right GeoDataFrame and adds a distance column."""
+
+    new_neighbor_cols = {"__left_range_idx": range(len(neighbors))}
+    if distance:
+        new_neighbor_cols[neighbors._geometry_column_name] = lambda x: x.buffer(
+            distance
+        )
+
+    # using assign to get a copy
+    neighbors = neighbors.assign(**new_neighbor_cols)
+
+    out = gdf.sjoin(neighbors, **kwargs)
+
+    out[distance_col] = shapely.distance(
+        out.geometry.values, neighbors.geometry.iloc[out["__left_range_idx"]].values
+    )
+
+    return out.drop(columns="__left_range_idx")
+
+
 def get_k_nearest_neighbors(
     gdf: GeoDataFrame | GeoSeries,
     neighbors: GeoDataFrame | GeoSeries,