Merge branch 'main' into bugfix/issue108-outline_color-doesnt-work

Author: timtreis

src/spatialdata_plot/_logging.py

@@ -0,0 +1,23 @@
+# from https://github.com/scverse/spatialdata/blob/main/src/spatialdata/_logging.py
+
+import logging
+
+
+def _setup_logger() -> "logging.Logger":
+    from rich.console import Console
+    from rich.logging import RichHandler
+
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.INFO)
+    console = Console(force_terminal=True)
+    if console.is_jupyter is True:
+        console.is_jupyter = False
+    ch = RichHandler(show_path=False, console=console, show_time=False)
+    logger.addHandler(ch)
+
+    # this prevents double outputs
+    logger.propagate = False
+    return logger
+
+
+logger = _setup_logger()

src/spatialdata_plot/pl/basic.py

@@ -33,6 +33,7 @@
     _render_shapes,
 )
 from spatialdata_plot.pl.utils import (
+    CmapParams,
     LegendParams,
     _FontSize,
     _FontWeight,
@@ -296,11 +297,12 @@ def render_images(
         self,
         elements: str | list[str] | None = None,
         channel: list[str] | list[int] | int | str | None = None,
-        cmap: Colormap | str | None = None,
+        cmap: list[Colormap] | list[str] | Colormap | str | None = None,
         norm: None | Normalize = None,
         na_color: str | tuple[float, ...] | None = (0.0, 0.0, 0.0, 0.0),
         palette: ListedColormap | str | None = None,
         alpha: float = 1.0,
+        quantiles_for_norm: tuple[float | None, float | None] = (3.0, 99.8),  # defaults from CSBDeep
         **kwargs: Any,
     ) -> sd.SpatialData:
         """
@@ -321,6 +323,8 @@ def render_images(
             Color to be used for NAs values, if present.
         alpha
             Alpha value for the shapes.
+        quantiles_for_norm
+            Tuple of (pmin, pmax) which will be used for quantile normalization.
         kwargs
             Additional arguments to be passed to cmap and norm.
 
@@ -332,18 +336,36 @@ def render_images(
         sdata = _verify_plotting_tree(sdata)
         n_steps = len(sdata.plotting_tree.keys())
 
-        cmap_params = _prepare_cmap_norm(
-            cmap=cmap,
-            norm=norm,
-            na_color=na_color,  # type: ignore[arg-type]
-            **kwargs,
-        )
+        if channel is None and cmap is None:
+            cmap = "brg"
+
+        cmap_params: list[CmapParams] | CmapParams
+        if isinstance(cmap, list):
+            cmap_params = [
+                _prepare_cmap_norm(
+                    cmap=c,
+                    norm=norm,
+                    na_color=na_color,  # type: ignore[arg-type]
+                    **kwargs,
+                )
+                for c in cmap
+            ]
+
+        else:
+            cmap_params = _prepare_cmap_norm(
+                cmap=cmap,
+                norm=norm,
+                na_color=na_color,  # type: ignore[arg-type]
+                **kwargs,
+            )
+
         sdata.plotting_tree[f"{n_steps+1}_render_images"] = ImageRenderParams(
             elements=elements,
             channel=channel,
             cmap_params=cmap_params,
             palette=palette,
             alpha=alpha,
+            quantiles_for_norm=quantiles_for_norm,
         )
 
         return sdata

src/spatialdata_plot/pl/render.py

@@ -4,7 +4,7 @@
 from copy import copy
 from dataclasses import dataclass
 from functools import partial
-from typing import Any, Callable, Optional, Union
+from typing import Any, Callable, Union
 
 import matplotlib
 import numpy as np
@@ -21,6 +21,7 @@
 from pandas.api.types import is_categorical_dtype
 from scanpy._settings import settings as sc_settings
 
+from spatialdata_plot._logging import logger
 from spatialdata_plot.pl.utils import (
     CmapParams,
     FigParams,
@@ -37,7 +38,6 @@
 )
 from spatialdata_plot.pp.utils import _get_instance_key, _get_region_key
 
-Palette_t = Optional[Union[str, ListedColormap]]
 _Normalize = Union[Normalize, Sequence[Normalize]]
 to_hex = partial(colors.to_hex, keep_alpha=True)
 
@@ -54,7 +54,7 @@ class ShapesRenderParams:
     contour_px: int | None = None
     alt_var: str | None = None
     layer: str | None = None
-    palette: Palette_t = None
+    palette: ListedColormap | str | None = None
     outline_alpha: float = 1.0
     fill_alpha: float = 0.3
     size: float = 1.0
@@ -208,7 +208,7 @@ class PointsRenderParams:
     elements: str | Sequence[str] | None = None
     color: str | None = None
     groups: str | Sequence[str] | None = None
-    palette: Palette_t = None
+    palette: ListedColormap | str | None = None
     alpha: float = 1.0
     size: float = 1.0
     transfunc: Callable[[float], float] | None = None
@@ -312,11 +312,12 @@ def _render_points(
 class ImageRenderParams:
     """Labels render parameters.."""
 
-    cmap_params: CmapParams
+    cmap_params: list[CmapParams] | CmapParams
     elements: str | Sequence[str] | None = None
     channel: list[str] | list[int] | int | str | None = None
-    palette: Palette_t = None
+    palette: ListedColormap | str | None = None
     alpha: float = 1.0
+    quantiles_for_norm: tuple[float | None, float | None] = (3.0, 99.8)  # defaults from CSBDeep
 
 
 def _render_images(
@@ -347,47 +348,126 @@ def _render_images(
     for img in images:
         if (len(img.c) > 3 or len(img.c) == 2) and render_params.channel is None:
             raise NotImplementedError("Only 1 or 3 channels are supported at the moment.")
-        if render_params.channel is None and len(img.c) == 1:
-            render_params.channel = 0
-        if render_params.channel is not None:
+
+        if render_params.channel is None:
+            channels = img.coords["c"].values
+        else:
             channels = (
                 [render_params.channel] if isinstance(render_params.channel, (str, int)) else render_params.channel
             )
-            img = img.sel(c=channels)
-            num_channels = img.sizes["c"]
+
+        n_channels = len(channels)
+
+        got_multiple_cmaps = isinstance(render_params.cmap_params, list)
+
+        if not isinstance(render_params.cmap_params, list):
+            render_params.cmap_params = [render_params.cmap_params] * n_channels
+
+        if got_multiple_cmaps:
+            logger.warning(
+                "You're blending multiple cmaps. "
+                "If the plot doesn't look like you expect, it might be because your "
+                "cmaps go from a given color to 'white', and not to 'transparent'. "
+                "Therefore, the 'white' of higher layers will overlay the lower layers. "
+                "Consider using 'palette' instead."
+            )
 
             if render_params.palette is not None:
-                if num_channels > len(render_params.palette):
-                    raise ValueError("If palette is provided, it must match the number of channels.")
+                logger.warning("Parameter 'palette' is ignored when a 'cmap' is provided.")
+
+            for idx, channel in enumerate(channels):
+                layer = img.sel(c=channel)
+
+                if render_params.quantiles_for_norm != (None, None):
+                    layer = _normalize(
+                        layer,
+                        pmin=render_params.quantiles_for_norm[0],
+                        pmax=render_params.quantiles_for_norm[1],
+                        clip=True,
+                    )
+
+                if render_params.cmap_params[idx].norm is not None:
+                    layer = render_params.cmap_params[idx].norm(layer)
+
+                ax.imshow(
+                    layer,
+                    cmap=render_params.cmap_params[idx].cmap,
+                    alpha=(1 / n_channels),
+                )
+            break
+
+        if n_channels == 1:
+            layer = img.sel(c=channels)
+
+            if render_params.quantiles_for_norm != (None, None):
+                layer = _normalize(
+                    layer, pmin=render_params.quantiles_for_norm[0], pmax=render_params.quantiles_for_norm[1], clip=True
+                )
+
+            if render_params.cmap_params[0].norm is not None:
+                layer = render_params.cmap_params[0].norm(layer)
 
-                color = render_params.palette
+            if render_params.palette is None:
+                ax.imshow(
+                    layer.squeeze(),  # get rid of the channel dimension
+                    cmap=render_params.cmap_params[0].cmap,
+                )
 
             else:
-                color = _get_colors_for_categorical_obs(
-                    img.coords["c"].values.tolist(), palette=render_params.cmap_params.cmap
+                ax.imshow(
+                    layer.squeeze(),  # get rid of the channel dimension
+                    cmap=_get_linear_colormap([render_params.palette], "k")[0],
                 )
 
-            cmaps = _get_linear_colormap([str(c) for c in color[:num_channels]], "k")
-            img = _normalize(img, clip=True)
-            colored = np.stack([cmaps[i](img.values[i]) for i in range(num_channels)], 0).sum(0)
-            img = xr.DataArray(
+            break
+
+        if render_params.palette is not None and n_channels != len(render_params.palette):
+            raise ValueError("If 'palette' is provided, its length must match the number of channels.")
+
+        if n_channels > 1:
+            layer = img.sel(c=channels).copy(deep=True)
+
+            channel_colors: list[str] | Any
+            if render_params.palette is None:
+                channel_colors = _get_colors_for_categorical_obs(
+                    layer.coords["c"].values.tolist(), palette=render_params.cmap_params[0].cmap
+                )
+            else:
+                channel_colors = render_params.palette
+
+            channel_cmaps = _get_linear_colormap([str(c) for c in channel_colors[:n_channels]], "k")
+
+            layer_vals = []
+            if render_params.quantiles_for_norm != (None, None):
+                for i in range(n_channels):
+                    layer_vals.append(
+                        _normalize(
+                            layer.values[i],
+                            pmin=render_params.quantiles_for_norm[0],
+                            pmax=render_params.quantiles_for_norm[1],
+                            clip=True,
+                        )
+                    )
+
+            colored = np.stack([channel_cmaps[i](layer_vals[i]) for i in range(n_channels)], 0).sum(0)
+
+            layer = xr.DataArray(
                 data=colored,
                 coords=[
-                    img.coords["y"],
-                    img.coords["x"],
+                    layer.coords["y"],
+                    layer.coords["x"],
                     ["R", "G", "B", "A"],
                 ],
                 dims=["y", "x", "c"],
             )
+            layer = layer.transpose("y", "x", "c")  # for plotting
 
-        img = img.transpose("y", "x", "c")  # for plotting
-
-        ax.imshow(
-            img.data,
-            cmap=render_params.cmap_params.cmap,
-            alpha=render_params.alpha,
-            # extent=extent,
-        )
+            ax.imshow(
+                layer.data,
+                cmap=channel_cmaps[0],
+                alpha=render_params.alpha,
+                norm=render_params.cmap_params[0].norm,
+            )
 
 
 @dataclass
@@ -402,7 +482,7 @@ class LabelsRenderParams:
     outline: bool = False
     alt_var: str | None = None
     layer: str | None = None
-    palette: Palette_t = None
+    palette: ListedColormap | str | None = None
     outline_alpha: float = 1.0
     fill_alpha: float = 0.4
     transfunc: Callable[[float], float] | None = None

src/spatialdata_plot/pl/utils.py

@@ -603,8 +603,8 @@ def _get_hex_colors_for_continous_values(values: pd.Series, cmap_name: str = "vi
 
 def _normalize(
     img: xr.DataArray,
-    pmin: float = 3.0,
-    pmax: float = 99.8,
+    pmin: float | None = 3.0,
+    pmax: float | None = 99.8,
     eps: float = 1e-20,
     clip: bool = False,
     name: str = "normed",
@@ -618,9 +618,9 @@ def _normalize(
     dataarray
         A xarray DataArray with an image field.
     pmin
-        Lower quantile (min value) used to perform qunatile normalization.
+        Lower quantile (min value) used to perform quantile normalization.
     pmax
-        Upper quantile (max value) used to perform qunatile normalization.
+        Upper quantile (max value) used to perform quantile normalization.
     eps
         Epsilon float added to prevent 0 division.
     clip
@@ -631,9 +631,12 @@ def _normalize(
     xr.DataArray
         A min-max normalized image.
     """
-    perc = np.percentile(img, [pmin, pmax], axis=(1, 2)).T
+    pmin = pmin or 0.0
+    pmax = pmax or 100.0
 
-    norm = (img - np.expand_dims(perc[:, 0], (1, 2))) / (np.expand_dims(perc[:, 1] - perc[:, 0], (1, 2)) + eps)
+    perc = np.percentile(img, [pmin, pmax])
+
+    norm = (img - perc[0]) / (perc[1] - perc[0] + eps)
 
     if clip:
         norm = np.clip(norm, 0, 1)
@@ -691,7 +694,7 @@ def _get_colors_for_categorical_obs(
     elif isinstance(palette, ListedColormap):
         palette = [to_hex(x) for x in palette(color_idx, alpha=alpha)]
     elif isinstance(palette, LinearSegmentedColormap):
-        palette = [to_hex(palette(x, alpha=alpha)) for x in [color_idx]]
+        palette = [to_hex(palette(x, alpha=alpha)) for x in color_idx]  # type: ignore[attr-defined]
     else:
         raise TypeError(f"Palette is {type(palette)} but should be string or `ListedColormap`.")
 

tests/_images/Extent_extent_of_img_full_canvas.png

@@ -22,5 +22,27 @@ class TestImages(PlotTester, metaclass=PlotTesterMeta):
     def test_plot_can_render_image(self, sdata_blobs: SpatialData):
         sdata_blobs.pl.render_images(elements="blobs_image").pl.show()
 
-    # def test_plot_can_render_multiscale_image(self, sdata_blobs: SpatialData):
-    #     sdata_blobs.pl.render_images(elements="blobs_multiscale_image").pl.show()
+    def test_plot_can_pass_cmap_to_render_images(self, sdata_blobs: SpatialData):
+        sdata_blobs.pl.render_images(elements="blobs_image", cmap="seismic").pl.show()
+
+    def test_plot_can_render_a_single_channel_from_image(self, sdata_blobs: SpatialData):
+        sdata_blobs.pl.render_images(elements="blobs_image", channel=0).pl.show()
+
+    def test_plot_can_render_two_channels_from_image(self, sdata_blobs: SpatialData):
+        sdata_blobs.pl.render_images(elements="blobs_image", channel=[0, 1]).pl.show()
+
+    def test_plot_can_pass_color_to_single_channel(self, sdata_blobs: SpatialData):
+        sdata_blobs.pl.render_images(elements="blobs_image", channel=1, palette="red").pl.show()
+
+    def test_plot_can_pass_cmap_to_single_channel(self, sdata_blobs: SpatialData):
+        sdata_blobs.pl.render_images(elements="blobs_image", channel=1, cmap="Reds").pl.show()
+
+    def test_plot_can_pass_color_to_each_channel(self, sdata_blobs: SpatialData):
+        sdata_blobs.pl.render_images(
+            elements="blobs_image", channel=[0, 1, 2], palette=["red", "green", "blue"]
+        ).pl.show()
+
+    def test_plot_can_pass_cmap_to_each_channel(self, sdata_blobs: SpatialData):
+        sdata_blobs.pl.render_images(
+            elements="blobs_image", channel=[0, 1, 2], cmap=["Reds", "Greens", "Blues"]
+        ).pl.show()