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

sgis/__init__.py

@@ -2,147 +2,133 @@ config = {
     "n_jobs": 1,
 }
 
-import sgis.raster.bands as bands
 import sgis.raster.indices as indices
-from sgis.raster.raster import Raster, get_shape_from_bounds, get_transform_from_bounds
+from sgis.raster.raster import Raster
+from sgis.raster.raster import get_shape_from_bounds
+from sgis.raster.raster import get_transform_from_bounds
 
-from .geopandas_tools.bounds import (
-    Gridlooper,
-    bounds_to_points,
-    bounds_to_polygon,
-    get_total_bounds,
-    gridloop,
-    make_grid,
-    make_grid_from_bbox,
-    make_ssb_grid,
-    points_in_bounds,
-)
-from .geopandas_tools.buffer_dissolve_explode import (
-    buff,
-    buffdiss,
-    buffdissexp,
-    buffdissexp_by_cluster,
-    diss,
-    diss_by_cluster,
-    dissexp,
-    dissexp_by_cluster,
-)
+from .geopandas_tools.bounds import Gridlooper
+from .geopandas_tools.bounds import bounds_to_points
+from .geopandas_tools.bounds import bounds_to_polygon
+from .geopandas_tools.bounds import get_total_bounds
+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
+from .geopandas_tools.buffer_dissolve_explode import buffdissexp_by_cluster
+from .geopandas_tools.buffer_dissolve_explode import diss
+from .geopandas_tools.buffer_dissolve_explode import diss_by_cluster
+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,
-    remove_interior_slivers,
-    remove_spikes,
-    split_and_eliminate_by_longest,
-    split_by_neighbors,
-)
-from .geopandas_tools.conversion import (
-    coordinate_array,
-    from_4326,
-    to_4326,
-    to_bbox,
-    to_gdf,
-    to_geoseries,
-    to_shapely,
-)
-from .geopandas_tools.duplicates import (  # drop_duplicate_geometries,
-    get_intersections,
-    update_geometries,
-)
-from .geopandas_tools.general import (
-    clean_clip,
-    clean_geoms,
-    drop_inactive_geometry_columns,
-    get_common_crs,
-    get_grouped_centroids,
-    random_points,
-    random_points_in_polygons,
-    rename_geometry_if,
-    sort_large_first,
-    sort_long_first,
-    sort_short_first,
-    sort_small_first,
-    to_lines,
-)
-from .geopandas_tools.geocoding import address_to_coords, address_to_gdf
-from .geopandas_tools.geometry_types import (
-    get_geom_type,
-    is_single_geom_type,
-    make_all_singlepart,
-    to_single_geom_type,
-)
-from .geopandas_tools.neighbors import (
-    get_all_distances,
-    get_k_nearest_neighbors,
-    get_neighbor_dfs,
-    get_neighbor_indices,
-    k_nearest_neighbors,
-    sjoin_within_distance,
-)
+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.conversion import coordinate_array
+from .geopandas_tools.conversion import from_4326
+from .geopandas_tools.conversion import to_4326
+from .geopandas_tools.conversion import to_bbox
+from .geopandas_tools.conversion import to_gdf
+from .geopandas_tools.conversion import to_geoseries
+from .geopandas_tools.conversion import to_shapely
+from .geopandas_tools.duplicates import get_intersections  # drop_duplicate_geometries,
+from .geopandas_tools.duplicates import update_geometries  # drop_duplicate_geometries,
+from .geopandas_tools.general import _rename_geometry_if
+from .geopandas_tools.general import clean_clip
+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 random_points
+from .geopandas_tools.general import random_points_in_polygons
+from .geopandas_tools.general import sort_large_first
+from .geopandas_tools.general import sort_long_first
+from .geopandas_tools.general import sort_short_first
+from .geopandas_tools.general import sort_small_first
+from .geopandas_tools.general import to_lines
+from .geopandas_tools.geocoding import address_to_coords
+from .geopandas_tools.geocoding import address_to_gdf
+from .geopandas_tools.geometry_types import get_geom_type
+from .geopandas_tools.geometry_types import is_single_geom_type
+from .geopandas_tools.geometry_types import make_all_singlepart
+from .geopandas_tools.geometry_types import to_single_geom_type
+from .geopandas_tools.neighbors import get_all_distances
+from .geopandas_tools.neighbors import get_k_nearest_neighbors
+from .geopandas_tools.neighbors import get_neighbor_dfs
+from .geopandas_tools.neighbors import get_neighbor_indices
+from .geopandas_tools.neighbors import k_nearest_neighbors
+from .geopandas_tools.neighbors import sjoin_within_distance
 from .geopandas_tools.overlay import clean_overlay
