ssb-sgis 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

sgis/__init__.py

@@ -2,6 +2,7 @@ config = {
     "n_jobs": 1,
 }
 
+
 import sgis.raster.indices as indices
 from sgis.raster.raster import Raster
 from sgis.raster.raster import get_shape_from_bounds
@@ -15,7 +16,6 @@ from .geopandas_tools.bounds import gridloop
 from .geopandas_tools.bounds import make_grid
 from .geopandas_tools.bounds import make_grid_from_bbox
 from .geopandas_tools.bounds import make_ssb_grid
-from .geopandas_tools.bounds import points_in_bounds
 from .geopandas_tools.buffer_dissolve_explode import buff
 from .geopandas_tools.buffer_dissolve_explode import buffdiss
 from .geopandas_tools.buffer_dissolve_explode import buffdissexp
@@ -26,9 +26,9 @@ from .geopandas_tools.buffer_dissolve_explode import dissexp
 from .geopandas_tools.buffer_dissolve_explode import dissexp_by_cluster
 from .geopandas_tools.centerlines import get_rough_centerlines
 from .geopandas_tools.cleaning import coverage_clean
-from .geopandas_tools.cleaning import remove_spikes
 from .geopandas_tools.cleaning import split_and_eliminate_by_longest
-from .geopandas_tools.cleaning import split_by_neighbors
+
+# from .geopandas_tools.cleaning import split_by_neighbors
 from .geopandas_tools.conversion import coordinate_array
 from .geopandas_tools.conversion import from_4326
 from .geopandas_tools.conversion import to_4326
@@ -44,6 +44,8 @@ from .geopandas_tools.general import clean_geoms
 from .geopandas_tools.general import drop_inactive_geometry_columns
 from .geopandas_tools.general import get_common_crs
 from .geopandas_tools.general import get_grouped_centroids
+from .geopandas_tools.general import get_line_segments
+from .geopandas_tools.general import points_in_bounds
 from .geopandas_tools.general import random_points
 from .geopandas_tools.general import random_points_in_polygons
 from .geopandas_tools.general import sort_large_first
@@ -66,6 +68,7 @@ from .geopandas_tools.neighbors import sjoin_within_distance
 from .geopandas_tools.overlay import clean_overlay
 from .geopandas_tools.point_operations import snap_all
 from .geopandas_tools.point_operations import snap_within_distance
+from .geopandas_tools.polygon_operations import clean_dissexp
 from .geopandas_tools.polygon_operations import close_all_holes
 from .geopandas_tools.polygon_operations import close_small_holes
 from .geopandas_tools.polygon_operations import close_thin_holes
@@ -76,6 +79,7 @@ from .geopandas_tools.polygon_operations import get_cluster_mapper
 from .geopandas_tools.polygon_operations import get_gaps
 from .geopandas_tools.polygon_operations import get_holes
 from .geopandas_tools.polygon_operations import get_polygon_clusters
+from .geopandas_tools.polygon_operations import split_polygons_by_lines
 from .geopandas_tools.polygons_as_rings import PolygonsAsRings
 from .geopandas_tools.sfilter import sfilter
 from .geopandas_tools.sfilter import sfilter_inverse
@@ -119,7 +123,9 @@ from .raster.cube import concat_cubes
 from .raster.image_collection import Band
 from .raster.image_collection import Image
 from .raster.image_collection import ImageCollection
+from .raster.image_collection import NDVIBand
 from .raster.image_collection import Sentinel2Band
+from .raster.image_collection import Sentinel2CloudlessBand
 from .raster.image_collection import Sentinel2CloudlessCollection
 from .raster.image_collection import Sentinel2CloudlessImage
 from .raster.image_collection import Sentinel2Collection
@@ -128,6 +134,7 @@ from .raster.image_collection import concat_image_collections
 
 try:
     from .io.dapla_functions import check_files
+    from .io.dapla_functions import get_bounds_series
     from .io.dapla_functions import read_geopandas
     from .io.dapla_functions import write_geopandas
 except ImportError:

