ssb-sgis 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

sgis/geopandas_tools/general.py

@@ -368,8 +368,8 @@ def to_lines(*gdfs: GeoDataFrame, copy: bool = True) -> GeoDataFrame:
     >>> poly1["poly1"] = 1
     >>> line = sg.to_lines(poly1)
     >>> line
-        poly1                                           geometry
-    0      1  LINESTRING (0.00000 0.00000, 0.00000 1.00000, ...
+                                                geometry  poly1
+    0  LINESTRING (0.00000 0.00000, 0.00000 1.00000, ...      1
 
     Convert two overlapping polygons to linestrings.
 
@@ -385,13 +385,11 @@ def to_lines(*gdfs: GeoDataFrame, copy: bool = True) -> GeoDataFrame:
     4    NaN    1.0  LINESTRING (0.50000 1.00000, 0.50000 1.50000, ...
     5    NaN    1.0      LINESTRING (1.00000 0.50000, 0.50000 0.50000)
 
-    Plot before and after (plots not showing in terminal).
+    Plot before and after.
 
     >>> sg.qtm(poly1, poly2)
-    <Axes: >
     >>> lines["l"] = lines.length
     >>> sg.qtm(lines, "l")
-    <Axes: >
     """
 
     if any(any(gdf.geom_type.isin(["Point", "MultiPoint"])) for gdf in gdfs):

sgis/geopandas_tools/geometry_types.py

@@ -60,7 +60,7 @@ def to_single_geom_type(
     0  GEOMETRYCOLLECTION (POINT (0.00000 0.00000), L...
 
     >>> to_single_geom_type(gdf, "line")
-                    geometry
+                                            geometry
     2  LINESTRING (1.00000 1.00000, 2.00000 2.00000)
     """
     if not isinstance(gdf, (GeoDataFrame, GeoSeries)):

sgis/geopandas_tools/line_operations.py

@@ -698,7 +698,7 @@ def close_network_holes_to_deadends(
 
     Fill gaps shorter than 1.1 meters.
 
-    >>> filled = sg.close_network_holes_to_deadends(roads, max_distance=1.1, max_angle=30)
+    >>> filled = sg.close_network_holes_to_deadends(roads, max_distance=1.1)
     >>> roads = sg.get_largest_component(roads)
     >>> roads.connected.value_counts()
     1.0    100315

sgis/maps/explore.py

@@ -85,42 +85,6 @@ class Explore(Map):
             self.cmap_stop = kwargs.pop("cmap_stop", 256)
 
     def explore(self, column: str | None = None, **kwargs) -> None:
-        """Interactive map of the GeoDataFrames with layers that can be toggles on/off.
-
-        It displays all the GeoDataFrames and displays them together in an interactive
-        map with a common legend. The layers can be toggled on and off.
-
-        Args:
-            column: The column to color the geometries by. Defaults to the column
-                that was specified last.
-            **kwargs: Keyword arguments to pass to geopandas.GeoDataFrame.explore, for
-                instance 'cmap' to change the colors, 'scheme' to change how the data
-                is grouped. This defaults to 'fisherjenks' for numeric data.
-
-        See also:
-            samplemap: same functionality, but shows only a random area of a given size.
-            clipmap: same functionality, but shows only the areas clipped by a given
-            mask.
-
-        Examples
-        --------
-        >>> from sgis import read_parquet_url
-        >>> 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")
-
-        Simple explore of two GeoDataFrames.
-
-        >>> from sgis import Explore
-        >>> ex = Explore(roads, points)
-        >>> ex.explore()
-
-        With column.
-
-        >>> roads["meters"] = roads.length
-        >>> points["meters"] = points.length
-        >>> ex = Explore(roads, points, column="meters")
-        >>> ex.samplemap()
-        """
         if column:
             self._column = column
             self._update_column()
@@ -135,34 +99,6 @@ class Explore(Map):
         sample_from_first: bool = True,
         **kwargs,
     ) -> None:
-        """Shows an interactive map of a random area of the GeoDataFrames.
-
-        It takes a random sample point of the GeoDataFrames, and shows all geometries
-        within a given radius of this point. Displays an interactive map with a common
-        legend. The layers can be toggled on and off.
-
-        The radius to plot can be changed with the 'size' parameter.
-
-        For more info about the labeling and coloring of the map, see the explore
-        method.
-
-        Args:
-            size: the radius to buffer the sample point by before clipping with the
-                data.
-            column: The column to color the geometries by. Defaults to the column
-                that was specified last.
-            sample_from_first: If True (default), the sample point is taken from
-                the first specified GeoDataFrame. If False, all GeoDataFrames are
-                considered.
-            **kwargs: Keyword arguments to pass to geopandas.GeoDataFrame.explore, for
-                instance 'cmap' to change the colors, 'scheme' to change how the data
-                is grouped. This defaults to 'fisherjenks' for numeric data.
-
-        See also:
-            explore: same functionality, but shows the entire area of the geometries.
-            clipmap: same functionality, but shows only the areas clipped by a given
-            mask.
-        """
         if column:
             self._column = column
             self._update_column()
@@ -200,27 +136,6 @@ class Explore(Map):
         column: str | None = None,
         **kwargs,
     ) -> None:
-        """Shows an interactive map of a of the GeoDataFrames clipped by the mask.
-
-        It clips all the GeoDataFrames in the Explore instance to the mask extent,
-        and displays the resulting geometries in an interactive map with a common
-        legends. The layers can be toggled on and off.
-
-        For more info about the labeling and coloring of the map, see the explore
-        method.
-
-        Args:
-            mask: the geometry to clip the data by.
-            column: The column to color the geometries by. Defaults to the column
-                that was specified last.
-            **kwargs: Keyword arguments to pass to geopandas.GeoDataFrame.explore, for
-                instance 'cmap' to change the colors, 'scheme' to change how the data
-                is grouped. This defaults to 'fisherjenks' for numeric data.
-
-        See also:
-            explore: same functionality, but shows the entire area of the geometries.
-            samplemap: same functionality, but shows only a random area of a given size.
-        """
         if column:
             self._column = column
             self._update_column()

sgis/maps/legend.py

@@ -157,9 +157,7 @@ class Legend:
         else:
             self._markersize = size
 
-    def _actually_add_categorical_legend(
-        self, ax, categories_colors: dict, nan_label: str
-    ):
+    def _prepare_categorical_legend(self, categories_colors: dict, nan_label: str):
         for attr in self.__dict__.keys():
             if attr in self.kwargs:
                 self[attr] = self.kwargs.pop(attr)
@@ -196,6 +194,8 @@ class Legend:
                     markeredgewidth=0,
                 )
             )
