fix(color): correct LogNorm domain + make continuous colorbars reflect the resolved norm

_resolve_continuous_norm preserved the norm subclass (#722) but still derived
vmin/vmax from the full data range, so a LogNorm over data containing 0 or
negatives produced LogNorm(vmin<=0) and raised 'Invalid vmin or vmax' on render.
Derive the range from strictly-positive finite values for LogNorm (mirrors
matplotlib's LogNorm.autoscale_None).

Once the subclass is preserved, the continuous colorbar sites must attach the
resolved norm, not a default linear Normalize:
- shapes fill: set_norm(used_norm) instead of set_clim.
- labels: imshow of a pre-baked RGB image cannot carry a non-linear norm, so
  display the RGB without a norm and build the colorbar from a
  ScalarMappable(norm=used_norm), mirroring the outline path.

as_points now carries the upstream colortype instead of re-deriving it from
'source is not None', so an all-NaN ('none') layer is not mislabelled categorical.

Adds regression tests feeding LogNorm zeros/negatives/all-NaN (and invoking the
norm) plus a shapes colorbar-subclass assertion.

Author: timtreis

src/spatialdata_plot/pl/_color.py

@@ -124,8 +124,16 @@ def _resolve_continuous_norm(values: Any, cmap_params: CmapParams) -> Normalize:
         if not np.issubdtype(arr.dtype, np.number):
             arr = pd.to_numeric(arr.ravel(), errors="coerce")
         finite = np.isfinite(arr)
-        data_min = float(np.nanmin(arr[finite])) if finite.any() else 0.0
-        data_max = float(np.nanmax(arr[finite])) if finite.any() else 1.0
+        if isinstance(base, LogNorm):
+            # LogNorm's domain excludes 0/negatives; derive the range from strictly-positive
+            # finite values only (mirrors matplotlib's LogNorm.autoscale_None). Otherwise a
+            # data_min <= 0 produces a LogNorm that raises "Invalid vmin or vmax" when called.
+            positive = arr[finite & (arr > 0)]
+            data_min = float(np.nanmin(positive)) if positive.size else 1.0
+            data_max = float(np.nanmax(positive)) if positive.size else 1.0
+        else:
+            data_min = float(np.nanmin(arr[finite])) if finite.any() else 0.0
+            data_max = float(np.nanmax(arr[finite])) if finite.any() else 1.0
         if vmin is None:
             vmin = data_min
         if vmax is None:

src/spatialdata_plot/pl/render.py

@@ -34,6 +34,7 @@
 from spatialdata_plot._logging import _log_context, logger
 from spatialdata_plot.pl._color import (
     ColorSpec,
+    ColorType,
     _get_colors_for_categorical_obs,
     _get_linear_colormap,
     _map_color_seg,
@@ -968,9 +969,11 @@ def _render_shapes(
             path.vertices = trans.transform(path.vertices)
 
     if color_spec.is_continuous:
-        # Colorbar range from the same resolved norm the fill pixels use.
+        # Colorbar uses the same resolved norm the fill pixels use, including its subclass
+        # (LogNorm/PowerNorm) — set_norm, not set_clim, which would leave the collection's
+        # default linear Normalize in place and mis-scale the bar for non-linear norms.
         used_norm = _resolve_continuous_norm(color_spec.color_vector, render_params.cmap_params)
-        _cax.set_clim(vmin=used_norm.vmin, vmax=used_norm.vmax)
+        _cax.set_norm(used_norm)
 
     _add_legend_and_colorbar(
         ax=ax,
@@ -2297,25 +2300,29 @@ def _render_labels(
             # (`_map_color_seg` Case C) instead of collapsing every dot to a single na_color.
             point_color_vector = np.random.default_rng(42).random((len(point_ids), 3))
             point_color_source_vector = None
+            point_colortype: ColorType = "none"  # colour is not data-driven
             allow_datashader = False
         elif len(color_spec.color_vector) == len(instance_id):
-            # data-driven colour is per-instance
+            # data-driven colour is per-instance; carry the upstream classification (invariant under mask)
             point_color_vector = np.asarray(color_spec.color_vector)[keep]
             point_color_source_vector = None if color_spec.source_vector is None else color_spec.source_vector[keep]
+            point_colortype = color_spec.colortype
         else:
             # literal colour / user-set na_color -> one colour per centroid
             point_color_vector = np.full(len(point_ids), na_color.get_hex_with_alpha())
             point_color_source_vector = None
+            point_colortype = "none"  # colour is not data-driven
         # transform rendered-raster intrinsic centroids to coordinate-system coords
         xy = trans.transform(np.column_stack([centroids["x"].to_numpy(), centroids["y"].to_numpy()]))
         _render_centroids_as_points(
             ax,
             render_params,
             x=xy[:, 0],
             y=xy[:, 1],
-            # point colours are derived fresh; classify by source so the spec stays self-consistent
+            # point colours are derived fresh; carry the resolved colortype so the spec invariant
+            # (categorical => pd.Categorical source) holds and `none` is not mislabelled categorical
             color_spec=ColorSpec(
-                "categorical" if point_color_source_vector is not None else "continuous",
+                point_colortype,
                 point_color_source_vector,
                 point_color_vector,
             ),
@@ -2352,20 +2359,17 @@ def _draw_labels(
             outline_color_source_vector=outline_color_source_vector if seg_boundaries else None,
         )
 
-        # labels is pre-baked RGB; cmap/norm only drive the colorbar, so feed the same resolved norm.
-        cax = ax.imshow(
-            labels,
-            rasterized=True,
-            cmap=None if color_spec.is_categorical else render_params.cmap_params.cmap,
-            norm=None
-            if color_spec.is_categorical
-            else _resolve_continuous_norm(color_spec.color_vector, render_params.cmap_params),
-            alpha=alpha,
-            origin="lower",
-            zorder=render_params.zorder,
-        )
-        cax.set_transform(trans_data)
-        return cax
+        # labels is pre-baked RGB, so imshow ignores cmap/norm for display. Passing the resolved
+        # norm to imshow would make it try to normalize the RGBA array — which raises for a
+        # non-linear norm (LogNorm/PowerNorm). Display the RGB without a norm and build the
+        # continuous colorbar mappable separately from the resolved norm (mirrors the outline path),
+        # so the colorbar reflects the real norm subclass.
+        img = ax.imshow(labels, rasterized=True, alpha=alpha, origin="lower", zorder=render_params.zorder)
+        img.set_transform(trans_data)
+        if color_spec.is_categorical:
+            return img
+        used_norm = _resolve_continuous_norm(color_spec.color_vector, render_params.cmap_params)
+        return ScalarMappable(norm=used_norm, cmap=render_params.cmap_params.cmap)
 
     # When color is a literal (col_for_color is None) and no explicit outline_color,
     # use the literal color for outlines so they are visible (e.g., color='white' on

tests/pl/test_render_labels.py

@@ -540,6 +540,45 @@ def test_render_labels_all_nan_color_renders_under_rasterize(sdata_blobs: Spatia
     plt.close(fig)
 
 
+def test_render_labels_as_points_all_nan_color_does_not_crash(sdata_blobs: SpatialData):
+    # Regression: as_points rebuilds the centroid ColorSpec; an all-NaN column is the "none" colortype
+    # and must not be re-classified "categorical" (which would later call Categorical-only methods on
+    # the na-array source). It must just render the centroids in na_color.
+    labels_name = "blobs_labels"
+    instances = get_element_instances(sdata_blobs[labels_name])
+    n_obs = len(instances)
+    adata = AnnData(np.zeros((n_obs, 1)))
+    adata.obs["instance_id"] = instances.values
+    adata.obs["nanvals"] = np.full(n_obs, np.nan)
+    adata.obs["region"] = labels_name
+    sdata_blobs["label_table"] = TableModel.parse(
+        adata=adata, region_key="region", instance_key="instance_id", region=labels_name
+    )
+    fig, ax = plt.subplots()
+    sdata_blobs.pl.render_labels(labels_name, color="nanvals", table_name="label_table", as_points=True).pl.show(ax=ax)
+    plt.close(fig)
+
+
+def test_render_labels_lognorm_with_zeros_does_not_crash(sdata_blobs: SpatialData):
+    # Regression: a continuous LogNorm column containing 0 must derive a positive vmin instead of a
+    # LogNorm(vmin=0) that raises "Invalid vmin or vmax" when the segmentation colors are mapped.
+    from matplotlib.colors import LogNorm
+
+    labels_name = "blobs_labels"
+    instances = get_element_instances(sdata_blobs[labels_name])
+    n_obs = len(instances)
+    adata = AnnData(np.zeros((n_obs, 1)))
+    adata.obs["instance_id"] = instances.values
+    adata.obs["counts"] = np.linspace(0.0, 10.0, n_obs)  # includes 0
+    adata.obs["region"] = labels_name
+    sdata_blobs["label_table"] = TableModel.parse(
+        adata=adata, region_key="region", instance_key="instance_id", region=labels_name
+    )
+    fig, ax = plt.subplots()
+    sdata_blobs.pl.render_labels(labels_name, color="counts", table_name="label_table", norm=LogNorm()).pl.show(ax=ax)
+    plt.close(fig)
+
+
 @pytest.mark.parametrize("dtype", [np.float16, np.float32, np.float64])
 def test_render_labels_rejects_float_dtype(dtype):
     # Regression test for #606: float-dtype labels must raise a clear

tests/pl/test_render_shapes.py

@@ -1150,6 +1150,29 @@ def test_render_shapes_all_nan_color_with_groups_does_not_crash(sdata_blobs_shap
     plt.close(fig)
 
 
+def test_render_shapes_lognorm_with_zeros_does_not_crash(sdata_blobs_shapes_annotated: SpatialData):
+    # Regression: a continuous LogNorm column containing 0 must derive a positive vmin instead of
+    # producing a LogNorm(vmin=0) that raises "Invalid vmin or vmax" when the fill is mapped.
+    from matplotlib.colors import LogNorm
+
+    sdata_blobs_shapes_annotated["blobs_polygons"]["counts"] = [0.0, 2.5, 5.0, 7.5, 10.0]
+    fig, ax = plt.subplots()
+    sdata_blobs_shapes_annotated.pl.render_shapes("blobs_polygons", color="counts", norm=LogNorm()).pl.show(ax=ax)
+    plt.close(fig)
+
+
+def test_render_shapes_continuous_colorbar_reflects_norm_subclass(sdata_blobs_shapes_annotated: SpatialData):
+    # Regression: the fill colorbar must use the resolved norm subclass (LogNorm), not the
+    # collection's default linear Normalize — i.e. set_norm, not set_clim.
+    from matplotlib.colors import LogNorm
+
+    sdata_blobs_shapes_annotated["blobs_polygons"]["counts"] = [1.0, 2.5, 5.0, 7.5, 10.0]
+    fig, ax = plt.subplots()
+    sdata_blobs_shapes_annotated.pl.render_shapes("blobs_polygons", color="counts", norm=LogNorm()).pl.show(ax=ax)
+    assert any(isinstance(c.norm, LogNorm) for c in ax.collections), "fill colorbar norm was linearized"
+    plt.close(fig)
+
+
 def test_gene_symbols_auto_detect_table(sdata_blobs: SpatialData):
     """gene_symbols resolves correctly without explicit table_name (#247)."""
     sdata_blobs["table"].obs["region"] = pd.Categorical(["blobs_circles"] * sdata_blobs["table"].n_obs)

tests/pl/test_utils.py

@@ -917,6 +917,43 @@ def test_object_dtype_coerces_color_strings_to_nan(self):
         norm = _resolve_continuous_norm(np.array([1.0, "red", 9.0], dtype=object), self._params())
         assert (norm.vmin, norm.vmax) == (1.0, 9.0)
 
+    def test_lognorm_with_zero_derives_positive_vmin_and_does_not_raise(self):
+        # regression: deriving vmin from a LogNorm's data range must skip 0/negatives; otherwise the
+        # preserved LogNorm has vmin <= 0 and raises "Invalid vmin or vmax" when the renderer calls it
+        from matplotlib.colors import LogNorm
+
+        from spatialdata_plot.pl._color import _resolve_continuous_norm
+
+        vals = np.array([0.0, 5.0, 50.0])
+        params = CmapParams(cmap=self._params().cmap, norm=LogNorm(vmin=None, vmax=None), na_color=Color())
+        norm = _resolve_continuous_norm(vals, params)
+        assert isinstance(norm, LogNorm)
+        assert norm.vmin == 5.0 and norm.vmax == 50.0  # smallest positive, not 0
+        norm(vals)  # must not raise
+
+    def test_lognorm_with_negatives_derives_positive_vmin(self):
+        from matplotlib.colors import LogNorm
+
+        from spatialdata_plot.pl._color import _resolve_continuous_norm
+
+        vals = np.array([-10.0, 1.0, 100.0])
+        params = CmapParams(cmap=self._params().cmap, norm=LogNorm(vmin=None, vmax=None), na_color=Color())
+        norm = _resolve_continuous_norm(vals, params)
+        assert isinstance(norm, LogNorm)
+        assert norm.vmin == 1.0 and norm.vmax == 100.0
+        norm(vals)  # must not raise
+
+    def test_lognorm_all_nonpositive_falls_back_without_raising(self):
+        from matplotlib.colors import LogNorm
+
+        from spatialdata_plot.pl._color import _resolve_continuous_norm
+
+        params = CmapParams(cmap=self._params().cmap, norm=LogNorm(vmin=None, vmax=None), na_color=Color())
+        norm = _resolve_continuous_norm(np.array([0.0, -1.0, np.nan]), params)
+        assert isinstance(norm, LogNorm)
+        assert (norm.vmin, norm.vmax) == (1.0, 1.0)
+        norm(np.array([1.0]))  # must not raise
+
     def test_same_values_give_identical_norm_and_never_mutate_shared(self):
         # the core #699 invariant: pixels and colorbar call this with the same vector -> same result,
         # and the shared CmapParams.norm is never autoscaled in place.