ssb-sgis 0.1.5__tar.gz → 0.1.6__tar.gz

{ssb_sgis-0.1.5 → ssb_sgis-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ssb-sgis
-Version: 0.1.5
+Version: 0.1.6
 Summary: GIS functions used at Statistics Norway.
 Home-page: https://github.com/statisticsnorway/ssb-sgis
 License: MIT
@@ -68,7 +68,7 @@ Preparing for network analysis:
 
 ```python
 import sgis as sg
-
+import pandas as pd
 
 roads = sg.read_parquet_url(
     "https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet"
@@ -97,14 +97,23 @@ nwa
         log=True, detailed_log=True,
     )
 
-Get number of times each line segment was visited.
+Get number of times each line segment was visited, with optional weighting.
 
 ```python
-frequencies = nwa.get_route_frequencies(points.sample(75), points.sample(75))
+origins = points.iloc[:75]
+destinations = points.iloc[75:150]
+
+# creating uniform weights of 10
+od_pairs = pd.MultiIndex.from_product([origins.index, destinations.index])
+weights = pd.DataFrame(index=od_pairs)
+weights["weight"] = 10
 
+frequencies = nwa.get_route_frequencies(origins, destinations, weight_df=weights)
+
+# plot the results
 m = sg.ThematicMap(sg.buff(frequencies, 15), column="frequency", black=True)
 m.cmap = "plasma"
-m.title = "Number of times each road was used."
+m.title = "Number of times each road was used,\nweighted * 10"
 m.plot()
 ```
 
@@ -141,6 +150,7 @@ service_areas = nwa.service_area(
     breaks=np.arange(1, 11),
 )
 
+# plot the results
 m = sg.ThematicMap(service_areas, column="minutes", black=True, size=10)
 m.k = 10
 m.title = "Roads that can be reached within 1 to 10 minutes"
@@ -164,8 +174,6 @@ m.plot()
 
 ![png](docs/examples/network_analysis_examples_files/network_analysis_examples_11_0.png)
 
-More network analysis examples can be found here: https://github.com/statisticsnorway/ssb-sgis/blob/main/docs/network_analysis_demo_template.md
-
 Road data for Norway can be downloaded here: https://kartkatalog.geonorge.no/metadata/nvdb-ruteplan-nettverksdatasett/8d0f9066-34f9-4423-be12-8e8523089313
 
 ## Developer information

{ssb_sgis-0.1.5 → ssb_sgis-0.1.6}/README.md

@@ -34,7 +34,7 @@ Preparing for network analysis:
 
 ```python
 import sgis as sg
-
+import pandas as pd
 
 roads = sg.read_parquet_url(
     "https://media.githubusercontent.com/media/statisticsnorway/ssb-sgis/main/tests/testdata/roads_oslo_2022.parquet"
@@ -63,14 +63,23 @@ nwa
         log=True, detailed_log=True,
     )
 
-Get number of times each line segment was visited.
+Get number of times each line segment was visited, with optional weighting.
 
 ```python
-frequencies = nwa.get_route_frequencies(points.sample(75), points.sample(75))
+origins = points.iloc[:75]
+destinations = points.iloc[75:150]
+
+# creating uniform weights of 10
+od_pairs = pd.MultiIndex.from_product([origins.index, destinations.index])
+weights = pd.DataFrame(index=od_pairs)
+weights["weight"] = 10
 
+frequencies = nwa.get_route_frequencies(origins, destinations, weight_df=weights)
+
+# plot the results
 m = sg.ThematicMap(sg.buff(frequencies, 15), column="frequency", black=True)
 m.cmap = "plasma"
-m.title = "Number of times each road was used."
+m.title = "Number of times each road was used,\nweighted * 10"
 m.plot()
 ```
 
@@ -107,6 +116,7 @@ service_areas = nwa.service_area(
     breaks=np.arange(1, 11),
 )
 
+# plot the results
 m = sg.ThematicMap(service_areas, column="minutes", black=True, size=10)
 m.k = 10
 m.title = "Roads that can be reached within 1 to 10 minutes"
@@ -130,8 +140,6 @@ m.plot()
 
 ![png](docs/examples/network_analysis_examples_files/network_analysis_examples_11_0.png)
 
-More network analysis examples can be found here: https://github.com/statisticsnorway/ssb-sgis/blob/main/docs/network_analysis_demo_template.md
-
 Road data for Norway can be downloaded here: https://kartkatalog.geonorge.no/metadata/nvdb-ruteplan-nettverksdatasett/8d0f9066-34f9-4423-be12-8e8523089313
 
 ## Developer information

{ssb_sgis-0.1.5 → ssb_sgis-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ssb-sgis"
-version = "0.1.5"
+version = "0.1.6"
 description = "GIS functions used at Statistics Norway."
 authors = ["Statistics Norway <ort@ssb.no>"]
 license = "MIT"

{ssb_sgis-0.1.5 → ssb_sgis-0.1.6}/src/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):

{ssb_sgis-0.1.5 → ssb_sgis-0.1.6}/src/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)):

