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

sgis/maps/map.py

@@ -119,53 +119,68 @@ class Map:
                 list(self._gdf.loc[~self._nan_idx, self._column].unique())
             )
 
-    def _get_unique_floats(self) -> list[int | float]:
-        """Converting floats to large integers, then getting unique values.
+    def _get_unique_floats(self) -> np.array:
+        """Get unique floats by multiplying, then converting to integer.
 
-        Also making a column of the large integers to use in the bin classifying later.
+        Find a multiplier that makes the max value greater than +- 1_000_000.
+        Because floats don't always equal each other. This will make very
+        similar values count as the same value in the color classification.
         """
         array = self._gdf.loc[~self._nan_idx, self._column]
 
-        self._gdf["col_as_int"] = self._array_to_large_int(array)
+        self._min = np.min(array)
+        self._max = np.max(array)
+        self._get_multiplier(array)
 
         unique = array.reset_index(drop=True).drop_duplicates()
-
         as_int = self._array_to_large_int(unique)
         no_duplicates = as_int.drop_duplicates()
-        return list(sorted(unique.loc[no_duplicates.index]))
 
-    @staticmethod
-    def _array_to_large_int(array: np.ndarray):
+        return np.sort(np.array(unique.loc[no_duplicates.index]))
+
+    def _array_to_large_int(self, array: np.ndarray):
         """Multiply values in float array, then convert to integer."""
-        max_ = np.max(array)
-        min_ = np.min(array)
 
-        if max_ > 1 or min_ < -1:
-            unique_multiplied = array * np.emath.logn(1.25, np.abs(np.mean(array)) + 1)
-        else:
-            unique_multiplied = array
-            while max_ < 1_000_000:
-                unique_multiplied = unique_multiplied * 10
-                max_ = np.max(unique_multiplied)
+        unique_multiplied = array * self._multiplier
 
         return unique_multiplied.astype(np.int64)
 
+    def _get_multiplier(self, array: np.ndarray):
+        """Find the number of zeros needed to push the max value of the array above
+        +-1_000_000.
+
+        Adding this as an attribute to use later in _classify_from_bins.
+        """
+        multiplier = 10
+        max_ = np.max(array * multiplier)
+
+        if self._max > 0:
+            while max_ < 1_000_000:
+                multiplier *= 10
+                max_ = np.max(array * multiplier)
+        else:
+            while max_ > -1_000_000:
+                multiplier *= 10
+                max_ = np.max(array * multiplier)
+
+        self._multiplier: int = multiplier
+
     def _add_minmax_to_bins(self, bins: list[float | int]) -> list[float | int]:
         """If values are outside the bin range, add max and/or min values of array."""
         # make sure they are lists
         bins = [bin for bin in bins]
 
-        if min(bins) > 0 and min(self._gdf[self._column]) < min(bins) * 0.999:
-            bins = [min(self._gdf[self._column]) * 0.9999] + bins
+        if min(bins) > 0 and min(self._gdf[self._column]) < min(bins):
+            bins = [min(self._gdf[self._column])] + bins
 
-        if min(bins) < 0 and min(self._gdf[self._column]) < min(bins) * 1.0001:
-            bins = [min(self._gdf[self._column]) * 1.0001] + bins
+        if min(bins) < 0 and min(self._gdf[self._column]) < min(bins):
+            bins = [min(self._gdf[self._column])] + bins
 
-        if max(bins) > 0 and max(self._gdf[self._column]) > max(bins) * 1.0001:
-            bins = bins + [max(self._gdf[self._column]) * 1.0001]
+        if max(bins) > 0 and max(self._gdf[self._column]) > max(bins):
+            bins = bins + [max(self._gdf[self._column])]
 
-        if max(bins) < 0 and max(self._gdf[self._column]) < max(bins) * 1.0001:
-            bins = bins + [max(self._gdf[self._column]) * 1.0001]
+        if max(bins) < 0 and max(self._gdf[self._column]) < max(bins):
+            bins = bins + [max(self._gdf[self._column])]
 
         return bins
 
@@ -194,7 +209,7 @@ class Map:
         """Create bins if not already done and adjust k if needed."""
 
         if not hasattr(self, "scheme"):
-            self.scheme = self.kwargs.get("scheme", "fisherjenks")
+            self.scheme = self.kwargs.pop("scheme", "fisherjenks")
 
         if self.scheme is None:
             return
@@ -204,7 +219,6 @@ class Map:
             if len(self.bins) <= self._k and len(self.bins) != len(self._unique_values):
                 warnings.warn(f"Could not create {self._k} classes.")
                 self._k = len(self.bins)
-            self.bins = self._add_minmax_to_bins(self.bins)
         else:
             self.bins = self._add_minmax_to_bins(self.bins)
             if len(self._unique_values) > len(self.bins):
@@ -285,10 +299,10 @@ class Map:
             return False
 
         if all_nan == len(self._gdfs):
-            raise ValueError(f"All values are NaN in column {self.kwargs['column']!r}.")
+            raise ValueError(f"All values are NaN in column {self.column!r}.")
 
         if col_not_present == len(self._gdfs):
-            raise ValueError(f"{self.kwargs['column']} not found.")
+            raise ValueError(f"{self.column} not found.")
 
         return False
 
@@ -323,7 +337,7 @@ class Map:
 
         self._gdf["color"] = self._gdf[self._column].map(self._categories_colors_dict)
 
-    def _create_bins(self, gdf, column) -> np.ndarray:
+    def _create_bins(self, gdf: GeoDataFrame, column: str) -> np.ndarray:
         """Make bin list of length k + 1, or length of unique values.
 
         The returned bins sometimes have two almost identical
