Merge pull request #300 from statisticsnorway/map-hatches

docs

Author: mortewle

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ssb-sgis"
-version = "1.2.13"
+version = "1.2.14"
 description = "GIS functions used at Statistics Norway."
 authors = ["Morten Letnes <morten.letnes@ssb.no>"]
 license = "MIT"

src/sgis/maps/legend.py

@@ -330,6 +330,8 @@ def _actually_add_legend(self, ax: matplotlib.axes.Axes) -> matplotlib.axes.Axes
             framealpha=self.framealpha,
             edgecolor=self.edgecolor,
             labelspacing=self.labelspacing,
+            facecolor=self.facecolor,
+            labelcolor=self.labelcolor,
             **self.kwargs,
         )
 
@@ -344,16 +346,22 @@ def _get_best_legend_position(
         minx, miny, maxx, maxy = gdf.total_bounds
         diffx = maxx - minx
         diffy = maxy - miny
-
+        if diffx > 10000 and diffy > 10000:
+            gridsize = (diffy + diffx) // 1000
+        if diffx > 1000 and diffy > 1000:
+            gridsize = (diffy + diffx) // 100
+        if diffx > 100 and diffy > 100:
+            gridsize = (diffy + diffx) // 10
+        else:
+            gridsize = 30
         points = pd.concat(
             [
-                points_in_bounds(gdf, 30),
+                points_in_bounds(gdf, gridsize),
                 bounds_to_points(gdf)
                 .geometry.explode(ignore_index=True)
                 .to_frame("geometry"),
             ]
         )
-
         gdf = gdf.loc[:, ~gdf.columns.str.contains("index|level_")]
         joined = points.sjoin_nearest(gdf, distance_col="nearest")
 

src/sgis/maps/thematicmap.py

@@ -253,18 +253,13 @@ def __init__(
         self._dark = self._dark or black
 
         if not self.cmap and not self._is_categorical:
-            self._choose_cmap()
+            self._choose_cmap(**kwargs)
 
         if not legend:
             self.legend = None
         else:
             self._create_legend()
 
-        self._dark_or_light()
-
-        if cmap:
-            self._cmap = cmap
-
         new_kwargs = {}
         for key, value in self.kwargs.items():
             if key not in MAP_KWARGS:
@@ -286,6 +281,11 @@ def __init__(
                 except Exception:
                     setattr(self.legend, f"_{key}", value)
 
+        self._dark_or_light()
+
+        if cmap:
+            self._cmap = cmap
+
         self.bounds = (
             to_bbox(bounds) if bounds is not None else to_bbox(self._gdf.total_bounds)
         )
@@ -589,16 +589,16 @@ def _create_legend(self) -> None:
         else:
             self.legend = ContinousLegend(title=self._column, size=self._size)
 
-    def _choose_cmap(self) -> None:
+    def _choose_cmap(self, **kwargs) -> None:
         """Kwargs is to catch start and stop points for the cmap in __init__."""
         if self._dark:
             self._cmap = "viridis"
-            self.cmap_start = 0
-            self.cmap_stop = 256
+            self.cmap_start = self.kwargs.pop("cmap_start", 0)
+            self.cmap_stop = self.kwargs.pop("cmap_stop", 256)
         else:
             self._cmap = "RdPu"
-            self.cmap_start = 23
-            self.cmap_stop = 256
+            self.cmap_start = self.kwargs.pop("cmap_start", 23)
+            self.cmap_stop = self.kwargs.pop("cmap_stop", 256)
 
     def _make_bin_value_dict(self, gdf: GeoDataFrame, classified: np.ndarray) -> dict:
         """Dict with unique values of all bins. Used in labels in ContinousLegend."""
@@ -609,8 +609,6 @@ def _make_bin_value_dict(self, gdf: GeoDataFrame, classified: np.ndarray) -> dic
         return bins_unique_values
 
     def _actually_add_background(self) -> None:
-        # self.ax.set_xlim([self.minx - self.diffx * 0.03, self.maxx + self.diffx * 0.03])
-        # self.ax.set_ylim([self.miny - self.diffy * 0.03, self.maxy + self.diffy * 0.03])
         self._background_gdfs.plot(
             ax=self.ax, color=self.bg_gdf_color, **self.bg_gdf_kwargs
         )
@@ -632,13 +630,14 @@ def _dark_or_light(self) -> None:
             )
             self.nan_color = "#666666" if self._nan_color_was_none else self.nan_color
             if not self._is_categorical:
-                self.change_cmap("viridis")
+                self._cmap = self.kwargs.get("cmap", "viridis")
 
             if self.legend is not None:
                 for key, color in {
                     "facecolor": "#0f0f0f",
                     "labelcolor": "#fefefe",
                     "title_color": "#fefefe",
+                    "edgecolor": "#0f0f0f",
                 }.items():
                     setattr(self.legend, key, color)
 
@@ -650,13 +649,14 @@ def _dark_or_light(self) -> None:
             )
             self.nan_color = "#c2c2c2" if self._nan_color_was_none else self.nan_color
             if not self._is_categorical:
-                self.change_cmap("RdPu", start=23)
+                self._cmap = self.kwargs.get("cmap", "RdPu")
 
             if self.legend is not None:
                 for key, color in {
                     "facecolor": "#fefefe",
                     "labelcolor": "#0f0f0f",
                     "title_color": "#0f0f0f",
+                    "edgecolor": "#0f0f0f",
                 }.items():
                     setattr(self.legend, key, color)
 

src/sgis/networkanalysis/_get_route.py

@@ -2,6 +2,7 @@
 
 import joblib
 import pandas as pd
+import shapely
 from geopandas import GeoDataFrame
 from igraph import Graph
 from pandas import DataFrame
@@ -116,8 +117,8 @@ def _get_route(
     results: DataFrame = pd.concat(resultlist)
     assert list(results.columns) == ["origin", "destination"], list(results.columns)
     lines: GeoDataFrame = _get_line_geometries(results, roads, weight)
+    lines.geometry = shapely.force_2d(lines.geometry)
     lines = lines.dissolve(by=["origin", "destination"], aggfunc="sum", as_index=False)
-
     return lines[["origin", "destination", weight, "geometry"]]
 
 

src/sgis/networkanalysis/_service_area.py

@@ -129,10 +129,12 @@ def _service_area(
 
             service_areas.append(edges_within)
 
-    return pd.concat(
+    service_areas = pd.concat(
         service_areas,
         ignore_index=True,
     )
+    service_areas.geometry = force_2d(service_areas.geometry)
+    return service_areas
 
 
 def _part_of_edge_within(distance_df, nodes_within_break, directed):

src/sgis/networkanalysis/networkanalysis.py

@@ -17,6 +17,7 @@
 from igraph import Graph
 from pandas import DataFrame
 from pandas import MultiIndex
+from shapely import force_2d
 
 from ..geopandas_tools.general import _push_geom_col
 from ._get_route import _get_k_routes
@@ -34,9 +35,20 @@
 class NetworkAnalysis:
     """Class for doing network analysis.
 
-    The class takes a GeoDataFrame of line geometries and rules for the analyses,
-    and holds methods for doing network analysis based on GeoDataFrames of origin
-    and destination points.
+    Args:
+        network: A GeoDataFrame of line geometries.
+        rules: The rules for the analysis, either as an instance of
+            NetworkAnalysisRules or a dictionary with the parameters
+            as keys.
+        log: If True (default), a DataFrame with information about each
+            analysis run will be stored in the 'log' attribute.
+        detailed_log: If True, the log DataFrame will include columns for
+            all arguments passed to the analysis method, plus standard deviation and
+            percentiles (25th, 50th, 75th) of the weight column in the results.
+            Defaults to False.
+
+    The class implements methods for doing network analysis based on
+    GeoDataFrames of origin and destination points.
 
     The 'od_cost_matrix' method is the fastest, and returns a DataFrame with only
     indices and travel costs between each origin-destination pair.
@@ -96,21 +108,7 @@ def __init__(
         log: bool = True,
         detailed_log: bool = False,
     ) -> None:
-        """Initialise NetworkAnalysis instance.
-
-        Args:
-            network: A GeoDataFrame of line geometries.
-            rules: The rules for the analysis, either as an instance of
-                NetworkAnalysisRules or a dictionary with the parameters
-                as keys.
-            log: If True (default), a DataFrame with information about each
-                analysis run will be stored in the 'log' attribute.
-            detailed_log: If True, the log DataFrame will include columns for
-                all arguments passed to the analysis method, plus standard deviation and
-                percentiles (25th, 50th, 75th) of the weight column in the results.
-                Defaults to False.
-
-        """
+        """Initialise NetworkAnalysis instance."""
         if not isinstance(rules, NetworkAnalysisRules):
             rules = NetworkAnalysisRules(**rules)
 
@@ -647,6 +645,8 @@ def multiindex_mapper(x: tuple[int, int]) -> tuple[int, int]:
             frequency_col
         )
 
+        results.geometry = force_2d(results.geometry)
+
         if self.rules.split_lines:
             self._unsplit_network()