{ssb_sgis-0.1.5 → ssb_sgis-0.1.6}/src/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

{ssb_sgis-0.1.5 → ssb_sgis-0.1.6}/src/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()

{ssb_sgis-0.1.5 → ssb_sgis-0.1.6}/src/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,

{ssb_sgis-0.1.5 → ssb_sgis-0.1.6}/src/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.

{ssb_sgis-0.1.5 → ssb_sgis-0.1.6}/src/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,

ssb_sgis-0.1.6/src/sgis/networkanalysis/_get_route.py

@@ -0,0 +1,244 @@
+import warnings
+
+import numpy as np
+import pandas as pd
+from geopandas import GeoDataFrame
+from igraph import Graph
+from pandas import DataFrame
+
+
+def _get_route(
+    graph: Graph,
+    origins: GeoDataFrame,
+    destinations: GeoDataFrame,
+    weight: str,
+    roads: GeoDataFrame,
+    rowwise: bool = False,
+) -> GeoDataFrame:
+    """Function used in the get_route method of NetworkAnalysis."""
+
+    warnings.filterwarnings("ignore", category=RuntimeWarning)
+
+    od_pairs = _create_od_pairs(origins, destinations, rowwise)
+
+    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. Try larger search_tolerance or search_factor. "
+            "Or close_network_holes() or remove_isolated()."
+        )
+        return pd.DataFrame(columns=["origin", "destination", weight, "geometry"])
+
+    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)
+
+    return lines[["origin", "destination", weight, "geometry"]]
+
+
+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)
+
+    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)
+
+    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"])
+
+    results: DataFrame = pd.concat(resultlist)
+    assert list(results.columns) == ["origin", "destination", "k"], list(
+        results.columns
+    )
+    lines: GeoDataFrame = _get_line_geometries(results, roads, weight)
+
+    lines = lines.dissolve(
+        by=["origin", "destination", "k"], aggfunc="sum", as_index=False
+    )
+
+    return lines[["origin", "destination", weight, "k", "geometry"]]
+
+
+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 []
+
+    return graph.es[res[0]]
+
+
+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)
+
+
+def _create_line_id_df(source_target_weight: list, ori_id, des_id) -> DataFrame:
+    line_ids = DataFrame(index=source_target_weight)
+
+    # remove edges from ori/des to the roads
+    line_ids = line_ids.loc[~line_ids.index.str.endswith("_0")]
+
+    line_ids["origin"] = ori_id
+    line_ids["destination"] = des_id
+
+    return line_ids
+
+
+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 _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[DataFrame] = []
+
+    for i in range(k):
+        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)
+        line_ids["k"] = i + 1
+        lines.append(line_ids)
+
+        edge_tuples = indices["edge_tuples"]
+
+        n_edges_to_keep = (
+            len(edge_tuples) - len(edge_tuples) * drop_middle_percent / 100
+        ) / 2
+
+        n_edges_to_keep = int(round(n_edges_to_keep, 0))
+
+        if n_edges_to_keep == 0:
+            n_edges_to_keep = 1
+
+        to_be_dropped = edge_tuples[n_edges_to_keep:-n_edges_to_keep]
+        graph.delete_edges(to_be_dropped)
+
+    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