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

sgis/geopandas_tools/buffer_dissolve_explode.py

@@ -14,15 +14,19 @@ for the following:
 - The buff function returns a GeoDataFrame, the geopandas method returns a GeoSeries.
 """
 
-from typing import Callable
+from collections.abc import Callable
+from collections.abc import Sequence
 
 import numpy as np
 import pandas as pd
-from geopandas import GeoDataFrame, GeoSeries
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
 
-from .general import merge_geometries, parallel_unary_union
+from .general import _merge_geometries
+from .general import _parallel_unary_union
 from .geometry_types import make_all_singlepart
-from .polygon_operations import get_cluster_mapper, get_grouped_centroids
+from .polygon_operations import get_cluster_mapper
+from .polygon_operations import get_grouped_centroids
 
 
 def _decide_ignore_index(kwargs: dict) -> tuple[dict, bool]:
@@ -65,6 +69,8 @@ def buffdissexp(
         index_parts: If False (default), the index after dissolve is respected. If
             True, an integer index level is added during explode.
         copy: Whether to copy the GeoDataFrame before buffering. Defaults to True.
+        grid_size: Rounding of the coordinates. Defaults to None.
+        n_jobs: Number of threads to use. Defaults to 1.
         **dissolve_kwargs: additional keyword arguments passed to geopandas' dissolve.
 
     Returns:
@@ -109,12 +115,13 @@ def buffdiss(
         resolution: The number of segments used to approximate a quarter circle.
             Here defaults to 50, as opposed to the default 16 in geopandas.
         copy: Whether to copy the GeoDataFrame before buffering. Defaults to True.
+        n_jobs: Number of threads to use. Defaults to 1.
         **dissolve_kwargs: additional keyword arguments passed to geopandas' dissolve.
 
     Returns:
         A buffered GeoDataFrame where geometries are dissolved.
 
-    Examples
+    Examples:
     --------
     Create some random points.
 
@@ -167,7 +174,13 @@ def buffdiss(
     return _dissolve(buffered, n_jobs=n_jobs, **dissolve_kwargs)
 
 
-def _dissolve(gdf, aggfunc="first", grid_size=None, n_jobs=1, **dissolve_kwargs):
+def _dissolve(
+    gdf: GeoDataFrame,
+    aggfunc: str = "first",
+    grid_size: None | float = None,
+    n_jobs: int = 1,
+    **dissolve_kwargs,
+) -> GeoDataFrame:
 
     if not len(gdf):
         return gdf
@@ -220,7 +233,7 @@ def _dissolve(gdf, aggfunc="first", grid_size=None, n_jobs=1, **dissolve_kwargs)
 
     if n_jobs > 1:
         try:
-            agged = parallel_unary_union(
+            agged = _parallel_unary_union(
                 many_hits, n_jobs=n_jobs, by=by, grid_size=grid_size, **dissolve_kwargs
             )
             dissolved[geom_col] = agged
@@ -230,7 +243,7 @@ def _dissolve(gdf, aggfunc="first", grid_size=None, n_jobs=1, **dissolve_kwargs)
             raise e
 
     geoms_agged = many_hits.groupby(by, **dissolve_kwargs)[geom_col].agg(
-        lambda x: merge_geometries(x, grid_size=grid_size)
+        lambda x: _merge_geometries(x, grid_size=grid_size)
     )
 
     if not dissolve_kwargs.get("as_index"):
@@ -248,13 +261,13 @@ def _dissolve(gdf, aggfunc="first", grid_size=None, n_jobs=1, **dissolve_kwargs)
 
 def diss(
     gdf: GeoDataFrame,
-    by=None,
-    aggfunc="first",
+    by: str | Sequence[str] | None = None,
+    aggfunc: str | Callable | dict[str, str | Callable] = "first",
     as_index: bool = True,
     grid_size: float | int | None = None,
     n_jobs: int = 1,
     **dissolve_kwargs,
-):
+) -> GeoDataFrame:
     """Dissolves geometries.
 
     It takes a GeoDataFrame and dissolves and fixes geometries.
