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

sgis/networkanalysis/_od_cost_matrix.py

@@ -47,7 +47,9 @@ def _od_cost_matrix(
     return results.reset_index(drop=True)
 
 
-def _get_od_df(graph, origins, destinations, weight_col):
+def _get_od_df(
+    graph: Graph, origins: GeoDataFrame, destinations: GeoDataFrame, weight_col: str
+) -> pd.DataFrame:
     distances: list[list[float]] = graph.distances(
         weights="weight",
         source=origins,
@@ -68,3 +70,44 @@ def _get_od_df(graph, origins, destinations, weight_col):
         .replace([np.inf, -np.inf], np.nan)
         .reset_index(drop=True)
     )
+
+
+def _get_one_od_df(
+    graph: Graph, origins: GeoDataFrame, destinations: GeoDataFrame, weight_col: str
+) -> pd.DataFrame:
+    distances: list[list[float]] = graph.distances(
+        weights="weight",
+        source=origins,
+        target=destinations,
+    )
+
+    ori_idx, des_idx, costs = [], [], []
+    for i, f_idx in enumerate(origins):
+        for j, t_idx in enumerate(destinations):
+            ori_idx.append(f_idx)
+            des_idx.append(t_idx)
+            costs.append(distances[i][j])
+
+    return (
+        pd.DataFrame(
+            data={"origin": ori_idx, "destination": des_idx, weight_col: costs}
+        )
+        .replace([np.inf, -np.inf], np.nan)
+        .reset_index(drop=True)
+    )
+
+
+# def _get_od_df(
+#     graph: Graph,
+#     origins: GeoDataFrame,
+#     destinations: GeoDataFrame,
+#     weight_col: str,
+# ) -> pd.DataFrame:
+#     from ..parallel.parallel import Parallel
+
+#     results: list[pd.DataFrame] = Parallel(40, backend="loky").map(
+#         _get_one_od_df,
+#         [origins[origins.index == i] for i in origins.index.unique()],
+#         kwargs=dict(graph=graph, destinations=destinations, weight_col=weight_col),
+#     )
+#     return pd.concat(results, ignore_index=True)

sgis/networkanalysis/_points.py

@@ -1,10 +1,12 @@
+from collections.abc import Sequence
+
 import numpy as np
+import pandas as pd
 from geopandas import GeoDataFrame
 
 from ..geopandas_tools.neighbors import get_k_nearest_neighbors
 from .networkanalysisrules import NetworkAnalysisRules
 
-
 """
 These are internal classes used in the NetworkAnalysis class. The classes used in
 NetworkAnalysis are Origins and Destinations, which are subclasses of Points. The
@@ -26,7 +28,6 @@ class Points:
         The original indices are stored in a dict and mapped back to the results in the
         end.
         """
-
         self.gdf["temp_idx"] = np.arange(start=start, stop=start + len(self.gdf))
         self.gdf["temp_idx"] = self.gdf["temp_idx"].astype(str)
 
@@ -36,7 +37,9 @@ class Points:
         }
 
     @staticmethod
-    def _convert_distance_to_weight(distances, rules):
+    def _convert_distance_to_weight(
+        distances: Sequence, rules: NetworkAnalysisRules
+    ) -> list[float]:
         """Meters to minutes based on 'weight_to_nodes_' attribute of the rules."""
         if not rules.nodedist_multiplier and not rules.nodedist_kmh:
             return [0 for _ in distances]
@@ -60,7 +63,9 @@ class Points:
 
         return [x / (16.666667 * rules.nodedist_kmh) for x in distances]
 
-    def _make_edges(self, df, from_col, to_col):
+    def _make_edges(
+        self, df: GeoDataFrame | pd.DataFrame, from_col: str, to_col: str
+    ) -> list[tuple[int, int]]:
         return [(f, t) for f, t in zip(df[from_col], df[to_col], strict=True)]
 
     def _get_edges_and_weights(
@@ -71,6 +76,7 @@ class Points:
         from_col: str,
         to_col: str,
     ):