sgis/debug_config.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+
+class _NoExplore:
+    """Simply so signal that explore functions should be immediately exited."""
+
+
+_DEBUG_CONFIG = {
+    # "center": (5.3719398, 59.00999914, 0.01),
+    # "center": (5.27306727, 59.44232754, 200),
+    # "center": (5.85575588, 62.33991158, 200),
+    # "center": (26.02870514, 70.68108478, 200),
+    "center": _NoExplore(),
+    "print": False,
+}
+
+
+def _try_debug_print(*args: Any) -> None:
+    if not _DEBUG_CONFIG["print"]:
+        return
+    try:
+        print(*args)
+    except Exception:
+        pass

sgis/geopandas_tools/bounds.py

@@ -18,7 +18,7 @@ from ..parallel.parallel import Parallel
 from .conversion import to_bbox
 from .conversion import to_gdf
 from .general import clean_clip
-from .general import is_bbox_like
+from .general import get_common_crs
 
 
 @dataclass
@@ -133,11 +133,7 @@ class Gridlooper:
             )
             results = self.parallelizer.map(func_with_clip, buffered_grid)
             if not self.gridbuffer or not self.clip:
-                return (
-                    results
-                    if not self.concat
-                    else pd.concat(results, ignore_index=True)
-                )
+                return self._return(results, args, kwargs)
             out = []
             for cell_res, unbuffered in zip(results, grid, strict=True):
                 out.append(
@@ -145,7 +141,7 @@ class Gridlooper:
                         cell_res, unbuffered, self.keep_geom_type
                     )
                 )