+
+    def _actually_add_legend(self, ax):
         legend = ax.legend(
             self._patches,
             self._categories,
@@ -433,9 +433,8 @@ class ContinousLegend(Legend):
         if not self._legend:
             raise ValueError("Cannot modify legend before it is created.")
 
-    def _actually_add_continous_legend(
+    def _prepare_continous_legend(
         self,
-        ax,
         bins: list[float],
         colors: list[str],
         nan_label: str,
@@ -524,6 +523,7 @@ class ContinousLegend(Legend):
                     label = self._two_value_label(min_rounded, max_rounded)
                     self._categories.append(label)
 
+    def _actually_add_legend(self, ax):
         legend = ax.legend(
             self._patches,
             self._categories,

sgis/maps/maps.py

@@ -37,12 +37,16 @@ def explore(
     show_in_browser: bool = False,
     **kwargs,
 ) -> None:
-    """Interactive map of GeoDataFrames with layers that can be toggles on/off.
+    """Interactive map of GeoDataFrames with layers that can be toggled on/off.
 
     It takes all the given GeoDataFrames and displays them together in an
     interactive map with a common legend. If 'column' is not specified, each
     GeoDataFrame is given a unique color.
 
+    If the column is of type string and only one GeoDataFrame is given, the unique
+    values will be split into separate GeoDataFrames so that each value can be toggled
+    on/off.
+
     The coloring can be changed with the 'cmap' parameter. The default colormap is a
     custom, strongly colored palette. If a numerical colum is given, the 'viridis'
     palette is used.

sgis/maps/thematicmap.py

@@ -146,26 +146,56 @@ class ThematicMap(Map):
         This method should be run after customising the map, but before saving.
         """
 
+        __test = kwargs.pop("__test", False)
         include_legend = bool(kwargs.pop("legend", self.legend))
 
-        self._prepare_plot(**kwargs)
-
         if "color" in kwargs:
-            kwargs["column"] = self.column
+            kwargs.pop("column", None)
             self.legend = None
             include_legend = False
         elif hasattr(self, "color"):
-            kwargs["column"] = self.column
+            kwargs.pop("column", None)
             kwargs["color"] = self.color
             self.legend = None
             include_legend = False
+
         elif self._is_categorical:
             kwargs = self._prepare_categorical_plot(kwargs)
+            self.legend._prepare_categorical_legend(
+                categories_colors=self._categories_colors_dict,
+                nan_label=self.nan_label,
+            )
+
         else:
             kwargs = self._prepare_continous_plot(kwargs)
+            if self.legend:
+                if not self.legend._rounding_has_been_set:
+                    self.legend._rounding = self.legend._get_rounding(
+                        array=self._gdf.loc[~self._nan_idx, self._column]
+                    )
+
+                self.legend._prepare_continous_legend(
+                    bins=self.bins,
+                    colors=self._unique_colors,
+                    nan_label=self.nan_label,
+                    bin_values=self._bins_unique_values,
+                )
+
+        if self.legend and not self.legend._position_has_been_set:
+            self.legend._position = self.legend._get_best_legend_position(
+                self._gdf, k=self._k + bool(len(self._nan_idx))
+            )
+
+        if __test:
+            return
+
+        self._prepare_plot(**kwargs)
 
         if self.legend:
-            self._actually_add_legend()
+            self.ax = self.legend._actually_add_legend(ax=self.ax)
+
+        #        if self.legend:
+        #           self._actually_add_legend()
 
         self._gdf.plot(legend=include_legend, ax=self.ax, **kwargs)
 
@@ -257,11 +287,6 @@ class ThematicMap(Map):
                 self._gdf, k=self._k + bool(len(self._nan_idx))
             )
 
-        if not self._is_categorical and not self.legend._rounding_has_been_set:
-            self.legend._rounding = self.legend._get_rounding(
-                array=self._gdf.loc[~self._nan_idx, self._column]
-            )
-
         if self._is_categorical:
             self.ax = self.legend._actually_add_categorical_legend(
                 ax=self.ax,

sgis/networkanalysis/_get_route.py

@@ -1,15 +1,10 @@
 import warnings
 
+import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
 from igraph import Graph
-
-from .network import _edge_ids
-
-
-# run functions for get_route, get_k_routes and get_route_frequencies
-
-# TODO: clean up this mess. Make smaller base functions and three separated for route, frequency and k_routes
+from pandas import DataFrame
 
 
 def _get_route(
@@ -18,162 +13,199 @@ def _get_route(
     destinations: GeoDataFrame,
     weight: str,
     roads: GeoDataFrame,
-    summarise: bool = False,
     rowwise: bool = False,
-    k: int = 1,
-    drop_middle_percent: int = 0,
-):
-    """Super function used in the NetworkAnalysis class.
+) -> GeoDataFrame:
+    """Function used in the get_route method of NetworkAnalysis."""
 
-    Big, ugly super function that is used in the get_route, get_k_routes
-    and get_route_frequencies methods of the NetworkAnalysis class.
-    """
     warnings.filterwarnings("ignore", category=RuntimeWarning)
 
-    if k > 1:
-        route_func = _run_get_k_routes
-    else:
-        route_func = _run_get_route
+    od_pairs = _create_od_pairs(origins, destinations, rowwise)
 
-    resultlist: list[GeoDataFrame] = []
-    if rowwise:
-        for ori_id, des_id in zip(origins["temp_idx"], destinations["temp_idx"]):
-            resultlist = resultlist + route_func(
-                ori_id, des_id, graph, roads, summarise, weight, k, drop_middle_percent
-            )
-    else:
-        for ori_id in origins["temp_idx"]:
-            for des_id in destinations["temp_idx"]:
-                resultlist = resultlist + route_func(
-                    ori_id,
-                    des_id,
-                    graph,
-                    roads,
-                    summarise,
-                    weight,
-                    k,
-                    drop_middle_percent,
-                )
+    resultlist: list[DataFrame] = []
+
+    for ori_id, des_id in od_pairs:
+        indices = _get_one_route(graph, ori_id, des_id)
+
+        if not indices:
+            continue
+
+        line_ids = _create_line_id_df(indices["source_target_weight"], ori_id, des_id)
+
+        resultlist.append(line_ids)
 
     if not resultlist:
-        warnings.warn("No paths were found.")
+        warnings.warn(
+            "No paths were found. Try larger search_tolerance or search_factor. "
+            "Or close_network_holes() or remove_isolated()."
+        )
         return pd.DataFrame(columns=["origin", "destination", weight, "geometry"])
 
-    if summarise:
-        counted = (
-            pd.concat(resultlist, ignore_index=True)
-            .assign(n=1)
-            .groupby("source_target_weight")["n"]
-            .count()
-        )
+    results: DataFrame = pd.concat(resultlist)
+    assert list(results.columns) == ["origin", "destination"], list(results.columns)
+    lines: GeoDataFrame = _get_line_geometries(results, roads, weight)
+    lines = lines.dissolve(by=["origin", "destination"], aggfunc="sum", as_index=False)
 
-        roads["source_target_weight"] = _edge_ids(roads, weight)
+    return lines[["origin", "destination", weight, "geometry"]]
 
-        roads["n"] = roads["source_target_weight"].map(counted)
 
-        roads_visited = roads.loc[
-            roads.n.notna(), roads.columns.difference(["source_target_weight"])
-        ]
+def _get_k_routes(
+    graph: Graph,
+    origins: GeoDataFrame,
+    destinations: GeoDataFrame,
+    weight: str,
+    roads: GeoDataFrame,
+    k: int,
+    drop_middle_percent: int,
+    rowwise: bool,
+) -> GeoDataFrame:
+    """Function used in the get_k_routes method of NetworkAnalysis."""
+    warnings.filterwarnings("ignore", category=RuntimeWarning)
+    od_pairs = _create_od_pairs(origins, destinations, rowwise)
 
-        return roads_visited
+    resultlist: list[DataFrame] = []
+
+    for ori_id, des_id in od_pairs:
+        k_lines: DataFrame = _loop_k_routes(
+            graph, ori_id, des_id, k, drop_middle_percent
+        )
+        if k_lines is not None:
+            resultlist.append(k_lines)
 
-    try:
-        results = pd.concat(resultlist)
-    except Exception:
-        raise ValueError(
+    if not resultlist:
+        warnings.warn(
             "No paths were found. Try larger search_tolerance or search_factor. "
             "Or close_network_holes() or remove_isolated()."
         )
+        return pd.DataFrame(columns=["origin", "destination", weight, "geometry"])
 
-    cols = ["origin", "destination", weight, "geometry"]
-    if "k" in results.columns:
-        cols.append("k")
+    results: DataFrame = pd.concat(resultlist)
+    assert list(results.columns) == ["origin", "destination", "k"], list(
+        results.columns
+    )
+    lines: GeoDataFrame = _get_line_geometries(results, roads, weight)
 
-    results = results.loc[:, cols].reset_index(drop=True)
+    lines = lines.dissolve(
+        by=["origin", "destination", "k"], aggfunc="sum", as_index=False
+    )
 
-    return results
+    return lines[["origin", "destination", weight, "k", "geometry"]]
 
 
-def _run_get_route(
-    ori_id: str,
-    des_id: str,
-    graph: Graph,
-    roads: GeoDataFrame,
-    summarise: bool,
-    weight: str,
-    k: int,
-    drop_middle_percent: int,
-) -> list[GeoDataFrame] | tuple[GeoDataFrame, list[tuple] | None]:
+def _get_route_frequencies(
+    graph,
+    origins,
+    destinations,
+    rowwise,
+    roads,
+    weight_df: DataFrame | None = None,
+):
+    """Function used in the get_route_frequencies method of NetworkAnalysis."""
+    warnings.filterwarnings("ignore", category=RuntimeWarning)
+    od_pairs = _create_od_pairs(origins, destinations, rowwise)
+
+    if weight_df is not None and len(weight_df) != len(od_pairs):
+        error_message = _make_keyerror_message(rowwise, weight_df, origins)
+        raise ValueError(error_message)
+
+    resultlist: list[DataFrame] = []
+
+    for ori_id, des_id in od_pairs:
+        indices = _get_one_route(graph, ori_id, des_id)
+
+        if not indices:
+            continue
+
+        line_ids = DataFrame({"source_target_weight": indices["source_target_weight"]})
+        line_ids["origin"] = ori_id
+        line_ids["destination"] = des_id
+
+        if weight_df is not None:
+            try:
+                line_ids["multiplier"] = weight_df.loc[ori_id, des_id].iloc[0]
+            except KeyError as e:
+                error_message = _make_keyerror_message(rowwise, weight_df, origins)
+                raise KeyError(error_message) from e
+        else:
+            line_ids["multiplier"] = 1
+
+        resultlist.append(line_ids)
+
+    summarised = (
+        pd.concat(resultlist, ignore_index=True)
+        .groupby("source_target_weight")["multiplier"]
+        .sum()
+    )
+
+    roads["frequency"] = roads["source_target_weight"].map(summarised)
+
+    roads_visited = roads.loc[
+        roads.frequency.notna(), roads.columns.difference(["source_target_weight"])
+    ]
+
+    return roads_visited
+
+
+def _create_od_pairs(
+    origins: GeoDataFrame, destinations: GeoDataFrame, rowwise: bool
+) -> zip | pd.MultiIndex:
+    """Get all od combinaions if not rowwise."""
+    if rowwise:
+        return zip(origins.temp_idx, destinations.temp_idx)
+    else:
+        return pd.MultiIndex.from_product([origins.temp_idx, destinations.temp_idx])
+
+
+def _get_one_route(graph: Graph, ori_id: str, des_id: str):
+    """Get the edges for one route."""
     res = graph.get_shortest_paths(
         weights="weight", v=ori_id, to=des_id, output="epath"
     )
-
     if not res[0]:
         return []
 
-    source_target_weight = graph.es[res[0]]["source_target_weight"]
+    return graph.es[res[0]]
 
-    if summarise:
-        return [pd.DataFrame({"source_target_weight": source_target_weight})]
 
-    roads["source_target_weight"] = _edge_ids(roads, weight)
-    line = roads.loc[
-        roads["source_target_weight"].isin(source_target_weight),
-        ["geometry", weight, "source_target_weight"],
-    ]
+def _get_line_geometries(line_ids, roads, weight) -> GeoDataFrame:
+    road_mapper = roads.set_index(["source_target_weight"])[[weight, "geometry"]]
+    line_ids = line_ids.join(road_mapper)
+    return GeoDataFrame(line_ids, geometry="geometry", crs=roads.crs)
 
-    # if len(line) != len(source_target_weight) - 2:
-    #    raise ValueError("length mismatch", len(line), len(source_target_weight))
 
-    if not len(line):
-        return []
+def _create_line_id_df(source_target_weight: list, ori_id, des_id) -> DataFrame:
+    line_ids = DataFrame(index=source_target_weight)
 
-    weight_sum = line[weight].sum()
-    line = line.dissolve()
+    # remove edges from ori/des to the roads
+    line_ids = line_ids.loc[~line_ids.index.str.endswith("_0")]
 
-    line["origin"] = ori_id
-    line["destination"] = des_id
-    line[weight] = weight_sum
+    line_ids["origin"] = ori_id
+    line_ids["destination"] = des_id
 
-    if k == 1:
-        return [line]
-    else:
-        return [line], graph.es[res[0]]["edge_tuples"]
+    return line_ids
 
 
-def _run_get_k_routes(
-    ori_id: str,
-    des_id: str,
-    graph: Graph,
-    roads: GeoDataFrame,
-    summarise: bool,
-    weight: str,
-    k: int,
-    drop_middle_percent,
-) -> list[GeoDataFrame]:
+def _loop_k_routes(graph: Graph, ori_id, des_id, k, drop_middle_percent) -> DataFrame:
     """Workaround for igraph's get_k_shortest_paths.
 
     igraph's get_k_shorest_paths doesn't seem to work (gives just the same path k
-    times), so doing it manually. Run _run_get_route, then remove the edges in the
+    times), so doing it manually. Run _get_one_route, then remove the edges in the
     middle of the route, given with drop_middle_percent, repeat k times.
     """
     graph = graph.copy()
 
-    lines: list[GeoDataFrame] = []
+    lines: list[DataFrame] = []
 
     for i in range(k):
-        line = _run_get_route(
-            ori_id, des_id, graph, roads, summarise, weight, k, drop_middle_percent
-        )
+        indices = _get_one_route(graph, ori_id, des_id)
 
-        if not isinstance(line, tuple):
+        if not indices:
             continue
 
-        line, edge_tuples = line
-        line = line[0]
-        line["k"] = i + 1
+        line_ids = _create_line_id_df(indices["source_target_weight"], ori_id, des_id)
+        line_ids["k"] = i + 1
+        lines.append(line_ids)
 
-        lines.append(line)
+        edge_tuples = indices["edge_tuples"]
 
         n_edges_to_keep = (
             len(edge_tuples) - len(edge_tuples) * drop_middle_percent / 100
@@ -187,4 +219,26 @@ def _run_get_k_routes(
         to_be_dropped = edge_tuples[n_edges_to_keep:-n_edges_to_keep]
         graph.delete_edges(to_be_dropped)
 
-    return lines
+    if lines:
+        return pd.concat(lines)
+    else:
+        return pd.DataFrame()
+
+
+def _make_keyerror_message(rowwise, weight_df, origins) -> str:
+    """Add help info to error message if key in weight_df is missing.
+
+    If empty resultlist, assume all indices are wrong. Else, assume
+    """
+    error_message = (
+        "'weight_df' does not contain all indices of each OD pair combination. "
+    )
+    if not rowwise and len(weight_df) == len(origins):
+        error_message = error_message + (
+            "Did you mean to set rowwise to True? "
+            "If not, make sure weight_df contains all combinations of "
+            "origin-destination pairs. Either specified as a MultiIndex or as the "
+            "first two columns of 'weight_df'. So (0, 0), (0, 1), (1, 0), (1, 1) etc."
+        )
+
+    return error_message

sgis/networkanalysis/_od_cost_matrix.py

@@ -16,12 +16,7 @@ def _od_cost_matrix(
     lines: bool = False,
     rowwise: bool = False,
 ) -> DataFrame | GeoDataFrame:
-    if rowwise and len(origins) != len(destinations):
-        raise ValueError(
-            "'origins' and 'destinations' must have the same length when rowwise=True"
-        )
-
-    results = graph.distances(
+    distances: list[list[str]] = graph.distances(
         weights="weight",
         source=origins["temp_idx"],
         target=destinations["temp_idx"],
@@ -29,10 +24,10 @@ def _od_cost_matrix(
 
     ori_idx, des_idx, costs = [], [], []
     for i, f_idx in enumerate(origins["temp_idx"]):
-        for ii, t_idx in enumerate(destinations["temp_idx"]):
+        for j, t_idx in enumerate(destinations["temp_idx"]):
             ori_idx.append(f_idx)
             des_idx.append(t_idx)
-            costs.append(results[i][ii])
+            costs.append(distances[i][j])
 
     results = (
         pd.DataFrame(data={"origin": ori_idx, "destination": des_idx, weight: costs})
@@ -44,7 +39,10 @@ def _od_cost_matrix(
     # so filtering to rowwise afterwards instead
     if rowwise:
         rowwise_df = DataFrame(
-            {"origin": origins["temp_idx"], "destination": destinations["temp_idx"]}
+            {
+                "origin": origins["temp_idx"].reset_index(drop=True),
+                "destination": destinations["temp_idx"].reset_index(drop=True),
+            }
         )
         results = rowwise_df.merge(results, on=["origin", "destination"], how="left")