@@ -332,14 +346,6 @@ class Map:
         much faster than the one from Mapclassifier.
         """
 
-        if hasattr(self, "scheme"):
-            scheme = self.scheme
-        else:
-            scheme = self.kwargs.get("scheme", "fisherjenks")
-
-        if scheme is None:
-            return
-
         n_classes = (
             self._k if len(self._unique_values) > self._k else len(self._unique_values)
         )
@@ -347,12 +353,12 @@ class Map:
         if self._k == len(self._unique_values) - 1:
             n_classes = self._k - 1
 
-        if scheme == "fisherjenks":
+        if self.scheme == "fisherjenks":
             bins = jenks_breaks(gdf.loc[~self._nan_idx, column], n_classes=n_classes)
         else:
             binning = classify(
                 np.asarray(gdf.loc[~self._nan_idx, column]),
-                scheme=scheme,
+                scheme=self.scheme,
                 k=self._k,
             )
             bins = binning.bins
@@ -367,13 +373,7 @@ class Map:
         if len(unique_bins) == len(self._unique_values):
             return np.array(unique_bins)
 
-        binarray = np.array(bins)
-        binarray = np.where(
-            binarray > 0,
-            binarray + binarray / 100_000,
-            binarray - binarray / 100_000,
-        )
-        return binarray
+        return np.array(bins)
 
     def change_cmap(self, cmap: str, start: int = 0, stop: int = 256):
         """Change the color palette of the plot.
@@ -391,47 +391,42 @@ class Map:
         self._cmap_has_been_set = True
         return self
 
-    def _get_continous_colors(self) -> list[str]:
+    def _get_continous_colors(self, n: int) -> np.ndarray:
         cmap = matplotlib.colormaps.get_cmap(self._cmap)
         colors_ = [
             colors.to_hex(cmap(int(i)))
-            for i in np.linspace(self.cmap_start, self.cmap_stop, num=self._k)
+            #            for i in np.linspace(self.cmap_start, self.cmap_stop, num=self._k)
+            for i in np.linspace(self.cmap_start, self.cmap_stop, num=n)
         ]
         if any(self._nan_idx):
             colors_ = colors_ + [self.nan_color]
-        return colors_
-
-    def _classify_from_bins(self, gdf: GeoDataFrame) -> np.ndarray:
-        """Place the values of the column into groups."""
-        # if equal lenght, use integer column to check for equality
-        # since long floats are unpredictable
-        if len(self.bins) == len(self._unique_values):
-            if "col_as_int" not in gdf.columns:
-                gdf["col_as_int"] = self._array_to_large_int(gdf[self._column])
-            bins = np.array(sorted(gdf["col_as_int"].unique()))
+        return np.array(colors_)
+
+    def _classify_from_bins(self, gdf: GeoDataFrame, bins: np.ndarray) -> np.ndarray:
+        """Place the column values into groups."""
+        if len(bins) == len(self._unique_values):
+            # if equal lenght, convert to integer and check for equality
+            gdf["col_as_int"] = self._array_to_large_int(gdf[self._column])
+            bins = self._array_to_large_int(self._unique_values)
             classified = np.searchsorted(bins, gdf["col_as_int"])
         else:
-            if any(self._nan_idx) and len(self.bins) == len(self.colorlist):
-                bins = self.bins[1:]
-            elif not any(self._nan_idx) and len(self.bins) == len(self.colorlist) + 1:
-                bins = self.bins[1:]
-            else:
-                bins = self.bins
+            if len(bins) == self._k + 1:
+                bins = bins[1:]
 
             classified = np.searchsorted(bins, gdf[self._column])
 
-        # storing unique values to use in legend labels
-        self._bins_unique_values = {
-            i: list(set(gdf.loc[classified == i, self._column]))
-            for i, _ in enumerate(bins)
-        }
+        return classified
 