-            return out if not self.concat else pd.concat(out, ignore_index=True)
+            return self._return(out, args, kwargs)
 
         results = []
         for i, (unbuffered, buffered) in enumerate(
@@ -175,7 +171,18 @@ class Gridlooper:
             if self.verbose:
                 print(f"Done with {i+1} of {n} grid cells", end="\r")
 
-        return results if not self.concat else pd.concat(results, ignore_index=True)
+        return self._return(results, args, kwargs)
+
+    def _return(
+        self, results: list[Any], args: tuple[Any], kwargs: dict[str, Any]
+    ) -> list[Any] | GeoDataFrame:
+        if self.concat and len(results):
+            return pd.concat(results, ignore_index=True)
+        elif self.concat:
+            crs = get_common_crs(list(args) + list(kwargs.values()))
+            return GeoDataFrame({"geometry": []}, crs=crs)
+        else:
+            return results
 
 
 def gridloop(
@@ -650,6 +657,7 @@ def bounds_to_points(
     Examples:
     ---------
     >>> import sgis as sg
+    >>> from shapely.geometry import MultiPoint, Point
     >>> gdf = sg.to_gdf([MultiPoint([(0, 0), (1, 1)]), Point(0, 0)])
     >>> gdf
                                             geometry
@@ -690,16 +698,3 @@ def get_total_bounds(
                 else:
                     continue
     return min(xs), min(ys), max(xs), max(ys)
-
-
-def points_in_bounds(gdf: GeoDataFrame | GeoSeries, n2: int) -> GeoDataFrame:
-    """Get a GeoDataFrame of points within the bounds of the GeoDataFrame."""
-    if not isinstance(gdf, (GeoDataFrame | GeoSeries)) and is_bbox_like(gdf):
-        minx, miny, maxx, maxy = gdf
-    else:
-        minx, miny, maxx, maxy = gdf.total_bounds
-    xs = np.linspace(minx, maxx, num=n2)
-    ys = np.linspace(miny, maxy, num=n2)
-    x_coords, y_coords = np.meshgrid(xs, ys, indexing="ij")
-    coords = np.concatenate((x_coords.reshape(-1, 1), y_coords.reshape(-1, 1)), axis=1)
-    return to_gdf(coords, crs=gdf.crs)

sgis/geopandas_tools/buffer_dissolve_explode.py

@@ -21,9 +21,12 @@ import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
 from geopandas import GeoSeries
+from shapely import get_num_geometries
 
-from .general import _merge_geometries
+from ..parallel.parallel import Parallel
+from .general import _grouped_unary_union
 from .general import _parallel_unary_union
+from .general import _unary_union_for_notna
 from .geometry_types import make_all_singlepart
 from .polygon_operations import get_cluster_mapper
 from .polygon_operations import get_grouped_centroids
@@ -186,6 +189,7 @@ def _dissolve(
     aggfunc: str = "first",
     grid_size: None | float = None,
     n_jobs: int = 1,
+    as_index: bool = True,
     **dissolve_kwargs,
 ) -> GeoDataFrame:
 
@@ -194,6 +198,13 @@ def _dissolve(
 
     geom_col = gdf._geometry_column_name
 
+    gdf[geom_col] = gdf[geom_col].make_valid()
+
+    more_than_one = get_num_geometries(gdf.geometry.values) > 1
+    gdf.loc[more_than_one, geom_col] = gdf.loc[more_than_one, geom_col].apply(
+        _unary_union_for_notna
+    )
+
     by = dissolve_kwargs.pop("by", None)
 
     by_was_none = not bool(by)
@@ -207,7 +218,9 @@ def _dissolve(
         other_cols = list(gdf.columns.difference({geom_col} | set(by or {})))
 
     try:
-        is_one_hit = gdf.groupby(by, **dissolve_kwargs).transform("size") == 1
+        is_one_hit = (
+            gdf.groupby(by, as_index=True, **dissolve_kwargs).transform("size") == 1
+        )
     except IndexError:
         # if no rows when dropna=True
         original_by = [x for x in by]
@@ -216,16 +229,17 @@ def _dissolve(
             query &= gdf[col].notna()
         gdf = gdf.loc[query]
         assert not len(gdf), gdf
-        if not by_was_none and dissolve_kwargs.get("as_index", True):
+        if not by_was_none and as_index:
             try:
                 gdf = gdf.set_index(original_by)
             except Exception as e:
                 print(gdf)
                 print(original_by)
                 raise e
+
         return gdf
 
-    if not by_was_none and dissolve_kwargs.get("as_index", True):
+    if not by_was_none and as_index:
         one_hit = gdf[is_one_hit].set_index(by)
     else:
         one_hit = gdf[is_one_hit]
@@ -234,14 +248,21 @@ def _dissolve(
     if not len(many_hits):
         return GeoDataFrame(one_hit, geometry=geom_col, crs=gdf.crs)
 
-    dissolved = many_hits.groupby(by, **dissolve_kwargs)[other_cols].agg(aggfunc)
+    dissolved = many_hits.groupby(by, as_index=True, **dissolve_kwargs)[other_cols].agg(
+        aggfunc
+    )
 
     # dissolved = gdf.groupby(by, **dissolve_kwargs)[other_cols].agg(aggfunc)
 
     if n_jobs > 1:
         try:
             agged = _parallel_unary_union(
-                many_hits, n_jobs=n_jobs, by=by, grid_size=grid_size, **dissolve_kwargs
+                many_hits,
+                n_jobs=n_jobs,
+                by=by,
+                grid_size=grid_size,
+                as_index=True,
+                **dissolve_kwargs,
             )
             dissolved[geom_col] = agged
             return GeoDataFrame(dissolved, geometry=geom_col, crs=gdf.crs)
@@ -249,21 +270,55 @@ def _dissolve(
             print(e, dissolved, agged, many_hits)
             raise e
 
-    geoms_agged = many_hits.groupby(by, **dissolve_kwargs)[geom_col].agg(
-        lambda x: _merge_geometries(x, grid_size=grid_size)
-    )
+    # geoms_agged = many_hits.groupby(by, **dissolve_kwargs)[geom_col].agg(
+    #     lambda x: _unary_union_for_notna(x, grid_size=grid_size)
+    # )
+    # print("\n\n\ngeomsagged\n", geoms_agged, geoms_agged.shape)
+    geoms_agged = _grouped_unary_union(many_hits, by, as_index=True, **dissolve_kwargs)
+    # print(geoms_agged, geoms_agged.shape)
 
-    if not dissolve_kwargs.get("as_index"):
-        try:
-            geoms_agged = geoms_agged[geom_col]
-        except KeyError:
-            pass
+    # if not as_index:
+    #     try:
+    #         geoms_agged = geoms_agged[geom_col]
+    #     except KeyError:
+    #         pass
 
     dissolved[geom_col] = geoms_agged
 
-    return GeoDataFrame(
-        pd.concat([dissolved, one_hit]).sort_index(), geometry=geom_col, crs=gdf.crs
-    )
+    if not as_index:
+        dissolved = dissolved.reset_index()
+    # else:
+    #     one_hit = one_hit.set
+    # dissolved = dissolved.reset_index()
+
+    # from ..maps.maps import explore, explore_locals
+    # from .conversion import to_gdf
+
+    # try:
+    #     explore(
+    #         dissolved=to_gdf(dissolved, 25833),
+    #         geoms_agged=to_gdf(geoms_agged, 25833),
+    #         gdf=gdf,
+    #         column="ARTYPE",
+    #     )
+    # except Exception:
+    #     explore(
+    #         dissolved=to_gdf(dissolved, 25833),
+    #         geoms_agged=to_gdf(geoms_agged, 25833),
+    #         gdf=gdf,
+    #     )
+
+    # from ..maps.maps import explore_locals
+    # from .conversion import to_gdf
+
+    # explore_locals()
+
+    try:
+        return GeoDataFrame(
+            pd.concat([dissolved, one_hit]).sort_index(), geometry=geom_col, crs=gdf.crs
+        )
+    except TypeError as e:
+        raise e.__class__(e, dissolved.index, one_hit.index) from e
 
 
 def diss(
@@ -358,7 +413,10 @@ def dissexp(
 
 
 def dissexp_by_cluster(
-    gdf: GeoDataFrame, predicate: str | None = None, n_jobs: int = 1, **dissolve_kwargs
+    gdf: GeoDataFrame,
+    predicate: str | None = "intersects",
+    n_jobs: int = 1,
+    **dissolve_kwargs,
 ) -> GeoDataFrame:
     """Dissolves overlapping geometries through clustering with sjoin and networkx.
 
@@ -414,12 +472,14 @@ def diss_by_cluster(
 def _run_func_by_cluster(
     func: Callable,
     gdf: GeoDataFrame,
-    predicate: str | None = None,
+    predicate: str | None = "intersects",
     n_jobs: int = 1,
     **dissolve_kwargs,
 ) -> GeoDataFrame:
     is_geoseries = isinstance(gdf, GeoSeries)
 
+    processes = dissolve_kwargs.pop("processes", 1)
+
     by = dissolve_kwargs.pop("by", [])
     if isinstance(by, str):
         by = [by]
@@ -432,22 +492,44 @@ def _run_func_by_cluster(
     def get_group_clusters(group: GeoDataFrame):
         """Adds cluster column. Applied to each group because much faster."""
         group = group.reset_index(drop=True)
-        group["_cluster"] = get_cluster_mapper(
-            group, predicate=predicate
-        )  # component_mapper
+        group["_cluster"] = get_cluster_mapper(group, predicate=predicate)
         group["_cluster"] = get_grouped_centroids(group, groupby="_cluster")
         return group
 
+    gdf = make_all_singlepart(gdf)
+
     if by:
-        dissolved = (
-            make_all_singlepart(gdf)
-            .groupby(by, group_keys=True, dropna=False, as_index=False)
-            .apply(get_group_clusters)
-            .pipe(func, by=["_cluster"] + by, n_jobs=n_jobs, **dissolve_kwargs)
-        )
+        if processes == 1:
+            gdf = gdf.groupby(by, group_keys=False, dropna=False, as_index=False).apply(
+                get_group_clusters
+            )
+        else:
+            gdf = pd.concat(
+                Parallel(processes, backend="loky").map(
+                    get_group_clusters,
+                    [
+                        gdf[lambda x: x[by].values == values]
+                        for values in np.unique(gdf[by].values)
+                    ],
+                ),
+            )
+        _by = ["_cluster"] + by
+    else:
+        gdf = get_group_clusters(gdf)
+        _by = ["_cluster"]
+
+    if processes == 1:
+        dissolved = func(gdf, by=_by, n_jobs=n_jobs, **dissolve_kwargs)
     else:
-        dissolved = get_group_clusters(make_all_singlepart(gdf)).pipe(
-            func, by="_cluster", n_jobs=n_jobs, **dissolve_kwargs
+        dissolved = pd.concat(
+            Parallel(processes, backend="loky").map(
+                func,
+                [
+                    gdf[gdf["_cluster"] == cluster]
+                    for cluster in gdf["_cluster"].unique()
+                ],
+                kwargs=dissolve_kwargs | {"n_jobs": n_jobs, "by": _by},
+            ),
         )
 
     if not by:

sgis/geopandas_tools/centerlines.py

@@ -2,9 +2,7 @@ import functools
 import itertools
 import warnings
 
-import numpy as np
 import pandas as pd
-import shapely
 from geopandas import GeoDataFrame
 from geopandas import GeoSeries
 from numpy.typing import NDArray
@@ -16,17 +14,17 @@ from shapely import line_merge
 from shapely import make_valid
 from shapely import segmentize
 from shapely import unary_union
+from shapely import union_all
 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
 from ..networkanalysis.traveling_salesman import traveling_salesman_problem
-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 multipoints_to_line_segments
 from .general import sort_long_first
 from .geometry_types import make_all_singlepart
 from .sfilter import sfilter_inverse
@@ -64,7 +62,7 @@ def _remove_longest_if_not_intersecting(
 
     nearest = longest_endpoints.groupby(level=0).apply(
         lambda x: nearest_points(
-            x, not_longest[not_longest.index.isin(x.index)].unary_union
+            x, union_all(not_longest[not_longest.index.isin(x.index)].geometry.values)
         )[1]
     )
     longest_endpoints.loc[:] = make_lines_between_points(
@@ -186,8 +184,6 @@ def get_rough_centerlines(
         ]
     )
 
-    explore(points=to_gdf(points, 25833), gdf=gdf)
-
     remove_longest = functools.partial(_remove_longest_if_not_intersecting, geoms=geoms)
 
     centerlines = GeoSeries(
@@ -336,7 +332,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)
     )
 
@@ -372,86 +368,3 @@ def _get_approximate_polygon_endpoints(geoms: GeoSeries) -> GeoSeries:
         out_geoms.append(points_moved)
 
     return pd.concat(out_geoms)
-
-
-def _multipoints_to_line_segments(
-    multipoints: GeoSeries | GeoDataFrame, to_next: bool = True, cycle: bool = True
-) -> GeoSeries | GeoDataFrame:
-    if not len(multipoints):
-        return multipoints
-
-    multipoints = to_geoseries(multipoints)
-
-    if isinstance(multipoints.index, pd.MultiIndex):
-        index = [
-            multipoints.index.get_level_values(i)
-            for i in range(multipoints.index.nlevels)
-        ]
-        multipoints.index = pd.MultiIndex.from_arrays(
-            [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],
-        )
-
-    try:
-        crs = multipoints.crs
-    except AttributeError:
-        crs = None
-
-    point_df = multipoints.explode(index_parts=False).to_frame("geometry")
-
-    if to_next:
-        shift = -1
-        keep = "first"
-    else:
-        shift = 1
-        keep = "last"
-
-    point_df["next"] = point_df.groupby(level=0)["geometry"].shift(shift)
-
-    if cycle:
-        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
-        assert point_df["next"].notna().all()
-    else:
-        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"], strict=False)
-    ]
-    if isinstance(multipoints.index, pd.MultiIndex):
-        point_df.index = point_df.index.droplevel(0)
-
-    if isinstance(multipoints, GeoDataFrame):
-        return GeoDataFrame(
-            point_df.drop(columns=["next"]), geometry="geometry", crs=crs
-        )
-    return GeoSeries(point_df["geometry"], crs=crs)
-
-
-def get_line_segments(
-    lines: GeoDataFrame | GeoSeries, extract_unique: bool = False, cycle=False
-) -> GeoDataFrame:
-    try:
-        assert lines.index.is_unique
-    except AttributeError:
-        pass
-
-    lines = to_geoseries(lines)
-
-    if extract_unique:
-        points = extract_unique_points(lines.values)
-    else:
-        coords, indices = shapely.get_coordinates(lines, return_index=True)
-        points = GeoSeries(shapely.points(coords), index=indices)
-
-    return _multipoints_to_line_segments(points, cycle=cycle)