@@ -265,6 +278,8 @@ def diss(
         aggfunc: How to aggregate the non-geometry colums not in "by".
         as_index: Whether the 'by' columns should be returned as index. Defaults to
             True to be consistent with geopandas.
+        grid_size: Rounding of the coordinates. Defaults to None.
+        n_jobs: Number of threads to use. Defaults to 1.
         **dissolve_kwargs: additional keyword arguments passed to geopandas' dissolve.
 
     Returns:
@@ -292,14 +307,14 @@ def diss(
 
 def dissexp(
     gdf: GeoDataFrame,
-    by=None,
-    aggfunc="first",
+    by: str | Sequence[str] | None = None,
+    aggfunc: str | Callable | dict[str, str | Callable] = "first",
     as_index: bool = True,
     index_parts: bool = False,
     grid_size: float | int | None = None,
     n_jobs: int = 1,
     **dissolve_kwargs,
-):
+) -> GeoDataFrame:
     """Dissolves overlapping geometries.
 
     It takes a GeoDataFrame and dissolves, fixes and explodes geometries.
@@ -312,6 +327,8 @@ def dissexp(
             True to be consistent with geopandas.
         index_parts: If False (default), the index after dissolve is respected. If
             True, an integer index level is added during explode.
+        grid_size: Rounding of the coordinates. Defaults to None.
+        n_jobs: Number of threads to use. Defaults to 1.
         **dissolve_kwargs: additional keyword arguments passed to geopandas' dissolve.
 
     Returns:
@@ -334,7 +351,7 @@ def dissexp(
 
 
 def dissexp_by_cluster(
-    gdf: GeoDataFrame, predicate=None, n_jobs: int = 1, **dissolve_kwargs
+    gdf: GeoDataFrame, predicate: str | None = None, n_jobs: int = 1, **dissolve_kwargs
 ) -> GeoDataFrame:
     """Dissolves overlapping geometries through clustering with sjoin and networkx.
 
@@ -348,6 +365,8 @@ def dissexp_by_cluster(
 
     Args:
         gdf: the GeoDataFrame that will be dissolved and exploded.
+        predicate: Spatial predicate to use.
+        n_jobs: Number of threads to use. Defaults to 1.
         **dissolve_kwargs: Keyword arguments passed to geopandas' dissolve.
 
     Returns:
@@ -373,6 +392,8 @@ def diss_by_cluster(
 
     Args:
         gdf: the GeoDataFrame that will be dissolved and exploded.
+        predicate: Spatial predicate to use.
+        n_jobs: Number of threads to use. Defaults to 1.
         **dissolve_kwargs: Keyword arguments passed to geopandas' dissolve.
 
     Returns:
@@ -386,27 +407,10 @@ def diss_by_cluster(
 def _run_func_by_cluster(
     func: Callable,
     gdf: GeoDataFrame,
-    predicate=None,
+    predicate: str | None = None,
     n_jobs: int = 1,
     **dissolve_kwargs,
 ) -> GeoDataFrame:
-    """Dissolves overlapping geometries through clustering with sjoin and networkx.
-
-    Works exactly like dissexp, but, before dissolving, the geometries are divided
-    into clusters based on overlap (uses the function sgis.get_polygon_clusters).
-    The geometries are then dissolved based on this column (and optionally other
-    columns).
-
-    This might be many times faster than a regular dissexp, if there are many
-    non-overlapping geometries.
-
-    Args:
-        gdf: the GeoDataFrame that will be dissolved and exploded.
-        **dissolve_kwargs: Keyword arguments passed to geopandas' dissolve.
-
-    Returns:
-        A GeoDataFrame where overlapping geometries are dissolved.
-    """
     is_geoseries = isinstance(gdf, GeoSeries)
 
     by = dissolve_kwargs.pop("by", [])
@@ -477,6 +481,7 @@ def buffdissexp_by_cluster(
         resolution: The number of segments used to approximate a quarter circle.
             Here defaults to 50, as opposed to the default 16 in geopandas.
         copy: Whether to copy the GeoDataFrame before buffering. Defaults to True.
+        n_jobs: int = 1,
         **dissolve_kwargs: additional keyword arguments passed to geopandas' dissolve.
 
     Returns:
@@ -507,7 +512,6 @@ def buff(
     Returns:
         A buffered GeoDataFrame.
     """
-
     if isinstance(gdf, GeoSeries):
         return gdf.buffer(distance, resolution=resolution, **buffer_kwargs).make_valid()
 

sgis/geopandas_tools/centerlines.py

@@ -1,51 +1,56 @@
 import functools
+import itertools
 import warnings
 
 import numpy as np
 import pandas as pd
 import shapely
-from geopandas import GeoDataFrame, GeoSeries
-from geopandas.array import GeometryArray
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
 from numpy.typing import NDArray
-from shapely import (
-    STRtree,
-    distance,
-    extract_unique_points,
-    get_parts,
-    get_rings,
-    line_merge,
-    make_valid,
-    segmentize,
-    unary_union,
-    voronoi_polygons,
-)
+from shapely import STRtree
+from shapely import distance
+from shapely import extract_unique_points
+from shapely import get_rings
+from shapely import line_merge
+from shapely import make_valid
+from shapely import segmentize
+from shapely import unary_union
+from shapely import voronoi_polygons
 from shapely.errors import GEOSException
 from shapely.geometry import LineString
 from shapely.ops import nearest_points
 
-from ..maps.maps import explore, explore_locals
+from ..maps.maps import explore
 from ..networkanalysis.traveling_salesman import traveling_salesman_problem
-from .conversion import to_gdf, to_geoseries
-from .general import clean_geoms, make_lines_between_points, sort_long_first
+from .conversion import to_gdf
+from .conversion import to_geoseries
+from .general import clean_geoms
+from .general import make_lines_between_points
+from .general import sort_long_first
 from .geometry_types import make_all_singlepart
-from .sfilter import sfilter_inverse, sfilter_split
-
+from .sfilter import sfilter_inverse
+from .sfilter import sfilter_split
 
 warnings.simplefilter(action="ignore", category=FutureWarning)
 
 
-def get_traveling_salesman_lines(df, return_to_start=False):
+def get_traveling_salesman_lines(
+    df: GeoDataFrame, return_to_start: bool = False
+) -> list[LineString]:
     path = traveling_salesman_problem(df, return_to_start=return_to_start)
 
     try:
-        return [LineString([p1, p2]) for p1, p2 in zip(path[:-1], path[1:])]
+        return [LineString([p1, p2]) for p1, p2 in itertools.pairwise(path)]
     except IndexError as e:
         if len(path) == 1:
             return path
         raise e
 
 
-def remove_longest_if_not_intersecting(centerlines, geoms):
+def _remove_longest_if_not_intersecting(
+    centerlines: GeoDataFrame, geoms: GeoDataFrame
+) -> GeoDataFrame:
     centerlines = sort_long_first(make_all_singlepart(centerlines))
 
     has_only_one_line = centerlines.groupby(level=0).size() == 1
@@ -83,8 +88,7 @@ def get_rough_centerlines(
     complext polygons like (buffered) road networks.
 
     """
-
-    PRECISION = 0.01
+    precision = 0.01
 
     if not len(gdf):
         return gdf
@@ -96,12 +100,12 @@ def get_rough_centerlines(
 
     segmentized: GeoSeries = segmentize(geoms, max_segment_length=max_segment_length)
 
-    points: GeoSeries = get_points_in_polygons(segmentized, PRECISION)
+    points: GeoSeries = _get_points_in_polygons(segmentized, precision)
 
     has_no_points = geoms.loc[(~geoms.index.isin(points.index))]
 
-    more_points: GeoSeries = get_points_in_polygons(
-        has_no_points.buffer(PRECISION), PRECISION
+    more_points: GeoSeries = _get_points_in_polygons(
+        has_no_points.buffer(precision), precision
     )
 
     # Geometries that have no lines inside, might be perfect circles.
@@ -131,7 +135,7 @@ def get_rough_centerlines(
         ]
 
     # make sure to include the endpoints
-    endpoints = get_approximate_polygon_endpoints(segmentized)
+    endpoints = _get_approximate_polygon_endpoints(segmentized)
 
     geoms = geoms.loc[~geoms.index.isin(still_has_no_points.index)]
 
@@ -148,7 +152,7 @@ def get_rough_centerlines(
     # keep lines 90 percent intersecting the polygon
     length_now = end_to_end.length
     end_to_end = (
-        end_to_end.intersection(geoms.buffer(PRECISION))
+        end_to_end.intersection(geoms.buffer(precision))
         .dropna()
         .loc[lambda x: x.length > length_now * 0.9]
     )
@@ -157,7 +161,7 @@ def get_rough_centerlines(
     to_be_erased = points.index.isin(end_to_end.index)
 
     dont_intersect = sfilter_inverse(
-        points.iloc[to_be_erased], end_to_end.buffer(PRECISION, cap_style=2)
+        points.iloc[to_be_erased], end_to_end.buffer(precision, cap_style=2)
     )
 
     points = (
@@ -184,7 +188,7 @@ def get_rough_centerlines(
 
     explore(points=to_gdf(points, 25833), gdf=gdf)
 
-    remove_longest = functools.partial(remove_longest_if_not_intersecting, geoms=geoms)
+    remove_longest = functools.partial(_remove_longest_if_not_intersecting, geoms=geoms)
 
     centerlines = GeoSeries(
         points.groupby(level=0).apply(get_traveling_salesman_lines).explode()
@@ -235,7 +239,7 @@ def get_rough_centerlines(
     return centerlines
 
 
-def get_points_in_polygons(geometries: GeoSeries, precision: float) -> GeoSeries:
+def _get_points_in_polygons(geometries: GeoSeries, precision: float) -> GeoSeries:
     # voronoi can cause problems if coordinates are nearly identical
     # buffering solves it
     try:
@@ -267,7 +271,7 @@ def get_points_in_polygons(geometries: GeoSeries, precision: float) -> GeoSeries
     return pd.concat([within_polygons, not_within_but_relevant]).centroid
 
 
-def get_approximate_polygon_endpoints(geoms: GeoSeries) -> GeoSeries:
+def _get_approximate_polygon_endpoints(geoms: GeoSeries) -> GeoSeries:
     out_geoms = []
 
     are_thin = geoms.buffer(-1e-2).is_empty
@@ -332,7 +336,7 @@ def get_approximate_polygon_endpoints(geoms: GeoSeries) -> GeoSeries:
 
         out_geoms.append(nearest_geom_points)
 
-    lines_around_geometries = multipoints_to_line_segments(
+    lines_around_geometries = _multipoints_to_line_segments(
         extract_unique_points(rectangles)
     )
 
@@ -370,7 +374,7 @@ def get_approximate_polygon_endpoints(geoms: GeoSeries) -> GeoSeries:
     return pd.concat(out_geoms)
 
 
-def multipoints_to_line_segments(
+def _multipoints_to_line_segments(
     multipoints: GeoSeries | GeoDataFrame, to_next: bool = True, cycle: bool = True
 ) -> GeoSeries | GeoDataFrame:
     if not len(multipoints):
@@ -384,13 +388,13 @@ def multipoints_to_line_segments(
             for i in range(multipoints.index.nlevels)
         ]
         multipoints.index = pd.MultiIndex.from_arrays(
-            [list(range(len(multipoints)))] + index,
-            names=["range_idx"] + multipoints.index.names,
+            [list(range(len(multipoints))), *index],
+            names=["range_idx", *multipoints.index.names],
         )
     else:
         multipoints.index = pd.MultiIndex.from_arrays(
             [np.arange(0, len(multipoints)), multipoints.index],
-            names=["range_idx"] + [multipoints.index.name],
+            names=["range_idx", multipoints.index.name],
         )
 
     try:
@@ -402,15 +406,17 @@ def multipoints_to_line_segments(
 
     if to_next:
         shift = -1
-        filt = lambda x: ~x.index.get_level_values(0).duplicated(keep="first")
+        keep = "first"
     else:
         shift = 1
-        filt = lambda x: ~x.index.get_level_values(0).duplicated(keep="last")
+        keep = "last"
 
     point_df["next"] = point_df.groupby(level=0)["geometry"].shift(shift)
 
     if cycle:
-        first_points = point_df.loc[filt, "geometry"]
+        first_points: GeoSeries = point_df.loc[
+            lambda x: ~x.index.get_level_values(0).duplicated(keep=keep), "geometry"
+        ]
         is_last_point = point_df["next"].isna()
 
         point_df.loc[is_last_point, "next"] = first_points
@@ -419,7 +425,8 @@ def multipoints_to_line_segments(
         point_df = point_df[point_df["next"].notna()]
 
     point_df["geometry"] = [
-        LineString([x1, x2]) for x1, x2 in zip(point_df["geometry"], point_df["next"])
+        LineString([x1, x2])
+        for x1, x2 in zip(point_df["geometry"], point_df["next"], strict=False)
     ]
     if isinstance(multipoints.index, pd.MultiIndex):
         point_df.index = point_df.index.droplevel(0)
@@ -431,7 +438,9 @@ def multipoints_to_line_segments(
     return GeoSeries(point_df["geometry"], crs=crs)
 
 
-def get_line_segments(lines, extract_unique: bool = False, cycle=False) -> GeoDataFrame:
+def get_line_segments(
+    lines: GeoDataFrame | GeoSeries, extract_unique: bool = False, cycle=False
+) -> GeoDataFrame:
     try:
         assert lines.index.is_unique
     except AttributeError:
@@ -445,4 +454,4 @@ def get_line_segments(lines, extract_unique: bool = False, cycle=False) -> GeoDa
         coords, indices = shapely.get_coordinates(lines, return_index=True)
         points = GeoSeries(shapely.points(coords), index=indices)
 
-    return multipoints_to_line_segments(points, cycle=cycle)
+    return _multipoints_to_line_segments(points, cycle=cycle)