-from .geopandas_tools.point_operations import snap_all, snap_within_distance
-from .geopandas_tools.polygon_operations import (
-    PolygonsAsRings,
-    close_all_holes,
-    close_small_holes,
-    close_thin_holes,
-    eliminate_by_largest,
-    eliminate_by_longest,
-    eliminate_by_smallest,
-    get_cluster_mapper,
-    get_gaps,
-    get_holes,
-    get_polygon_clusters,
-)
+from .geopandas_tools.point_operations import snap_all
+from .geopandas_tools.point_operations import snap_within_distance
+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
+from .geopandas_tools.polygon_operations import eliminate_by_largest
+from .geopandas_tools.polygon_operations import eliminate_by_longest
+from .geopandas_tools.polygon_operations import eliminate_by_smallest
+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.polygons_as_rings import PolygonsAsRings
-from .geopandas_tools.sfilter import sfilter, sfilter_inverse, sfilter_split
-from .helpers import get_object_name, sort_nans_last
+from .geopandas_tools.sfilter import sfilter
+from .geopandas_tools.sfilter import sfilter_inverse
+from .geopandas_tools.sfilter import sfilter_split
+from .helpers import get_object_name
+from .helpers import sort_nans_last
 from .io.opener import opener
 from .io.read_parquet import read_parquet_url
 from .maps.examine import Examine
 from .maps.explore import Explore
 from .maps.httpserver import run_html_server
 from .maps.legend import Legend
-from .maps.maps import clipmap, explore, explore_locals, qtm, samplemap
+from .maps.maps import clipmap
+from .maps.maps import explore
+from .maps.maps import explore_locals
+from .maps.maps import qtm
+from .maps.maps import samplemap
 from .maps.thematicmap import ThematicMap
 from .maps.tilesources import kartverket as kartverket_tiles
 from .maps.tilesources import xyz as xyztiles
-from .networkanalysis.closing_network_holes import (
-    close_network_holes,
-    close_network_holes_to_deadends,
-)
-from .networkanalysis.cutting_lines import (
-    cut_lines,
-    cut_lines_once,
-    split_lines_by_nearest_point,
-)
-from .networkanalysis.directednetwork import (
-    make_directed_network,
-    make_directed_network_norway,
-)
-from .networkanalysis.finding_isolated_networks import (
-    get_component_size,
-    get_connected_components,
-)
+from .networkanalysis.closing_network_holes import close_network_holes
+from .networkanalysis.closing_network_holes import close_network_holes_to_deadends
+from .networkanalysis.cutting_lines import cut_lines
+from .networkanalysis.cutting_lines import cut_lines_once
+from .networkanalysis.cutting_lines import split_lines_by_nearest_point
+from .networkanalysis.directednetwork import make_directed_network
+from .networkanalysis.directednetwork import make_directed_network_norway
+from .networkanalysis.finding_isolated_networks import get_component_size
+from .networkanalysis.finding_isolated_networks import get_connected_components
 from .networkanalysis.network import Network
 from .networkanalysis.networkanalysis import NetworkAnalysis
 from .networkanalysis.networkanalysisrules import NetworkAnalysisRules
-from .networkanalysis.nodes import (
-    make_edge_coords_cols,
-    make_edge_wkt_cols,
-    make_node_ids,
-)
+from .networkanalysis.nodes import make_edge_coords_cols
+from .networkanalysis.nodes import make_edge_wkt_cols
+from .networkanalysis.nodes import make_node_ids
 from .networkanalysis.traveling_salesman import traveling_salesman_problem
-from .parallel.parallel import Parallel, parallel_overlay
+from .parallel.parallel import Parallel
+from .parallel.parallel import parallel_overlay
 from .raster.cube import DataCube
-
-
-try:
-    import sgis.raster.torchgeo as torchgeo
-except ImportError:
-    pass
-
+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 Sentinel2Band
+from .raster.image_collection import Sentinel2CloudlessCollection
+from .raster.image_collection import Sentinel2CloudlessImage
+from .raster.image_collection import Sentinel2Collection
+from .raster.image_collection import Sentinel2Image
+from .raster.image_collection import concat_image_collections
 
 try:
-    from .io.dapla_functions import check_files, read_geopandas, write_geopandas
+    from .io.dapla_functions import check_files
+    from .io.dapla_functions import read_geopandas
+    from .io.dapla_functions import write_geopandas
 except ImportError:
     pass

sgis/exceptions.py

@@ -1,21 +1,23 @@
 """Some small exception classes."""
 
 
-class NoPointsWithinSearchToleranceError(Exception):
+class NoPointsWithinSearchToleranceError(ValueError):
     """Exception for when the points are too far away from the network."""
 
     def __init__(
         self, what: str | None = None, search_tolerance: str | None = None
     ) -> None:
+        """Initialise error class."""
         self.what = what
         self.search_tolerance = search_tolerance
 
-    def __str__(self):
+    def __str__(self) -> str:
+        """String representation."""
         return (
             f"No {self.what} within specified 'search_tolerance' "
             f"of {self.search_tolerance}"
         )
 
 
-class ZeroLinesError(Exception):
+class ZeroLinesError(ValueError):
     """DataFrame has 0 rows."""

sgis/geopandas_tools/__init__.py

@@ -0,0 +1 @@
+"""Tools for vector gis."""

sgis/geopandas_tools/bounds.py

@@ -1,20 +1,24 @@
 import functools
-import numbers
-from collections.abc import Callable, Collection, Mapping
+from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any
 
 import geopandas as gpd
 import numpy as np
 import pandas as pd
-from geopandas import GeoDataFrame, GeoSeries
-from pandas.api.types import is_dict_like
-from shapely import Geometry, box, extract_unique_points
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
+from pyproj import CRS
+from shapely import Geometry
+from shapely import box
+from shapely import extract_unique_points
 from shapely.geometry import Polygon
 
 from ..parallel.parallel import Parallel
-from .conversion import to_bbox, to_gdf
-from .general import clean_clip, is_bbox_like
+from .conversion import to_bbox
+from .conversion import to_gdf
+from .general import clean_clip
+from .general import is_bbox_like
 
 
 @dataclass
@@ -32,9 +36,8 @@ class Gridlooper:
         keep_geom_type: Whether to keep only the input geometry types after clipping.
             Defaults to True.
 
-    Examples
-    --------
-
+    Examples:
+    ---------
     Get some points and some polygons.
 
     >>> import sgis as sg
