implemented outline color for rendering labels

Author: MeyerBender

src/spatialdata_plot/pl/basic.py

@@ -641,6 +641,7 @@ def render_labels(
         na_color: ColorLike | None = "default",
         outline_alpha: float | int = 0.0,
         fill_alpha: float | int | None = None,
+        outline_color: ColorLike | tuple[ColorLike] | None = None,
         scale: str | None = None,
         colorbar: bool | str | None = "auto",
         colorbar_params: dict[str, object] | None = None,
@@ -692,6 +693,10 @@ def render_labels(
         fill_alpha : float | int | None, optional
             Alpha value for the fill of the labels. By default, it is set to 0.4 or, if a color is given that implies
             an alpha, that value is used for `fill_alpha`.
+        outline_color : ColorLike | None
+            Color of the outline of the labels. Can either be a named color ("red"), a hex representation
+            ("#000000") or a list of floats that represent RGB/RGBA values (1.0, 0.0, 0.0, 1.0). If None, the outline
+            color is set to "black".
         scale :  str | None
             Influences the resolution of the rendering. Possibilities for setting this parameter:
                 1) None (default). The image is rasterized to fit the canvas size. For multiscale images, the best scale
@@ -731,6 +736,7 @@ def render_labels(
             na_color=na_color,
             norm=norm,
             outline_alpha=outline_alpha,
+            outline_color=outline_color,
             palette=palette,
             scale=scale,
             colorbar=colorbar,
@@ -758,6 +764,7 @@ def render_labels(
                 cmap_params=cmap_params,
                 palette=param_values["palette"],
                 outline_alpha=param_values["outline_alpha"],
+                outline_color=param_values["outline_color"],
                 fill_alpha=param_values["fill_alpha"],
                 transfunc=kwargs.get("transfunc"),
                 scale=param_values["scale"],

src/spatialdata_plot/pl/render.py

@@ -1348,7 +1348,8 @@ def _render_labels(
         else:
             assert color_source_vector is None
 
-    def _draw_labels(seg_erosionpx: int | None, seg_boundaries: bool, alpha: float) -> matplotlib.image.AxesImage:
+    def _draw_labels(seg_erosionpx: int | None, seg_boundaries: bool, alpha: float, 
+                    outline_color: ColorLike | tuple[ColorLike] | None = None) -> matplotlib.image.AxesImage:
         labels = _map_color_seg(
             seg=label.values,
             cell_id=instance_id,
@@ -1358,6 +1359,7 @@ def _draw_labels(seg_erosionpx: int | None, seg_boundaries: bool, alpha: float)
             seg_erosionpx=seg_erosionpx,
             seg_boundaries=seg_boundaries,
             na_color=na_color,
+            outline_color=outline_color,
         )
 
         _cax = ax.imshow(
@@ -1389,6 +1391,7 @@ def _draw_labels(seg_erosionpx: int | None, seg_boundaries: bool, alpha: float)
             seg_erosionpx=render_params.contour_px,
             seg_boundaries=True,
             alpha=render_params.outline_alpha,
+            outline_color=render_params.outline_color,
         )
         alpha_to_decorate_ax = render_params.outline_alpha
 
@@ -1402,6 +1405,7 @@ def _draw_labels(seg_erosionpx: int | None, seg_boundaries: bool, alpha: float)
             seg_erosionpx=render_params.contour_px,
             seg_boundaries=True,
             alpha=render_params.outline_alpha,
+            outline_color=render_params.outline_color
         )
 
         # pass the less-transparent _cax for the legend

src/spatialdata_plot/pl/render_params.py

@@ -285,6 +285,7 @@ class LabelsRenderParams:
     outline: bool = False
     palette: ListedColormap | list[str] | None = None
     outline_alpha: float = 1.0
+    outline_color: ColorLike | tuple[ColorLike] | None = None
     fill_alpha: float = 0.4
     transfunc: Callable[[float], float] | None = None
     scale: str | None = None

src/spatialdata_plot/pl/utils.py

@@ -16,6 +16,7 @@
 import matplotlib.patches as mpatches
 import matplotlib.path as mpath
 import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
 import matplotlib.ticker
 import matplotlib.transforms as mtransforms
 import numpy as np
@@ -1160,6 +1161,7 @@ def _map_color_seg(
     na_color: Color,
     seg_erosionpx: int | None = None,
     seg_boundaries: bool = False,
+    outline_color: Color | None = None,
 ) -> ArrayLike:
     cell_id = np.array(cell_id)
 
@@ -1211,8 +1213,33 @@ def _map_color_seg(
     if seg_boundaries:
         if seg.shape[0] == 1:
             seg = np.squeeze(seg, axis=0)
-        seg_bound: ArrayLike = np.clip(seg_im - find_boundaries(seg)[:, :, None], 0, 1)
-        return np.dstack((seg_bound, np.where(val_im > 0, 1, 0)))  # add transparency here
+        
+        # Binary boundary mask
+        boundary_mask = find_boundaries(seg)  # True where boundaries are
+
+        # Ensure seg_im is float in 0-1 and has 3 channels
+        seg_float = seg_im.astype(float)
+        if seg_float.ndim == 2:
+            seg_float = np.stack([seg_float] * 3, axis=-1)  # H x W x 3
+
+        # Add alpha channel from val_im (preserve original mask)
+        alpha_channel = (val_im > 0).astype(float)
+        seg_float = np.dstack((seg_float, alpha_channel))  # H x W x 4
+
+        # Convert outline_color to RGBA
+        if outline_color is None:
+            outline_rgba = (0, 0, 0, 1.0)  # default black
+        elif isinstance(outline_color, str):
+            outline_rgba = mcolors.to_rgba(outline_color)  # named color or hex string
+        else:
+            # assume it's your Color object
+            outline_rgba = mcolors.to_rgba(outline_color.get_hex_with_alpha())
+
+        # Apply outline color to boundary pixels, but keep original alpha from val_im
+        seg_float[boundary_mask, :3] = outline_rgba[:3]      # RGB
+        seg_float[boundary_mask, 3] = alpha_channel[boundary_mask] * outline_rgba[3]  # scale alpha
+
+        return seg_float  # H x W x 4, valid RGBA
 
     if len(val_im.shape) != len(seg_im.shape):
         val_im = np.expand_dims((val_im > 0).astype(int), axis=-1)
@@ -2437,6 +2464,7 @@ def _validate_label_render_params(
     na_color: ColorLike | None,
     norm: Normalize | None,
     outline_alpha: float | int,
+    outline_color: ColorLike | tuple[ColorLike] | None,
     scale: str | None,
     table_name: str | None,
     table_layer: str | None,
@@ -2453,6 +2481,7 @@ def _validate_label_render_params(
         "color": color,
         "na_color": na_color,
         "outline_alpha": outline_alpha,
+        "outline_color": outline_color,
         "cmap": cmap,
         "norm": norm,
         "scale": scale,
@@ -2475,6 +2504,7 @@ def _validate_label_render_params(
         element_params[el]["fill_alpha"] = param_dict["fill_alpha"]
         element_params[el]["scale"] = param_dict["scale"]
         element_params[el]["outline_alpha"] = param_dict["outline_alpha"]
+        element_params[el]["outline_color"] = param_dict["outline_color"]
         element_params[el]["contour_px"] = param_dict["contour_px"]
         element_params[el]["table_layer"] = param_dict["table_layer"]