+        """Make edges and weights between points and the nodes of a network."""
         distances = get_k_nearest_neighbors(
             gdf=self.gdf.set_index("temp_idx"),
             neighbors=nodes.set_index("node_id"),

sgis/networkanalysis/_service_area.py

@@ -2,8 +2,11 @@ import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
 from igraph import Graph
-from shapely import force_2d, reverse, unary_union
-from shapely.geometry import MultiLineString, MultiPoint, Point
+from shapely import force_2d
+from shapely import reverse
+from shapely import unary_union
+from shapely.geometry import MultiPoint
+from shapely.geometry import Point
 from shapely.ops import nearest_points
 from shapely.wkt import loads
 

sgis/networkanalysis/closing_network_holes.py

@@ -3,61 +3,15 @@
 import geopandas as gpd
 import numpy as np
 import pandas as pd
-from geopandas import GeoDataFrame, GeoSeries
+from geopandas import GeoDataFrame
+from geopandas import GeoSeries
 from pandas import DataFrame
 from shapely import shortest_line
 
-from ..geopandas_tools.conversion import coordinate_array, to_geoseries
-from ..geopandas_tools.geometry_types import get_geom_type
+from ..geopandas_tools.conversion import coordinate_array
 from ..geopandas_tools.neighbors import k_nearest_neighbors
-from .nodes import make_edge_wkt_cols, make_node_ids
-
-
-def close_network_holes_to(
-    lines: GeoDataFrame | GeoSeries,
-    extend_to: GeoDataFrame | GeoSeries,
-    max_distance: int | float,
-    max_angle: int | float,
-) -> GeoDataFrame | GeoSeries:
-    if isinstance(lines, GeoSeries):
-        lines = lines.to_frame("geometry")
-        was_geoseries = True
-    else:
-        was_geoseries = False
-
-    lines, _ = make_node_ids(lines)
-
-    if isinstance(extend_to, GeoSeries):
-        extend_to = extend_to.to_frame("geometry")
-
-    if not (extend_to.geom_type == "Point").all():
-        raise ValueError("'extend_to' must be singlepart point geometries")
-
-    extend_to["wkt"] = extend_to.geometry.to_wkt()
-    extend_to = extend_to.drop_duplicates("wkt")
-    extend_to["node_id"] = range(len(extend_to))
-
-    new_lines: GeoSeries = _close_holes_all_lines(
-        lines, extend_to, max_distance=max_distance, max_angle=max_angle, idx_start=0
-    )
-
-    if was_geoseries:
-        return pd.concat([lines.geometry, new_lines])
-
-    new_lines = gpd.GeoDataFrame(
-        {"geometry": new_lines}, geometry="geometry", crs=lines.crs
-    )
-
-    return pd.concat([lines, new_lines], ignore_index=True).drop(
-        columns=[
-            "source_wkt",
-            "target_wkt",
-            "source",
-            "target",
-            "n_source",
-            "n_target",
-        ]
-    )
+from .nodes import make_edge_wkt_cols
+from .nodes import make_node_ids
 
 
 def close_network_holes(
@@ -65,7 +19,7 @@ def close_network_holes(
     max_distance: int | float,
     max_angle: int,
     hole_col: str | None = "hole",
-):
+) -> GeoDataFrame:
     """Fills network gaps with straigt lines.
 
     Fills holes in the network by connecting deadends with the nodes that are
@@ -89,8 +43,8 @@ def close_network_holes(
         The holes will have missing values in the weight column used in
         NetworkAnalysis. These values must be filled before analysis.
 
-    Examples
-    --------
+    Examples:
+    ---------
     Read road data with small gaps.
 
     >>> import sgis as sg
@@ -105,10 +59,10 @@ def close_network_holes(
 
     >>> filled = sg.close_network_holes(roads, max_distance=1.1, max_angle=180)
     >>> filled.hole.value_counts()
-    Name: connected, dtype: int64
+    hole
     0    93395
     1     7102
-    Name: hole, dtype: int64
+    Name: count, dtype: int64
 
     Compare the number of isolated lines before and after.
 
@@ -128,15 +82,15 @@ def close_network_holes(
 
     >>> filled = sg.close_network_holes(roads, max_distance=1.1, max_angle=30)
     >>> filled.hole.value_counts()
+    hole
     0    93395
     1     7092
-    Name: hole, dtype: int64
+    Name: count, dtype: int64
 
     It's not always wise to fill gaps. In the case of this data, these small gaps are
     intentional. They are road blocks where most cars aren't allowed to pass. Fill the
     holes only if it makes the travel times/routes more realistic.
     """
-
     lines, nodes = make_node_ids(gdf)
 
     # remove duplicates of lines going both directions
@@ -174,7 +128,7 @@ def close_network_holes(
     return pd.concat([lines, new_lines], ignore_index=True)
 
 
-def get_angle(array_a, array_b):
+def get_angle(array_a: np.ndarray, array_b: np.ndarray) -> np.ndarray:
     dx = array_b[:, 0] - array_a[:, 0]
     dy = array_b[:, 1] - array_a[:, 1]
 
@@ -187,7 +141,7 @@ def close_network_holes_to_deadends(
     gdf: GeoDataFrame,
     max_distance: int | float,
     hole_col: str | None = "hole",
-):
+) -> GeoDataFrame:
     """Fills gaps between two deadends if the distance is less than 'max_distance'.
 
     Fills holes between deadends in the network with straight lines if the distance is
@@ -202,8 +156,8 @@ def close_network_holes_to_deadends(
     Returns:
         The input GeoDataFrame with new lines added.
 
-    Examples
-    --------
+    Examples:
+    ---------
     Read road data with small gaps.
 
     >>> import sgis as sg
@@ -246,7 +200,7 @@ def close_network_holes_to_deadends(
     new_lines = make_edge_wkt_cols(new_lines)
 
     wkt_id_dict = {
-        wkt: id for wkt, id in zip(nodes["wkt"], nodes["node_id"], strict=True)
+        wkt: id_ for wkt, id_ in zip(nodes["wkt"], nodes["node_id"], strict=True)
     }
     new_lines["source"] = new_lines["source_wkt"].map(wkt_id_dict)
     new_lines["target"] = new_lines["target_wkt"].map(wkt_id_dict)
@@ -259,7 +213,11 @@ def close_network_holes_to_deadends(
 
 
 def _close_holes_all_lines(
-    lines, nodes, max_distance, max_angle, idx_start: int
+    lines: GeoDataFrame,
+    nodes: GeoDataFrame,
+    max_distance: int | None,
+    max_angle: int | None,
+    idx_start: int,
 ) -> GeoSeries:
     k = min(len(nodes), 50)
 

sgis/networkanalysis/cutting_lines.py

@@ -1,31 +1,23 @@
 """Cutting and splitting line geometries."""
+
 import warnings
 
 import numpy as np
 import pandas as pd
-from geopandas import GeoDataFrame, GeoSeries
-from pandas import DataFrame, Series
-from shapely import (
-    buffer,
-    extract_unique_points,
-    force_2d,
-    get_coordinates,
-    get_parts,
-    linestrings,
-    touches,
-    unary_union,
-)
-from shapely.geometry import LineString, Point
+from geopandas import GeoDataFrame
+from pandas import DataFrame
+from pandas import Series
+from shapely import extract_unique_points
+from shapely import force_2d
+from shapely.geometry import LineString
+from shapely.geometry import Point
 
 from ..geopandas_tools.buffer_dissolve_explode import buff
 from ..geopandas_tools.conversion import to_gdf
 from ..geopandas_tools.geometry_types import get_geom_type
 from ..geopandas_tools.neighbors import get_k_nearest_neighbors
-from ..geopandas_tools.point_operations import (
-    _shapely_snap,
-    snap_all,
-    snap_within_distance,
-)
+from ..geopandas_tools.point_operations import snap_all
+from ..geopandas_tools.point_operations import snap_within_distance
 from ..geopandas_tools.sfilter import sfilter_split
 from .nodes import make_edge_coords_cols
 
@@ -59,8 +51,8 @@ def split_lines_by_nearest_point(
     Raises:
         ValueError: If the crs of the input data differs.
 
-    Examples
-    --------
+    Examples:
+    ---------
     >>> from sgis import read_parquet_url, split_lines_by_nearest_point
     >>> roads = read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet")
     >>> points = read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/points_oslo.parquet")
@@ -148,8 +140,8 @@ def split_lines_by_nearest_point(
     splitted_source = to_gdf(splitted["source_coords"], crs=gdf.crs)
     splitted_target = to_gdf(splitted["target_coords"], crs=gdf.crs)
 
-    def get_nearest(splitted, snapped) -> pd.DataFrame:
-        """find the nearest snapped point for each source and target of the lines"""
+    def get_nearest(splitted: GeoDataFrame, snapped: GeoDataFrame) -> pd.DataFrame:
+        """Find the nearest snapped point for each source and target of the lines."""
         return get_k_nearest_neighbors(splitted, snapped, k=1).loc[
             lambda x: x["distance"] <= PRECISION * 2
         ]
@@ -166,7 +158,7 @@ def split_lines_by_nearest_point(
     # now, we can replace the source/target coordinate with the coordinates of
     # the snapped points.
 
-    splitted = change_line_endpoint(
+    splitted = _change_line_endpoint(
         splitted,
         indices=dists_source.index,
         pointmapper=pointmapper_source,
@@ -174,7 +166,7 @@ def split_lines_by_nearest_point(
     )  # i=0)
 
     # same for the lines where the target was split, but change the last coordinate
-    splitted = change_line_endpoint(
+    splitted = _change_line_endpoint(
         splitted,
         indices=dists_target.index,
         pointmapper=pointmapper_target,
@@ -189,22 +181,38 @@ def split_lines_by_nearest_point(
     )
 
 
-def change_line_endpoint(
+def _change_line_endpoint(
     gdf: GeoDataFrame,
     indices: pd.Index,
     pointmapper: pd.Series,
     change_what: str | int,
 ) -> GeoDataFrame:
-    """
-    Loop for each line where the source is the endpoint that was split
-    change the first point of the line to the point it was split by
+    """Modify the endpoints of selected lines in a GeoDataFrame based on an index mapping.
+
+    This function updates the geometry of specified line features within a GeoDataFrame,
+    changing either the first or last point of each line to new coordinates provided by a mapping.
+    It is typically used in scenarios where line endpoints need to be adjusted to new locations,
+    such as in network adjustments or data corrections.
+
+    Args:
+        gdf: A GeoDataFrame containing line geometries.
+        indices: An Index object identifying the rows in the GeoDataFrame whose endpoints will be changed.
+        pointmapper: A Series mapping from the index of lines to new point geometries.
+        change_what: Specifies which endpoint of the line to change. Accepts 'first' or 0 for the
+            starting point, and 'last' or -1 for the ending point.
+
+    Returns:
+        A GeoDataFrame with the specified line endpoints updated according to the pointmapper.
+
+    Raises:
+        ValueError: If `change_what` is not one of the accepted values ('first', 'last', 0, -1).
     """
     assert gdf.index.is_unique
 
     if change_what == "first" or change_what == 0:
-        to_be_changed = lambda x: ~x.index.duplicated(keep="first")
+        keep = "first"
     elif change_what == "last" or change_what == -1:
-        to_be_changed = lambda x: ~x.index.duplicated(keep="last")
+        keep = "last"
     else:
         raise ValueError(
             f"change_what should be 'first' or 'last' or 0 or -1. Got {change_what}"
@@ -216,8 +224,10 @@ def change_line_endpoint(
     relevant_lines.geometry = extract_unique_points(relevant_lines.geometry)
     relevant_lines = relevant_lines.explode(index_parts=False)
 
-    relevant_lines.loc[to_be_changed, "geometry"] = (
-        relevant_lines.loc[to_be_changed].index.map(pointmapper).values
+    relevant_lines.loc[lambda x: ~x.index.duplicated(keep=keep), "geometry"] = (
+        relevant_lines.loc[lambda x: ~x.index.duplicated(keep=keep)]
+        .index.map(pointmapper)
+        .values
     )
 
     relevant_lines_mapped = relevant_lines.groupby(level=0)["geometry"].agg(LineString)
@@ -227,7 +237,9 @@ def change_line_endpoint(
     return gdf
 
 
-def cut_lines(gdf: GeoDataFrame, max_length: int, ignore_index=False) -> GeoDataFrame:
+def cut_lines(
+    gdf: GeoDataFrame, max_length: int, ignore_index: bool = False
+) -> GeoDataFrame:
     """Cuts lines of a GeoDataFrame into pieces of a given length.
 
     Args:
@@ -242,8 +254,8 @@ def cut_lines(gdf: GeoDataFrame, max_length: int, ignore_index=False) -> GeoData
     Note:
         This method is time consuming for large networks and low 'max_length'.
 
-    Examples
-    --------
+    Examples:
+    ---------
     >>> from sgis import read_parquet_url, cut_lines
     >>> roads = read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet")
     >>> roads.length.describe().round(1)
@@ -314,8 +326,8 @@ def cut_lines_once(
         ignore_index: If True, the resulting axis will be labeled 0, 1, …, n - 1.
             Defaults to False.
 
-    Examples
-    --------
+    Examples:
+    ---------
     >>> from sgis import cut_lines_once, to_gdf
     >>> import pandas as pd
     >>> from shapely.geometry import LineString
@@ -344,24 +356,24 @@ def cut_lines_once(
     >>> cut_lines_once(gdf, "dist")
                                                 geometry  dist
     0      LINESTRING (0.00000 0.00000, 0.70711 0.70711)     1
-    1  LINESTRING (0.70711 0.70711, 1.00000 1.00000, ...     1
-    2  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     2
-    3      LINESTRING (1.41421 1.41421, 2.00000 2.00000)     2
-    4  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     3
+    0  LINESTRING (0.70711 0.70711, 1.00000 1.00000, ...     1
+    0  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     2
+    0      LINESTRING (1.41421 1.41421, 2.00000 2.00000)     2
+    0  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     3
 
     Cut distance as list (same result as above).
 
     >>> cut_lines_once(gdf, [1, 2, 3])
                                                 geometry  dist
     0      LINESTRING (0.00000 0.00000, 0.70711 0.70711)     1
-    1  LINESTRING (0.70711 0.70711, 1.00000 1.00000, ...     1
-    2  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     2
-    3      LINESTRING (1.41421 1.41421, 2.00000 2.00000)     2
-    4  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     3
+    0  LINESTRING (0.70711 0.70711, 1.00000 1.00000, ...     1
+    0  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     2
+    0      LINESTRING (1.41421 1.41421, 2.00000 2.00000)     2
+    0  LINESTRING (0.00000 0.00000, 1.00000 1.00000, ...     3
     """
 
     def _cut(line: LineString, distance: int | float) -> list[LineString]:
-        """From the shapely docs"""
+        """From the shapely docs."""
         if distance <= 0.0 or distance >= line.length:
             return line
         coords = list(line.coords)

sgis/networkanalysis/directednetwork.py

@@ -1,12 +1,14 @@
 """Prepare a GeoDataFrame of line geometries for directed network analysis."""
 
 import warnings
+from collections.abc import Sequence
 
 import pandas as pd
 from geopandas import GeoDataFrame
 from shapely.constructive import reverse
 
-from ..helpers import return_two_vals, unit_is_meters
+from ..helpers import return_two_vals
+from ..helpers import unit_is_meters
 
 
 def make_directed_network_norway(gdf: GeoDataFrame, dropnegative: bool) -> GeoDataFrame:
@@ -26,8 +28,8 @@ def make_directed_network_norway(gdf: GeoDataFrame, dropnegative: bool) -> GeoDa
             network graph. Recode these rows to a non-negative values if you want
             to keep them.
 
-    Examples
-    --------
+    Examples:
+    ---------
     2022 data for the municipalities of Oslo and Eidskog can be read directly like this:
 
     >>> import sgis as sg
@@ -47,11 +49,12 @@ def make_directed_network_norway(gdf: GeoDataFrame, dropnegative: bool) -> GeoDa
     1944398      B      0.068239      0.068239  MULTILINESTRING Z ((258292.600 6648313.440 18....
     1944409      B      0.023629      0.023629  MULTILINESTRING Z ((258291.452 6648289.258 19....
     1944415      B      0.175876      0.175876  MULTILINESTRING Z ((260762.830 6650240.620 43....
-    [93395 rows x 46 columns]
+    <BLANKLINE>
+    [93395 rows x 4 columns]
 
     And converted to a directed network like this:
 
-    >>> roads_directed = sg.make_directed_network_norway(roads)
+    >>> roads_directed = sg.make_directed_network_norway(roads, dropnegative=True)
     >>> roads_directed[["minutes", "geometry"]]
              minutes                                           geometry
     0       0.216611  MULTILINESTRING Z ((258028.440 6674249.890 413...
@@ -65,7 +68,8 @@ def make_directed_network_norway(gdf: GeoDataFrame, dropnegative: bool) -> GeoDa
     175622  0.036810  MULTILINESTRING Z ((268681.757 6651886.457 110...
     175623  0.003019  MULTILINESTRING Z ((268682.748 6651886.162 110...
     175624  0.036975  MULTILINESTRING Z ((268694.594 6651881.688 111...
-    [175541 rows x 45 columns]
+    <BLANKLINE>
+    [175541 rows x 2 columns]
     """
     if gdf["drivetime_fw"].isna().any():
         raise ValueError("Missing values in the columns 'drivetime_fw'")
@@ -202,7 +206,9 @@ def make_directed_network(
     return gdf
 
 
-def _validate_minute_args(minute_cols, speed_col_kmh, flat_speed_kmh):
+def _validate_minute_args(
+    minute_cols: Sequence[str], speed_col_kmh: str, flat_speed_kmh: str
+) -> None:
     if not minute_cols and not speed_col_kmh and not flat_speed_kmh:
         warnings.warn(
             "Minute column will not be calculated when both 'minute_cols', "
@@ -217,7 +223,9 @@ def _validate_minute_args(minute_cols, speed_col_kmh, flat_speed_kmh):
         )
 
 
-def _validate_direction_args(gdf, direction_col, direction_vals_bft):
+def _validate_direction_args(
+    gdf: GeoDataFrame, direction_col: str, direction_vals_bft: Sequence[str]
+) -> None:
     if len(direction_vals_bft) != 3:
         raise ValueError(
             "'direction_vals_bft' should be tuple/list with values of directions "

sgis/networkanalysis/finding_isolated_networks.py

@@ -22,8 +22,8 @@ def get_connected_components(gdf: GeoDataFrame) -> GeoDataFrame:
     Returns:
         The GeoDataFrame with a new column "connected".
 
-    Examples
-    --------
+    Examples:
+    ---------
     >>> from sgis import read_parquet_url, get_connected_components
     >>> roads = read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet")
 
@@ -75,19 +75,20 @@ def get_component_size(gdf: GeoDataFrame) -> GeoDataFrame:
     Returns:
         A GeoDataFrame with a new column "component_size".
 
-    Examples
-    --------
+    Examples:
+    ---------
     >>> from sgis import read_parquet_url, get_component_size
     >>> roads = read_parquet_url("https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet")
 
     >>> roads = get_component_size(roads)
     >>> roads.component_size.value_counts().head()
+    component_size
     79180    85638
     2         1601
     4          688
     6          406
     3          346
-    Name: component_size, dtype: int64
+    Name: count, dtype: int64
     """
     gdf, _ = make_node_ids(gdf)