@@ -46,7 +49,7 @@ class Gridlooper:
     0      0  POLYGON ((263222.700 6651184.900, 263222.651 6...
     1      1  POLYGON ((272556.100 6653369.500, 272556.051 6...
     2      2  POLYGON ((270182.300 6653032.700, 270182.251 6...
-    3      3  POLYGON ((259904.800 6650339.700, 259904.751 6...
+        3      3  POLYGON ((259904.800 6650339.700, 259904.751 6...
     4      4  POLYGON ((272976.200 6652889.100, 272976.151 6...
     ..   ...                                                ...
     995  995  POLYGON ((266901.700 6647844.500, 266901.651 6...
@@ -95,16 +98,24 @@ class Gridlooper:
     keep_geom_type: bool = True
     verbose: bool = False
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
+        """Fix types."""
         if not isinstance(self.mask, GeoDataFrame):
             self.mask = to_gdf(self.mask)
 
-    def run(self, func: Callable, *args, **kwargs):
-        def intersects_mask(df):
+    def run(self, func: Callable, *args, **kwargs) -> Any | list[Any]:
+        """Run a function for each grid cell in a loop.
+
+        Returns a list of the return values from the function,
+        or a (Geo)DataFrame if self.concat is True.
+
+        """
+
+        def _intersects_mask(df: GeoDataFrame) -> pd.Series:
             return df.index.isin(df.sjoin(self.mask).index)
 
         grid: GeoSeries = (
-            make_grid(self.mask, gridsize=self.gridsize).loc[intersects_mask].geometry
+            make_grid(self.mask, gridsize=self.gridsize).loc[_intersects_mask].geometry
         )
 
         n = len(grid)
@@ -137,7 +148,9 @@ class Gridlooper:
             return out if not self.concat else pd.concat(out, ignore_index=True)
 
         results = []
-        for i, (unbuffered, buffered) in enumerate(zip(grid, buffered_grid)):
+        for i, (unbuffered, buffered) in enumerate(
+            zip(grid, buffered_grid, strict=False)
+        ):
             cell_kwargs = {
                 key: _clip_if_isinstance(
                     value, buffered, self.keep_geom_type, self.clip
@@ -200,13 +213,16 @@ def gridloop(
         kwargs: Keyword arguments to pass to the function. Arguments
             of type GeoDataFrame or GeoSeries will be clipped by the grid cells in
             a loop.
+        parallelizer: Optional instance of sgis.Parallel, to run the function in parallel.
 
     Returns:
         List of results with the same length as number of grid cells.
 
-    Examples
-    --------
+    Raises:
+        TypeError: If args or kwargs has a wrong type
 
+    Examples:
+    ---------
     Get some points and some polygons.
 
     >>> import sgis as sg
@@ -274,8 +290,10 @@ def gridloop(
     if not isinstance(mask, GeoDataFrame):
         mask = to_gdf(mask)
 
-    intersects_mask = lambda df: df.index.isin(df.sjoin(mask).index)
-    grid: GeoSeries = make_grid(mask, gridsize=gridsize).loc[intersects_mask].geometry
+    def _intersects_mask(df: GeoDataFrame) -> pd.Series:
+        return df.index.isin(df.sjoin(mask).index)
+
+    grid: GeoSeries = make_grid(mask, gridsize=gridsize).loc[_intersects_mask].geometry
 
     n = len(grid)
 
@@ -301,7 +319,7 @@ def gridloop(
         return out
 
     results = []
-    for i, (unbuffered, buffered) in enumerate(zip(grid, buffered_grid)):
+    for i, (unbuffered, buffered) in enumerate(zip(grid, buffered_grid, strict=False)):
         cell_kwargs = {
             key: _clip_if_isinstance(value, buffered, keep_geom_type, clip)
             for key, value in kwargs.items()
@@ -333,7 +351,7 @@ def _clip_and_run_func(
     kwargs: dict,
     keep_geom_type: bool,
     clip: bool,
-):
+) -> Any:
     cell_args = tuple(
         _clip_if_isinstance(value, grid_cell, keep_geom_type, clip) for value in args
     )
@@ -345,11 +363,13 @@ def _clip_and_run_func(
     return func(*cell_args, **cell_kwargs)
 
 
-def _clip_if_isinstance(value, cell, keep_geom_type, clip: bool):
-    if not isinstance(value, (gpd.GeoDataFrame, gpd.GeoSeries, Geometry)):
+def _clip_if_isinstance(
+    value: Any, cell: Geometry, keep_geom_type: bool, clip: bool
+) -> Any:
+    if not isinstance(value, (gpd.GeoDataFrame | gpd.GeoSeries | Geometry)):
         return value
 
-    if isinstance(value, (gpd.GeoDataFrame, gpd.GeoSeries)):
+    if isinstance(value, (gpd.GeoDataFrame | gpd.GeoSeries)):
         if clip:
             return clean_clip(value, cell, keep_geom_type=keep_geom_type)
         return value.loc[value.intersects(cell)]
@@ -357,10 +377,12 @@ def _clip_if_isinstance(value, cell, keep_geom_type, clip: bool):
     return value.intersection(cell).make_valid()
 
 
-def _clip_back_to_unbuffered_grid(results, mask, keep_geom_type):
-    if isinstance(results, (gpd.GeoDataFrame, gpd.GeoSeries, Geometry)):
+def _clip_back_to_unbuffered_grid(
+    results: Any, mask: GeoDataFrame, keep_geom_type: bool
+) -> Any:
+    if isinstance(results, (gpd.GeoDataFrame | gpd.GeoSeries | Geometry)):
         return _clip_if_isinstance(results, mask, keep_geom_type, clip=True)
-    elif isinstance(results, (pd.DataFrame, pd.Series, np.ndarray)):
+    elif isinstance(results, (pd.DataFrame | pd.Series | np.ndarray)):
         return results
     try:
         for key, value in results.items():
@@ -383,7 +405,7 @@ def make_grid_from_bbox(
     maxy: int | float,
     *_,
     gridsize: int | float,
-    crs,
+    crs: CRS | int | str,
 ) -> GeoDataFrame:
     """Creates a polygon grid from a bounding box.
 
@@ -420,7 +442,7 @@ def make_grid(
     obj: GeoDataFrame | GeoSeries | Geometry | tuple,
     gridsize: int | float,
     *,
-    crs=None,
+    crs: CRS | None = None,
     clip_to_bounds: bool = False,
 ) -> GeoDataFrame:
     """Create a polygon grid around geometries.
@@ -439,13 +461,12 @@ def make_grid(
     Returns:
         GeoDataFrame with grid polygons.
 
+    Raises:
+        ValueError: crs can only be None if obj is GeoDataFrame/GeoSeries.
+
     """
-    if isinstance(obj, (GeoDataFrame, GeoSeries)):
+    if isinstance(obj, (GeoDataFrame | GeoSeries)):
         crs = obj.crs or crs
-    elif not crs:
-        raise ValueError(
-            "'crs' cannot be None when 'obj' is not GeoDataFrame/GeoSeries."
-        )
     if hasattr(obj, "__len__") and not len(obj):
         return GeoDataFrame({"geometry": []}, crs=crs)
 
@@ -475,14 +496,17 @@ def make_ssb_grid(
     Args:
         gdf: A GeoDataFrame.
         gridsize: Size of the grid in meters.
+        add: Number of grid cells to add on each side,
+            to make sure all data is covered by the grid.
 
     Returns:
         GeoDataFrame with grid geometries and a column 'SSBID'.
 
     Raises:
         ValueError: If the GeoDataFrame does not have 25833 as crs.
+        TypeError: if gdf has wrong type.
     """
-    if not isinstance(gdf, (GeoDataFrame, GeoSeries)):
+    if not isinstance(gdf, (GeoDataFrame | GeoSeries)):
         raise TypeError("gdf must be GeoDataFrame og GeoSeries.")
 
     if not gdf.crs.equals(25833):
@@ -551,6 +575,7 @@ def add_grid_id(
     Args:
         gdf: A GeoDataFrame.
         gridsize: Size of the grid in meters.
+        out_column: Name of column for the grid id.
 
     Returns:
         The input GeoDataFrame with a new grid id column.
@@ -587,9 +612,9 @@ def bounds_to_polygon(
     Returns:
         GeoDataFrame of box polygons with length and index of 'gdf'.
 
-    Examples
-    --------
-
+    Examples:
+    ---------
+    >>> import sgis as sg
     >>> gdf = sg.to_gdf([MultiPoint([(0, 0), (1, 1)]), Point(0, 0)])
     >>> gdf
                                             geometry
@@ -622,8 +647,9 @@ def bounds_to_points(
     Returns:
         GeoDataFrame of multipoints with same length and index as 'gdf'.
 
-    Examples
-    --------
+    Examples:
+    ---------
+    >>> import sgis as sg
     >>> gdf = sg.to_gdf([MultiPoint([(0, 0), (1, 1)]), Point(0, 0)])
     >>> gdf
                                             geometry
@@ -643,19 +669,32 @@ def bounds_to_points(
 
 
 def get_total_bounds(
-    *geometries: GeoDataFrame | GeoSeries | Geometry,
+    *geometries: GeoDataFrame | GeoSeries | Geometry, strict: bool = False
 ) -> tuple[float, float, float, float]:
     """Get a combined total bounds of multiple geometry objects."""
     xs, ys = [], []
     for obj in geometries:
-        minx, miny, maxx, maxy = to_bbox(obj)
-        xs += [minx, maxx]
-        ys += [miny, maxy]
+        try:
+            minx, miny, maxx, maxy = to_bbox(obj)
+            xs += [minx, maxx]
+            ys += [miny, maxy]
+        except Exception as e:
+            try:
+                for x in obj:
+                    minx, miny, maxx, maxy = to_bbox(x)
+                    xs += [minx, maxx]
+                    ys += [miny, maxy]
+            except Exception as e2:
+                if strict:
+                    raise e2 from e
+                else:
+                    continue
     return min(xs), min(ys), max(xs), max(ys)
 
 
-def points_in_bounds(gdf: GeoDataFrame | GeoSeries, n2: int):
-    if not isinstance(gdf, (GeoDataFrame, GeoSeries)) and is_bbox_like(gdf):
+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