-        colors_ = np.array(self.colorlist)
+    def _push_classification(self, classified: np.ndarray) -> np.ndarray:
+        """Push classes downwards if gaps in classification sequence.
 
-        # nans are sorted to the end, so nans will get NAN_COLOR
-        colors_classified = colors_[classified]
+        So from e.g. [0,2,4] to [0,1,2].
+
+        Otherwise, will get index error when classifying colors.
+        """
+        rank_dict = {val: rank for rank, val in enumerate(np.unique(classified))}
 
-        return colors_classified
+        return np.array([rank_dict[val] for val in classified])
 
     @property
     def k(self):

sgis/maps/maps.py

@@ -7,8 +7,6 @@ interactive map with layers that can be toggled on and off. The 'samplemap' and
 The 'qtm' function shows a static map of one or more GeoDataFrames.
 """
 from geopandas import GeoDataFrame, GeoSeries
-from matplotlib.axes._axes import Axes
-from matplotlib.figure import Figure
 from shapely import Geometry
 
 from ..exceptions import NotInJupyterError
@@ -39,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.
@@ -299,6 +301,7 @@ def qtm(
     legend: bool = True,
     cmap: str | None = None,
     k: int = 5,
+    **kwargs,
 ) -> None:
     """Quick, thematic map of one or more GeoDataFrames.
 
@@ -320,6 +323,7 @@ def qtm(
         cmap: Color palette of the map. See:
             https://matplotlib.org/stable/tutorials/colors/colormaps.html
         k: Number of color groups.
+        **kwargs: Additional keyword arguments taken by the geopandas plot method.
 
     See also:
         ThematicMap: Class with more options for customising the plot.
@@ -329,7 +333,7 @@ def qtm(
 
     m.title = title
 
-    if k and len(m._unique_values) >= 6:
+    if k and len(m._unique_values) >= k:
         m.k = k
 
     if cmap:
@@ -338,4 +342,4 @@ def qtm(
     if not legend:
         m.legend = None
 
-    m.plot()
+    m.plot(**kwargs)

sgis/maps/thematicmap.py

@@ -3,10 +3,11 @@ import warnings
 
 import matplotlib
 import matplotlib.pyplot as plt
+import numpy as np
 import pandas as pd
 from geopandas import GeoDataFrame
 
-from .legend import Legend
+from .legend import ContinousLegend, Legend
 from .map import Map
 
 
@@ -103,7 +104,7 @@ class ThematicMap(Map):
         if not self._is_categorical:
             self._choose_cmap()
 
-        self._add_legend()
+        self._create_legend()
 
     def change_cmap(self, cmap: str, start: int = 0, stop: int = 256):
         """Change the color palette of the plot.
@@ -139,12 +140,90 @@ class ThematicMap(Map):
         self.diffy = self.maxy - self.miny
         return self
 
-    def plot(self) -> None:
+    def plot(self, **kwargs) -> None:
         """Creates the final plot.
 
         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))
+
+        if "color" in kwargs:
+            kwargs.pop("column", None)
+            self.legend = None
+            include_legend = False
+        elif hasattr(self, "color"):
+            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.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)
+
+    def save(self, path: str) -> None:
+        """Save figure as image file.
+
+        To be run after the plot method.
+
+        Args:
+            path: File path.
+        """
+        try:
+            plt.savefig(path)
+        except FileNotFoundError:
+            from dapla import FileClient
+
+            fs = FileClient.get_gcs_file_system()
+            with fs.open(path, "wb") as file:
+                plt.savefig(file)
+
+    def _prepare_plot(self, **kwargs):
+        """Add figure and axis, title and background gdf."""
+        for attr in self.__dict__.keys():
+            if attr in self.kwargs:
+                self[attr] = self.kwargs.pop(attr)
+            if attr in kwargs:
+                self[attr] = kwargs.pop(attr)
+
         self.fig, self.ax = self._get_matplotlib_figure_and_axix(
             figsize=(self._size, self._size)
         )
@@ -159,85 +238,82 @@ class ThematicMap(Map):
                 self.title, fontsize=self.title_fontsize, color=self.title_color
             )
 
-        if not self._is_categorical:
-            self._prepare_continous_map()
-            if self.scheme:
-                self.colorlist = self._get_continous_colors()
-                self.colors = self._classify_from_bins(self._gdf)
+    def _prepare_continous_plot(self, kwargs) -> dict:
+        """Create bins and colors."""
+        self._prepare_continous_map()
+
+        if self.scheme is None:
+            self.legend = None
+            kwargs["column"] = self.column
+            return kwargs
+
+        elif self.bins is None:
+            kwargs["column"] = self.column
+            return kwargs
+
         else:
-            self._get_categorical_colors()
-            self.colors = self._gdf["color"]
+            classified = self._classify_from_bins(self._gdf, bins=self.bins)
+            classified_sequential = self._push_classification(classified)
+            n_colors = len(np.unique(classified_sequential)) - any(self._nan_idx)
+            self._unique_colors = self._get_continous_colors(n=n_colors)
+            self._bins_unique_values = self._make_bin_value_dict(
+                self._gdf, classified_sequential
+            )
+            colorarray = self._unique_colors[classified_sequential]
+            kwargs["color"] = colorarray
 
-        if self.legend:
-            if 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 self.legend and not self.legend._rounding_has_been_set:
+            self.bins = self.legend._set_rounding(
+                bins=self.bins, rounding=self.legend._rounding
+            )
 
-            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 any(self._nan_idx):
+                self.bins = self.bins + [self.nan_label]
 
-        if not self.legend:
-            self._include_legend = False
-        elif self._is_categorical:
+        return kwargs
+
+    def _prepare_categorical_plot(self, kwargs) -> dict:
+        """Map values to colors."""
+        self._get_categorical_colors()
+        colorarray = self._gdf["color"]
+
+        kwargs["color"] = colorarray
+        return kwargs
+
+    def _actually_add_legend(self) -> None:
+        """Add legend to the axis and fill it with colors and labels."""
+        if 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 self._is_categorical:
             self.ax = self.legend._actually_add_categorical_legend(
                 ax=self.ax,
                 categories_colors=self._categories_colors_dict,
                 nan_label=self.nan_label,
             )
-            self._include_legend = True
-        elif self.scheme is None:
-            self._include_legend = True
         else:
-            self._include_legend = True
-            if not self.legend._rounding_has_been_set:
-                self.bins = self.legend._set_rounding(
-                    bins=self.bins, rounding=self.legend._rounding
-                )
-
-            if any(self._nan_idx):
-                self.bins = self.bins + [self.nan_label]
-
             self.ax = self.legend._actually_add_continous_legend(
                 ax=self.ax,
                 bins=self.bins,
-                colors=self.colorlist,
+                colors=self._unique_colors,
                 nan_label=self.nan_label,
                 bin_values=self._bins_unique_values,
             )
 
-        if self.bins or self._is_categorical:
-            self._gdf.plot(color=self.colors, legend=self._include_legend, ax=self.ax)
-        else:
-            self._gdf.plot(column=self.column, legend=self._include_legend, ax=self.ax)
-
-    def save(self, path: str) -> None:
-        """Save figure as image file.
-
-        To be run after the plot method.
-
-        Args:
-            path: File path.
-        """
-        try:
-            plt.savefig(path)
-        except FileNotFoundError:
-            from dapla import FileClient
-
-            fs = FileClient.get_gcs_file_system()
-            with fs.open(path, "wb") as file:
-                plt.savefig(file)
-
-    def _add_legend(self):
+    def _create_legend(self):
+        """Instantiate the Legend class."""
         kwargs = {}
         if self._black:
             kwargs["facecolor"] = "#0f0f0f"
             kwargs["labelcolor"] = "#fefefe"
             kwargs["title_color"] = "#fefefe"
 
-        self.legend = Legend(title=self._column, size=self._size, **kwargs)
+        if self._is_categorical:
+            self.legend = Legend(title=self._column, size=self._size, **kwargs)
+        else:
+            self.legend = ContinousLegend(title=self._column, size=self._size, **kwargs)
 
     def _choose_cmap(self):
         """kwargs is to catch start and stop points for the cmap in __init__."""
@@ -250,6 +326,14 @@ class ThematicMap(Map):
             self.cmap_start = 23
             self.cmap_stop = 256
 
+    def _make_bin_value_dict(self, gdf, classified) -> dict:
+        """Dict with unique values of all bins. Used in labels in ContinousLegend."""
+        bins_unique_values = {
+            i: list(set(gdf.loc[classified == i, self._column]))
+            for i, _ in enumerate(np.unique(classified))
+        }
+        return bins_unique_values
+
     def _actually_add_background(self):
         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])
@@ -271,7 +355,6 @@ class ThematicMap(Map):
             self.nan_color = "#666666"
             if not self._is_categorical:
                 self.change_cmap("viridis")
-            self._add_legend()
 
         else:
             self.facecolor, self.title_color, self.bg_gdf_color = (
@@ -282,7 +365,8 @@ class ThematicMap(Map):
             self.nan_color = "#c2c2c2"
             if not self._is_categorical:
                 self.change_cmap("RdPu", start=23)
-            self._add_legend()
+
+        self._create_legend()
 
     def __getitem__(self, item):
         return getattr(self, item)