From 27ba8d29ba73d2b6b0796cfc190d9601b6dadae3 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Mon, 8 Jun 2026 14:36:12 +0200
Subject: [PATCH 01/28] Centroid extraction + squidpy obsm["spatial"] caching;
 shared scatter helper
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Infrastructure for an upcoming "render cells as centroid points" fast mode
(no user-facing render option yet).

Phase 0 — shared scatter primitive:
- Extract `_scatter_points(ax, x, y, color_vector, ...)` from `_render_points`'s
  matplotlib branch; `_render_points` now calls it. Byte-identical output
  (verified vs main on categorical and continuous point renders). This is the
  reuse seam the fast mode will draw through.

Phase 1 — centroid + caching core (headless, fully unit-tested):
- `_compute_element_centroids` / `_compute_label_centroids`: per-instance
  centroids in a coordinate system. Shapes use spatialdata's vectorized
  `get_centroids`; labels use skimage `regionprops` (the per-label reduction is
  orders of magnitude faster than `get_centroids` on rasters), mapped onto the
  raster's intrinsic coordinate arrays so it reproduces `get_centroids` exactly
  (incl. the pixel-center 0.5 offset) then transformed to the target CS.
- `_get_or_compute_centroids`: reuses/persists centroids via the squidpy
  convention. A pre-existing `obsm["spatial"]` (loader/user-provided) is trusted
  as the cells' locations; otherwise centroids are computed and written back into
  the annotating table's `obsm["spatial"]` with a coordinate-system provenance
  marker in `uns`, so later renders are instant. Reads run before writes, so a
  valid existing cache is reused rather than clobbered; an incompatible existing
  `obsm["spatial"]` is never overwritten; the cache is invalidated when the
  requested coordinate system differs.
- Tests: shapes/labels centroids match `get_centroids`; cache round-trip +
  provenance; CS invalidation; pre-existing obsm trusted; no-table compute path;
  `cache=False` writes nothing.
---
 src/spatialdata_plot/pl/render.py |  47 +++++++--
 src/spatialdata_plot/pl/utils.py  | 167 +++++++++++++++++++++++++++++-
 tests/pl/test_utils.py            |  65 ++++++++++++
 3 files changed, 271 insertions(+), 8 deletions(-)

diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index 9ee64033..160b4087 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -21,7 +21,7 @@
 from anndata import AnnData
 from matplotlib import patheffects
 from matplotlib.cm import ScalarMappable
-from matplotlib.colors import ListedColormap, Normalize
+from matplotlib.colors import Colormap, ListedColormap, Normalize
 from scanpy._settings import settings as sc_settings
 from scanpy.plotting._tools.scatterplots import _add_categorical_legend
 from spatialdata import get_extent, get_values
@@ -1052,6 +1052,40 @@ def _render_shapes(
     )
 
 
+def _scatter_points(
+    ax: matplotlib.axes.SubplotBase,
+    x: Any,
+    y: Any,
+    color_vector: Any,
+    *,
+    size: float,
+    cmap: Colormap,
+    norm: Normalize | None,
+    alpha: float,
+    trans_data: Any,
+    zorder: int,
+) -> Any:
+    """Draw one marker per (x, y) colored by ``color_vector`` via ``ax.scatter``.
+
+    Shared matplotlib scatter primitive: used by ``_render_points`` and (later) by the
+    centroid-point "fast" rendering of shapes/labels. ``color_vector`` is per-point hex
+    strings (categorical) or numeric values mapped through ``cmap``/``norm`` (continuous).
+    """
+    return ax.scatter(
+        x,
+        y,
+        s=size,
+        c=color_vector,
+        rasterized=sc_settings._vector_friendly,
+        cmap=cmap,
+        norm=norm,
+        alpha=alpha,
+        transform=trans_data,
+        zorder=zorder,
+        plotnonfinite=True,  # nan points should be rendered as well
+    )
+
+
 def _render_points(
     sdata: sd.SpatialData,
     render_params: PointsRenderParams,
@@ -1404,18 +1438,17 @@ def _render_points(
     elif method == "matplotlib":
         # update axis limits if plot was empty before (necessary if datashader comes after)
         update_parameters = not _mpl_ax_contains_elements(ax)
-        cax = ax.scatter(
+        cax = _scatter_points(
+            ax,
             adata[:, 0].X.flatten(),
             adata[:, 1].X.flatten(),
-            s=render_params.size,
-            c=color_vector,
-            rasterized=sc_settings._vector_friendly,
+            color_vector,
+            size=render_params.size,
             cmap=render_params.cmap_params.cmap,
             norm=norm,
             alpha=render_params.alpha,
-            transform=trans_data,
+            trans_data=trans_data,
             zorder=render_params.zorder,
-            plotnonfinite=True,  # nan points should be rendered as well
         )
         if update_parameters:
             # necessary if points are plotted with mpl first and then with datashader
diff --git a/src/spatialdata_plot/pl/utils.py b/src/spatialdata_plot/pl/utils.py
index 5ddefdb9..81b29a74 100644
--- a/src/spatialdata_plot/pl/utils.py
+++ b/src/spatialdata_plot/pl/utils.py
@@ -55,19 +55,29 @@
 from scipy.spatial import ConvexHull
 from shapely.errors import GEOSException
 from skimage.color import label2rgb
+from skimage.measure import regionprops_table
 from skimage.morphology import erosion, footprint_rectangle
 from skimage.util import map_array
 from spatialdata import (
     SpatialData,
+    get_centroids,
     get_element_annotators,
     get_extent,
     get_values,
     join_spatialelement_table,
     rasterize,
 )
+from spatialdata._core.operations.transform import transform as sd_transform
 from spatialdata._core.query.relational_query import _locate_value
 from spatialdata._types import ArrayLike
-from spatialdata.models import Image2DModel, Labels2DModel, SpatialElement, get_table_keys
+from spatialdata.models import (
+    Image2DModel,
+    Labels2DModel,
+    PointsModel,
+    SpatialElement,
+    get_model,
+    get_table_keys,
+)
 from spatialdata.transformations.operations import get_transformation
 from spatialdata.transformations.transformations import Scale, Translation
 from spatialdata.transformations.transformations import Sequence as TransformSequence
@@ -4417,3 +4427,158 @@ def _convert_alpha_to_datashader_range(alpha: float) -> float:
     """Convert alpha from the range [0, 1] to the range [0, 255] used in datashader."""
     # prevent a value of 255, bc that led to fully colored test plots instead of just colored points/shapes
     return min([254, alpha * 255])
+
+
+# --- Cell-centroid extraction & caching (squidpy `obsm["spatial"]` convention) ---
+
+# squidpy/scanpy canonical key for per-cell coordinates: an N x 2 array, row-aligned to obs.
+_CENTROID_OBSM_KEY = "spatial"
+# Provenance marker so we know which element / coordinate system a cached `obsm["spatial"]`
+# was computed for, and can invalidate it when the requested coordinate system changes.
+_CENTROID_PROVENANCE_UNS_KEY = "spatialdata_plot"
+
+
+def _compute_label_centroids(element: DataArray | DataTree, coordinate_system: str) -> pd.DataFrame:
+    """Per-label centroids via skimage ``regionprops`` + the element's coordinate transform.
+
+    ``regionprops`` does the per-label reduction in a single C pass, which is orders of
+    magnitude faster than ``spatialdata.get_centroids`` on labels (that scans the raster
+    row/column-wise and scales with raster area). The intrinsic pixel centroids are then
+    mapped into ``coordinate_system`` with spatialdata's own transform machinery.
+    """
+    raster = element
+    if isinstance(element, DataTree):
+        # full-resolution level, matching spatialdata.get_centroids
+        raster = next(iter(element["scale0"].values()))
+    values = np.asarray(raster.data)  # materialize the intrinsic pixel grid
+    props = regionprops_table(values, properties=("label", "centroid"))
+
+    # regionprops excludes background (label 0); centroid-0 = row (y), centroid-1 = col (x)
+    # as 0-based fractional indices. Map them onto the raster's intrinsic coordinate arrays
+    # (spatialdata uses pixel-center coords 0.5, 1.5, ... and possibly non-unit spacing),
+    # which reproduces spatialdata.get_centroids exactly.
+    def _index_to_coord(idx: ArrayLike, coord: ArrayLike) -> ArrayLike:
+        spacing = (coord[1] - coord[0]) if len(coord) > 1 else 1.0
+        return coord[0] + idx * spacing
+
+    xcoord = np.asarray(raster.coords["x"].values)
+    ycoord = np.asarray(raster.coords["y"].values)
+    intrinsic = pd.DataFrame(
+        {
+            "x": _index_to_coord(props["centroid-1"], xcoord),
+            "y": _index_to_coord(props["centroid-0"], ycoord),
+        },
+        index=props["label"],
+    )
+    t = get_transformation(raster, coordinate_system)
+    points = PointsModel.parse(intrinsic, transformations={coordinate_system: t})
+    mapped = sd_transform(points, to_coordinate_system=coordinate_system).compute()
+    return mapped[["x", "y"]]
+
+
+def _compute_element_centroids(sdata: SpatialData, element_name: str, coordinate_system: str) -> pd.DataFrame:
+    """Compute one centroid per instance of a shapes/labels element.
+
+    Returns a DataFrame indexed by instance id (shape index / label value) with columns
+    ``["x", "y"]`` in ``coordinate_system``. Shapes use spatialdata's vectorized
+    ``get_centroids`` (already fast); labels use the regionprops path above.
+    """
+    element = sdata[element_name]
+    if get_model(element) is Labels2DModel:
+        return _compute_label_centroids(element, coordinate_system)
+    centroids = get_centroids(element, coordinate_system=coordinate_system).compute()
+    return centroids[["x", "y"]]
+
+
+def _read_cached_centroids(
+    sdata: SpatialData, element_name: str, table_name: str, coordinate_system: str
+) -> pd.DataFrame | None:
+    """Return centroids from the annotating table's ``obsm["spatial"]`` if usable, else None.
+
+    A pre-existing ``obsm["spatial"]`` (loader/user-provided) is trusted as the cells'
+    locations (squidpy convention). One that *we* wrote is reused only when our provenance
+    marker records the same coordinate system.
+    """
+    table = sdata.tables[table_name]
+    if _CENTROID_OBSM_KEY not in table.obsm:
+        return None
+    coords = np.asarray(table.obsm[_CENTROID_OBSM_KEY], dtype=float)
+    if coords.ndim != 2 or coords.shape[0] != table.n_obs or coords.shape[1] < 2:
+        return None
+    _, region_key, instance_key = get_table_keys(table)
+    mask = (table.obs[region_key].astype(str) == str(element_name)).to_numpy()
+    if not mask.any():
+        return None
+    region_coords = coords[mask][:, :2]
+    if np.isnan(region_coords).any():
+        return None  # not (fully) populated for this element
+    prov_root = table.uns.get(_CENTROID_PROVENANCE_UNS_KEY)
+    prov = prov_root.get("centroids", {}).get(element_name) if isinstance(prov_root, dict) else None
+    if prov is not None and prov.get("coordinate_system") != coordinate_system:
+        return None  # we cached it for a different coordinate system -> recompute
+    idx = table.obs[instance_key].to_numpy()[mask]
+    return pd.DataFrame({"x": region_coords[:, 0], "y": region_coords[:, 1]}, index=idx)
+
+
+def _write_cached_centroids(
+    sdata: SpatialData, element_name: str, table_name: str, coordinate_system: str, centroids: pd.DataFrame
+) -> None:
+    """Persist centroids into the annotating table's ``obsm["spatial"]`` + a provenance marker.
+
+    Fills only the rows belonging to ``element_name`` (a table may annotate several
+    elements); other rows are left NaN. Never clobbers an incompatible existing
+    ``obsm["spatial"]``. Callers run the read path first, so a valid existing cache is
+    reused rather than overwritten.
+    """
+    table = sdata.tables[table_name]
+    _, region_key, instance_key = get_table_keys(table)
+    mask = (table.obs[region_key].astype(str) == str(element_name)).to_numpy()
+    if not mask.any():
+        return
+    if _CENTROID_OBSM_KEY in table.obsm:
+        existing = np.asarray(table.obsm[_CENTROID_OBSM_KEY], dtype=float)
+        if existing.ndim != 2 or existing.shape != (table.n_obs, 2):
+            return  # don't clobber an incompatible obsm["spatial"]
+        arr = existing.copy()
+    else:
+        arr = np.full((table.n_obs, 2), np.nan, dtype=float)
+    aligned = centroids.reindex(table.obs[instance_key].to_numpy()[mask])
+    arr[mask, 0] = aligned["x"].to_numpy()
+    arr[mask, 1] = aligned["y"].to_numpy()
+    table.obsm[_CENTROID_OBSM_KEY] = arr
+    prov_root = table.uns.setdefault(_CENTROID_PROVENANCE_UNS_KEY, {})
+    if not isinstance(prov_root, dict):
+        return
+    prov_root.setdefault("centroids", {})[element_name] = {
+        "coordinate_system": coordinate_system,
+        "n": int(mask.sum()),
+        "key": _CENTROID_OBSM_KEY,
+    }
+
+
+def _get_or_compute_centroids(
+    sdata: SpatialData,
+    element_name: str,
+    *,
+    coordinate_system: str,
+    table_name: str | None = None,
+    cache: bool = True,
+) -> pd.DataFrame:
+    """Per-instance centroids, reusing/persisting them via the squidpy ``obsm["spatial"]`` convention.
+
+    If the annotating table already carries cell coordinates in ``obsm["spatial"]`` (loader-,
+    user-, or previously-cached for the same coordinate system), they are reused with no
+    recomputation. Otherwise centroids are computed and, when ``cache`` is True and an
+    annotating table exists, written back so later renders are instant.
+
+    Returns a DataFrame indexed by instance id with columns ``["x", "y"]``.
+    """
+    table = table_name if (table_name is not None and table_name in sdata.tables) else None
+    if table is not None:
+        cached = _read_cached_centroids(sdata, element_name, table, coordinate_system)
+        if cached is not None:
+            return cached
+    centroids = _compute_element_centroids(sdata, element_name, coordinate_system)
+    if cache and table is not None:
+        _write_cached_centroids(sdata, element_name, table, coordinate_system, centroids)
+    return centroids
diff --git a/tests/pl/test_utils.py b/tests/pl/test_utils.py
index 4a7c8a5b..1d7b9c67 100644
--- a/tests/pl/test_utils.py
+++ b/tests/pl/test_utils.py
@@ -5,6 +5,7 @@
 import pandas as pd
 import pytest
 import scanpy as sc
+import spatialdata as sd
 import xarray as xr
 from anndata import AnnData
 from shapely.geometry import Point
@@ -14,8 +15,13 @@
 import spatialdata_plot
 from spatialdata_plot.pl.render_params import Color, ColorLike
 from spatialdata_plot.pl.utils import (
+    _CENTROID_OBSM_KEY,
+    _CENTROID_PROVENANCE_UNS_KEY,
     _apply_cmap_alpha_to_datashader_result,
+    _compute_element_centroids,
     _datashader_map_aggregate_to_color,
+    _get_or_compute_centroids,
+    _read_cached_centroids,
     _set_outline,
     set_zero_in_cmap_to_transparent,
 )
@@ -496,3 +502,62 @@ def fake_rasterize(*args, **kwargs):
     assert captured["target_unit_to_pixels"] == pytest.approx(0.15, rel=1e-6), (
         f"Expected world-unit basis (0.15), got {captured['target_unit_to_pixels']}"
     )
+
+
+class TestCentroids:
+    """Centroid extraction + squidpy ``obsm['spatial']`` caching (no rendering)."""
+
+    def test_shapes_centroids_match_get_centroids(self, sdata_blobs: SpatialData):
+        mine = _compute_element_centroids(sdata_blobs, "blobs_circles", "global").sort_index()
+        ref = sd.get_centroids(sdata_blobs["blobs_circles"]).compute()[["x", "y"]].sort_index()
+        assert np.allclose(mine.values, ref.values)
+
+    def test_labels_centroids_match_get_centroids(self, sdata_blobs: SpatialData):
+        # regionprops path must reproduce spatialdata's exact center-of-mass (incl. the
+        # pixel-center 0.5 offset), just much faster.
+        mine = _compute_element_centroids(sdata_blobs, "blobs_labels", "global").sort_index()
+        ref = sd.get_centroids(sdata_blobs["blobs_labels"]).compute()[["x", "y"]].sort_index()
+        assert list(mine.index) == list(ref.index)
+        assert np.allclose(mine.values, ref.values, atol=1e-9)
+
+    def test_cache_round_trip_and_provenance(self, sdata_blobs: SpatialData):
+        table = sdata_blobs["table"]
+        assert _CENTROID_OBSM_KEY not in table.obsm
+        computed = _get_or_compute_centroids(
+            sdata_blobs, "blobs_labels", coordinate_system="global", table_name="table"
+        )
+        assert _CENTROID_OBSM_KEY in table.obsm
+        prov = table.uns[_CENTROID_PROVENANCE_UNS_KEY]["centroids"]["blobs_labels"]
+        assert prov["coordinate_system"] == "global"
+        assert prov["n"] == len(computed)
+        cached = _read_cached_centroids(sdata_blobs, "blobs_labels", "table", "global")
+        assert cached is not None
+        assert np.allclose(cached.sort_index().values, computed.sort_index().values)
+
+    def test_cache_invalidated_on_coordinate_system_change(self, sdata_blobs: SpatialData):
+        _get_or_compute_centroids(sdata_blobs, "blobs_labels", coordinate_system="global", table_name="table")
+        assert _read_cached_centroids(sdata_blobs, "blobs_labels", "table", "global") is not None
+        # cached for "global" must not be reused for a different coordinate system
+        assert _read_cached_centroids(sdata_blobs, "blobs_labels", "table", "other_cs") is None
+
+    def test_preexisting_obsm_spatial_is_trusted(self, sdata_blobs: SpatialData):
+        # a loader/user-provided obsm["spatial"] is used as the cells' locations (squidpy
+        # convention) without recomputation.
+        table = sdata_blobs["table"]
+        coords = np.arange(table.n_obs * 2, dtype=float).reshape(table.n_obs, 2)
+        table.obsm[_CENTROID_OBSM_KEY] = coords
+        got = _read_cached_centroids(sdata_blobs, "blobs_labels", "table", "global")
+        assert got is not None
+        assert len(got) == table.n_obs  # the whole table annotates this single region
+
+    def test_no_annotating_table_computes_without_caching(self, sdata_blobs: SpatialData):
+        # blobs_circles has no annotating table -> compute and return, no persistence.
+        centroids = _get_or_compute_centroids(sdata_blobs, "blobs_circles", coordinate_system="global", table_name=None)
+        assert list(centroids.columns) == ["x", "y"]
+        assert len(centroids) > 0
+
+    def test_cache_false_does_not_write(self, sdata_blobs: SpatialData):
+        _get_or_compute_centroids(
+            sdata_blobs, "blobs_labels", coordinate_system="global", table_name="table", cache=False
+        )
+        assert _CENTROID_OBSM_KEY not in sdata_blobs["table"].obsm

From 3bad4c096f7a4fa7854e0587235d88e5bd311fcf Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Mon, 8 Jun 2026 14:46:01 +0200
Subject: [PATCH 02/28] Simplify centroid cache: dedup region mask/keys, fix
 half-write, trim provenance

Cleanup from /simplify (no behavioral change):
- Extract `_region_mask_and_keys(table, element)` used by both read and write,
  removing the duplicated `get_table_keys` + O(n_obs) `region_key`-string-cast
  mask that was computed twice per cold call.
- Read path: validate shape on the raw obsm array and cast only the masked
  subset to float, instead of casting the whole `obsm["spatial"]` on every
  cache hit (the hot path).
- Write path: coerce a non-dict `uns["spatialdata_plot"]` instead of early
  returning after `obsm` was already mutated, so obsm and the provenance marker
  are always written together (no half-write).
- Drop the dead `"key"` provenance field (constant, never read back).
- Rename the misleading `table` local (held a table *name*) in
  `_get_or_compute_centroids`.
---
 src/spatialdata_plot/pl/utils.py | 39 +++++++++++++++++++-------------
 1 file changed, 23 insertions(+), 16 deletions(-)

diff --git a/src/spatialdata_plot/pl/utils.py b/src/spatialdata_plot/pl/utils.py
index 81b29a74..0d266a02 100644
--- a/src/spatialdata_plot/pl/utils.py
+++ b/src/spatialdata_plot/pl/utils.py
@@ -4490,6 +4490,13 @@ def _compute_element_centroids(sdata: SpatialData, element_name: str, coordinate
     return centroids[["x", "y"]]
 
 
+def _region_mask_and_keys(table: AnnData, element_name: str) -> tuple[str, ArrayLike]:
+    """Return ``(instance_key, mask)`` for the rows of ``table`` that annotate ``element_name``."""
+    _, region_key, instance_key = get_table_keys(table)
+    mask = (table.obs[region_key].astype(str) == str(element_name)).to_numpy()
+    return instance_key, mask
+
+
 def _read_cached_centroids(
     sdata: SpatialData, element_name: str, table_name: str, coordinate_system: str
 ) -> pd.DataFrame | None:
@@ -4502,14 +4509,13 @@ def _read_cached_centroids(
     table = sdata.tables[table_name]
     if _CENTROID_OBSM_KEY not in table.obsm:
         return None
-    coords = np.asarray(table.obsm[_CENTROID_OBSM_KEY], dtype=float)
+    coords = np.asarray(table.obsm[_CENTROID_OBSM_KEY])
     if coords.ndim != 2 or coords.shape[0] != table.n_obs or coords.shape[1] < 2:
         return None
-    _, region_key, instance_key = get_table_keys(table)
-    mask = (table.obs[region_key].astype(str) == str(element_name)).to_numpy()
+    instance_key, mask = _region_mask_and_keys(table, element_name)
     if not mask.any():
         return None
-    region_coords = coords[mask][:, :2]
+    region_coords = coords[mask][:, :2].astype(float)
     if np.isnan(region_coords).any():
         return None  # not (fully) populated for this element
     prov_root = table.uns.get(_CENTROID_PROVENANCE_UNS_KEY)
@@ -4531,28 +4537,29 @@ def _write_cached_centroids(
     reused rather than overwritten.
     """
     table = sdata.tables[table_name]
-    _, region_key, instance_key = get_table_keys(table)
-    mask = (table.obs[region_key].astype(str) == str(element_name)).to_numpy()
+    instance_key, mask = _region_mask_and_keys(table, element_name)
     if not mask.any():
         return
     if _CENTROID_OBSM_KEY in table.obsm:
-        existing = np.asarray(table.obsm[_CENTROID_OBSM_KEY], dtype=float)
+        existing = np.asarray(table.obsm[_CENTROID_OBSM_KEY])
         if existing.ndim != 2 or existing.shape != (table.n_obs, 2):
             return  # don't clobber an incompatible obsm["spatial"]
-        arr = existing.copy()
+        arr = existing.astype(float, copy=True)
     else:
         arr = np.full((table.n_obs, 2), np.nan, dtype=float)
     aligned = centroids.reindex(table.obs[instance_key].to_numpy()[mask])
     arr[mask, 0] = aligned["x"].to_numpy()
     arr[mask, 1] = aligned["y"].to_numpy()
     table.obsm[_CENTROID_OBSM_KEY] = arr
-    prov_root = table.uns.setdefault(_CENTROID_PROVENANCE_UNS_KEY, {})
+    # We own the `spatialdata_plot` uns namespace; coerce anything unexpected so obsm and
+    # the provenance marker are always written together (no half-write).
+    prov_root = table.uns.get(_CENTROID_PROVENANCE_UNS_KEY)
     if not isinstance(prov_root, dict):
-        return
+        prov_root = {}
+        table.uns[_CENTROID_PROVENANCE_UNS_KEY] = prov_root
     prov_root.setdefault("centroids", {})[element_name] = {
         "coordinate_system": coordinate_system,
         "n": int(mask.sum()),
-        "key": _CENTROID_OBSM_KEY,
     }
 
 
@@ -4573,12 +4580,12 @@ def _get_or_compute_centroids(
 
     Returns a DataFrame indexed by instance id with columns ``["x", "y"]``.
     """
-    table = table_name if (table_name is not None and table_name in sdata.tables) else None
-    if table is not None:
-        cached = _read_cached_centroids(sdata, element_name, table, coordinate_system)
+    resolved_table = table_name if (table_name is not None and table_name in sdata.tables) else None
+    if resolved_table is not None:
+        cached = _read_cached_centroids(sdata, element_name, resolved_table, coordinate_system)
         if cached is not None:
             return cached
     centroids = _compute_element_centroids(sdata, element_name, coordinate_system)
-    if cache and table is not None:
-        _write_cached_centroids(sdata, element_name, table, coordinate_system, centroids)
+    if cache and resolved_table is not None:
+        _write_cached_centroids(sdata, element_name, resolved_table, coordinate_system, centroids)
     return centroids

From 23da9bc8fd5023cbebf604489bc8529ec7db5a82 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Mon, 8 Jun 2026 15:35:23 +0200
Subject: [PATCH 03/28] Store centroids intrinsic
 (coordinate-system-independent cache)

Refactor the centroid cache to store element-*intrinsic* coordinates and
transform to the render coordinate system on demand, instead of caching
coords already mapped into one coordinate system. Decisions from design pass:

- Intrinsic storage: one `obsm["spatial"]` cache serves every coordinate
  system (proven equivalent to per-CS computation). `_compute_element_centroids`
  returns intrinsic coords (shapes via shapely `.centroid`, labels via
  `regionprops`); `_centroids_to_coordinate_system` maps them to the requested
  CS via the element's transform; `_get_or_compute_centroids` reads/computes
  intrinsic then transforms on return.
- Provenance records `{n, scale_level}` (no coordinate system). Cache is
  invalidated when the region's instance count changes (cells added/removed),
  not on CS change.
- A pre-existing `obsm["spatial"]` (loader/user-provided) is trusted as the
  cells' intrinsic locations and transformed to the render CS.
- Exhaustive model dispatch: shapes and 2D labels supported; other element
  types raise NotImplementedError.
- Labels are reduced at full resolution (scale0).

Drops the now-unused `get_centroids` import; adds `ShapesModel`. Tests updated:
parametrized shapes/labels match `get_centroids`; new coordinate-system-
independence test (one cache, two CS); staleness-by-instance-count; trusted
pre-existing obsm; unsupported-type rejection.
---
 src/spatialdata_plot/pl/utils.py | 145 +++++++++++++++++--------------
 tests/pl/test_utils.py           |  76 ++++++++++------
 2 files changed, 131 insertions(+), 90 deletions(-)

diff --git a/src/spatialdata_plot/pl/utils.py b/src/spatialdata_plot/pl/utils.py
index 0d266a02..6348c689 100644
--- a/src/spatialdata_plot/pl/utils.py
+++ b/src/spatialdata_plot/pl/utils.py
@@ -60,7 +60,6 @@
 from skimage.util import map_array
 from spatialdata import (
     SpatialData,
-    get_centroids,
     get_element_annotators,
     get_extent,
     get_values,
@@ -74,6 +73,7 @@
     Image2DModel,
     Labels2DModel,
     PointsModel,
+    ShapesModel,
     SpatialElement,
     get_model,
     get_table_keys,
@@ -4433,61 +4433,78 @@ def _convert_alpha_to_datashader_range(alpha: float) -> float:
 
 # squidpy/scanpy canonical key for per-cell coordinates: an N x 2 array, row-aligned to obs.
 _CENTROID_OBSM_KEY = "spatial"
-# Provenance marker so we know which element / coordinate system a cached `obsm["spatial"]`
-# was computed for, and can invalidate it when the requested coordinate system changes.
+# Our provenance namespace in `table.uns`. Centroids are stored in the element's *intrinsic*
+# coordinates (coordinate-system-independent), so the marker records the resolution level and
+# the instance count (to invalidate when cells are added/removed), not a coordinate system.
 _CENTROID_PROVENANCE_UNS_KEY = "spatialdata_plot"
+_CENTROID_SCALE_LEVEL = "scale0"  # labels are reduced at full resolution (decision: exact)
 
 
-def _compute_label_centroids(element: DataArray | DataTree, coordinate_system: str) -> pd.DataFrame:
-    """Per-label centroids via skimage ``regionprops`` + the element's coordinate transform.
+def _transformable_raster(element: DataArray | DataTree) -> DataArray:
+    """Return the raster level (``scale0`` for multiscale) carrying intrinsic coords + transforms."""
+    if isinstance(element, DataTree):
+        return next(iter(element[_CENTROID_SCALE_LEVEL].values()))
+    return element
+
 
-    ``regionprops`` does the per-label reduction in a single C pass, which is orders of
-    magnitude faster than ``spatialdata.get_centroids`` on labels (that scans the raster
-    row/column-wise and scales with raster area). The intrinsic pixel centroids are then
-    mapped into ``coordinate_system`` with spatialdata's own transform machinery.
+def _compute_label_centroids(element: DataArray | DataTree) -> pd.DataFrame:
+    """Per-label centroids in the element's *intrinsic* coordinates via skimage ``regionprops``.
+
+    ``regionprops`` does the per-label reduction in a single C pass, orders of magnitude
+    faster than ``spatialdata.get_centroids`` on labels (which scans the raster row/column-wise
+    and scales with raster area). Returns intrinsic coords; the caller maps them to a target
+    coordinate system on demand.
     """
-    raster = element
-    if isinstance(element, DataTree):
-        # full-resolution level, matching spatialdata.get_centroids
-        raster = next(iter(element["scale0"].values()))
+    raster = _transformable_raster(element)
     values = np.asarray(raster.data)  # materialize the intrinsic pixel grid
     props = regionprops_table(values, properties=("label", "centroid"))
 
     # regionprops excludes background (label 0); centroid-0 = row (y), centroid-1 = col (x)
     # as 0-based fractional indices. Map them onto the raster's intrinsic coordinate arrays
-    # (spatialdata uses pixel-center coords 0.5, 1.5, ... and possibly non-unit spacing),
-    # which reproduces spatialdata.get_centroids exactly.
+    # (spatialdata uses pixel-center coords 0.5, 1.5, ... and possibly non-unit spacing).
     def _index_to_coord(idx: ArrayLike, coord: ArrayLike) -> ArrayLike:
         spacing = (coord[1] - coord[0]) if len(coord) > 1 else 1.0
         return coord[0] + idx * spacing
 
     xcoord = np.asarray(raster.coords["x"].values)
     ycoord = np.asarray(raster.coords["y"].values)
-    intrinsic = pd.DataFrame(
+    return pd.DataFrame(
         {
             "x": _index_to_coord(props["centroid-1"], xcoord),
             "y": _index_to_coord(props["centroid-0"], ycoord),
         },
         index=props["label"],
     )
-    t = get_transformation(raster, coordinate_system)
-    points = PointsModel.parse(intrinsic, transformations={coordinate_system: t})
-    mapped = sd_transform(points, to_coordinate_system=coordinate_system).compute()
-    return mapped[["x", "y"]]
 
 
-def _compute_element_centroids(sdata: SpatialData, element_name: str, coordinate_system: str) -> pd.DataFrame:
-    """Compute one centroid per instance of a shapes/labels element.
+def _compute_element_centroids(sdata: SpatialData, element_name: str) -> pd.DataFrame:
+    """One centroid per instance of a shapes/labels element, in the element's intrinsic coords.
 
     Returns a DataFrame indexed by instance id (shape index / label value) with columns
-    ``["x", "y"]`` in ``coordinate_system``. Shapes use spatialdata's vectorized
-    ``get_centroids`` (already fast); labels use the regionprops path above.
+    ``["x", "y"]``. Shapes use shapely's vectorized ``.centroid``; labels use ``regionprops``.
+    Other element types are rejected explicitly.
     """
     element = sdata[element_name]
-    if get_model(element) is Labels2DModel:
-        return _compute_label_centroids(element, coordinate_system)
-    centroids = get_centroids(element, coordinate_system=coordinate_system).compute()
-    return centroids[["x", "y"]]
+    model = get_model(element)
+    if model is ShapesModel:
+        centroids = element.geometry.centroid
+        return pd.DataFrame({"x": centroids.x.to_numpy(), "y": centroids.y.to_numpy()}, index=element.index)
+    if model is Labels2DModel:
+        return _compute_label_centroids(element)
+    raise NotImplementedError(
+        f"Centroid extraction is only supported for shapes and 2D labels; "
+        f"element {element_name!r} is a {model.__name__}."
+    )
+
+
+def _centroids_to_coordinate_system(
+    intrinsic: pd.DataFrame, element: SpatialElement, coordinate_system: str
+) -> pd.DataFrame:
+    """Map intrinsic centroids to ``coordinate_system`` via the element's transform (preserves index)."""
+    target = _transformable_raster(element) if isinstance(element, DataArray | DataTree) else element
+    t = get_transformation(target, coordinate_system)
+    points = PointsModel.parse(intrinsic, transformations={coordinate_system: t})
+    return sd_transform(points, to_coordinate_system=coordinate_system).compute()[["x", "y"]]
 
 
 def _region_mask_and_keys(table: AnnData, element_name: str) -> tuple[str, ArrayLike]:
@@ -4497,14 +4514,21 @@ def _region_mask_and_keys(table: AnnData, element_name: str) -> tuple[str, Array
     return instance_key, mask
 
 
-def _read_cached_centroids(
-    sdata: SpatialData, element_name: str, table_name: str, coordinate_system: str
-) -> pd.DataFrame | None:
-    """Return centroids from the annotating table's ``obsm["spatial"]`` if usable, else None.
+def _centroid_provenance(table: AnnData, element_name: str) -> dict[str, Any] | None:
+    """Our centroid provenance marker for ``element_name``, or None if absent/malformed."""
+    root = table.uns.get(_CENTROID_PROVENANCE_UNS_KEY)
+    if not isinstance(root, dict):
+        return None
+    marker = root.get("centroids", {}).get(element_name)
+    return marker if isinstance(marker, dict) else None
+
 
-    A pre-existing ``obsm["spatial"]`` (loader/user-provided) is trusted as the cells'
-    locations (squidpy convention). One that *we* wrote is reused only when our provenance
-    marker records the same coordinate system.
+def _read_cached_centroids(sdata: SpatialData, element_name: str, table_name: str) -> pd.DataFrame | None:
+    """Return *intrinsic* centroids from the annotating table's ``obsm["spatial"]`` if usable.
+
+    A pre-existing ``obsm["spatial"]`` (loader/user-provided) is trusted as the cells' intrinsic
+    locations (squidpy convention). One that *we* wrote is reused only while its recorded
+    instance count still matches the table (so adding/removing cells invalidates it).
     """
     table = sdata.tables[table_name]
     if _CENTROID_OBSM_KEY not in table.obsm:
@@ -4518,23 +4542,19 @@ def _read_cached_centroids(
     region_coords = coords[mask][:, :2].astype(float)
     if np.isnan(region_coords).any():
         return None  # not (fully) populated for this element
-    prov_root = table.uns.get(_CENTROID_PROVENANCE_UNS_KEY)
-    prov = prov_root.get("centroids", {}).get(element_name) if isinstance(prov_root, dict) else None
-    if prov is not None and prov.get("coordinate_system") != coordinate_system:
-        return None  # we cached it for a different coordinate system -> recompute
+    prov = _centroid_provenance(table, element_name)
+    if prov is not None and prov.get("n") != int(mask.sum()):
+        return None  # cells added/removed since we cached -> recompute
     idx = table.obs[instance_key].to_numpy()[mask]
     return pd.DataFrame({"x": region_coords[:, 0], "y": region_coords[:, 1]}, index=idx)
 
 
-def _write_cached_centroids(
-    sdata: SpatialData, element_name: str, table_name: str, coordinate_system: str, centroids: pd.DataFrame
-) -> None:
-    """Persist centroids into the annotating table's ``obsm["spatial"]`` + a provenance marker.
+def _write_cached_centroids(sdata: SpatialData, element_name: str, table_name: str, centroids: pd.DataFrame) -> None:
+    """Persist *intrinsic* centroids into the annotating table's ``obsm["spatial"]`` + provenance.
 
-    Fills only the rows belonging to ``element_name`` (a table may annotate several
-    elements); other rows are left NaN. Never clobbers an incompatible existing
-    ``obsm["spatial"]``. Callers run the read path first, so a valid existing cache is
-    reused rather than overwritten.
+    Fills only the rows belonging to ``element_name`` (a table may annotate several elements);
+    other rows are left NaN. Never clobbers an incompatible existing ``obsm["spatial"]``.
+    Callers run the read path first, so a valid existing cache is reused rather than overwritten.
     """
     table = sdata.tables[table_name]
     instance_key, mask = _region_mask_and_keys(table, element_name)
@@ -4551,15 +4571,15 @@ def _write_cached_centroids(
     arr[mask, 0] = aligned["x"].to_numpy()
     arr[mask, 1] = aligned["y"].to_numpy()
     table.obsm[_CENTROID_OBSM_KEY] = arr
-    # We own the `spatialdata_plot` uns namespace; coerce anything unexpected so obsm and
-    # the provenance marker are always written together (no half-write).
+    # We own the `spatialdata_plot` uns namespace; coerce anything unexpected so obsm and the
+    # provenance marker are always written together (no half-write).
     prov_root = table.uns.get(_CENTROID_PROVENANCE_UNS_KEY)
     if not isinstance(prov_root, dict):
         prov_root = {}
         table.uns[_CENTROID_PROVENANCE_UNS_KEY] = prov_root
     prov_root.setdefault("centroids", {})[element_name] = {
-        "coordinate_system": coordinate_system,
         "n": int(mask.sum()),
+        "scale_level": _CENTROID_SCALE_LEVEL,
     }
 
 
@@ -4571,21 +4591,20 @@ def _get_or_compute_centroids(
     table_name: str | None = None,
     cache: bool = True,
 ) -> pd.DataFrame:
-    """Per-instance centroids, reusing/persisting them via the squidpy ``obsm["spatial"]`` convention.
+    """Per-instance centroids in ``coordinate_system``, cached via the squidpy ``obsm["spatial"]`` convention.
 
-    If the annotating table already carries cell coordinates in ``obsm["spatial"]`` (loader-,
-    user-, or previously-cached for the same coordinate system), they are reused with no
-    recomputation. Otherwise centroids are computed and, when ``cache`` is True and an
-    annotating table exists, written back so later renders are instant.
+    Centroids are stored intrinsic (coordinate-system-independent) and transformed to
+    ``coordinate_system`` on return, so one cache serves every coordinate system. If the
+    annotating table already carries cell coordinates in ``obsm["spatial"]`` (loader-, user-,
+    or previously cached), they are reused with no recomputation; otherwise centroids are
+    computed and, when ``cache`` is True and an annotating table exists, written back.
 
     Returns a DataFrame indexed by instance id with columns ``["x", "y"]``.
     """
     resolved_table = table_name if (table_name is not None and table_name in sdata.tables) else None
-    if resolved_table is not None:
-        cached = _read_cached_centroids(sdata, element_name, resolved_table, coordinate_system)
-        if cached is not None:
-            return cached
-    centroids = _compute_element_centroids(sdata, element_name, coordinate_system)
-    if cache and resolved_table is not None:
-        _write_cached_centroids(sdata, element_name, resolved_table, coordinate_system, centroids)
-    return centroids
+    intrinsic = _read_cached_centroids(sdata, element_name, resolved_table) if resolved_table is not None else None
+    if intrinsic is None:
+        intrinsic = _compute_element_centroids(sdata, element_name)
+        if cache and resolved_table is not None:
+            _write_cached_centroids(sdata, element_name, resolved_table, intrinsic)
+    return _centroids_to_coordinate_system(intrinsic, sdata[element_name], coordinate_system)
diff --git a/tests/pl/test_utils.py b/tests/pl/test_utils.py
index 1d7b9c67..d5e51a64 100644
--- a/tests/pl/test_utils.py
+++ b/tests/pl/test_utils.py
@@ -507,48 +507,70 @@ def fake_rasterize(*args, **kwargs):
 class TestCentroids:
     """Centroid extraction + squidpy ``obsm['spatial']`` caching (no rendering)."""
 
-    def test_shapes_centroids_match_get_centroids(self, sdata_blobs: SpatialData):
-        mine = _compute_element_centroids(sdata_blobs, "blobs_circles", "global").sort_index()
-        ref = sd.get_centroids(sdata_blobs["blobs_circles"]).compute()[["x", "y"]].sort_index()
-        assert np.allclose(mine.values, ref.values)
-
-    def test_labels_centroids_match_get_centroids(self, sdata_blobs: SpatialData):
-        # regionprops path must reproduce spatialdata's exact center-of-mass (incl. the
-        # pixel-center 0.5 offset), just much faster.
-        mine = _compute_element_centroids(sdata_blobs, "blobs_labels", "global").sort_index()
-        ref = sd.get_centroids(sdata_blobs["blobs_labels"]).compute()[["x", "y"]].sort_index()
+    @pytest.mark.parametrize(("element", "table_name"), [("blobs_circles", None), ("blobs_labels", "table")])
+    def test_centroids_match_get_centroids(self, sdata_blobs: SpatialData, element: str, table_name: str | None):
+        # shapes via shapely .centroid, labels via regionprops (incl. the pixel-center 0.5
+        # offset) -> identical to spatialdata's exact centroids, just faster.
+        mine = _get_or_compute_centroids(
+            sdata_blobs, element, coordinate_system="global", table_name=table_name
+        ).sort_index()
+        ref = sd.get_centroids(sdata_blobs[element], coordinate_system="global").compute()[["x", "y"]].sort_index()
         assert list(mine.index) == list(ref.index)
         assert np.allclose(mine.values, ref.values, atol=1e-9)
 
+    def test_cache_is_coordinate_system_independent(self, sdata_blobs: SpatialData):
+        # one intrinsic cache serves every coordinate system: add a second CS and confirm both
+        # match get_centroids while only one obsm["spatial"] is written.
+        from spatialdata.transformations import Scale, set_transformation
+
+        set_transformation(
+            sdata_blobs["blobs_labels"], Scale([2.0, 3.0], axes=("x", "y")), to_coordinate_system="scaled"
+        )
+        g = _get_or_compute_centroids(
+            sdata_blobs, "blobs_labels", coordinate_system="global", table_name="table"
+        ).sort_index()
+        s = _get_or_compute_centroids(
+            sdata_blobs, "blobs_labels", coordinate_system="scaled", table_name="table"
+        ).sort_index()
+        assert _CENTROID_OBSM_KEY in sdata_blobs["table"].obsm  # cached once, reused for both
+        ref_g = sd.get_centroids(sdata_blobs["blobs_labels"], coordinate_system="global").compute()[["x", "y"]]
+        ref_s = sd.get_centroids(sdata_blobs["blobs_labels"], coordinate_system="scaled").compute()[["x", "y"]]
+        assert np.allclose(g.values, ref_g.sort_index().values, atol=1e-9)
+        assert np.allclose(s.values, ref_s.sort_index().values, atol=1e-9)
+        assert not np.allclose(ref_g.values, ref_s.values)  # the coordinate system genuinely matters
+
     def test_cache_round_trip_and_provenance(self, sdata_blobs: SpatialData):
         table = sdata_blobs["table"]
         assert _CENTROID_OBSM_KEY not in table.obsm
-        computed = _get_or_compute_centroids(
-            sdata_blobs, "blobs_labels", coordinate_system="global", table_name="table"
-        )
-        assert _CENTROID_OBSM_KEY in table.obsm
+        out = _get_or_compute_centroids(sdata_blobs, "blobs_labels", coordinate_system="global", table_name="table")
+        assert _CENTROID_OBSM_KEY in table.obsm  # intrinsic centroids cached
         prov = table.uns[_CENTROID_PROVENANCE_UNS_KEY]["centroids"]["blobs_labels"]
-        assert prov["coordinate_system"] == "global"
-        assert prov["n"] == len(computed)
-        cached = _read_cached_centroids(sdata_blobs, "blobs_labels", "table", "global")
-        assert cached is not None
-        assert np.allclose(cached.sort_index().values, computed.sort_index().values)
+        assert prov["n"] == len(out)
+        assert prov["scale_level"] == "scale0"
+        assert "coordinate_system" not in prov  # the cache is coordinate-system-independent
+        again = _get_or_compute_centroids(sdata_blobs, "blobs_labels", coordinate_system="global", table_name="table")
+        assert np.allclose(again.sort_index().values, out.sort_index().values)
 
-    def test_cache_invalidated_on_coordinate_system_change(self, sdata_blobs: SpatialData):
+    def test_cache_invalidated_on_instance_count_change(self, sdata_blobs: SpatialData):
         _get_or_compute_centroids(sdata_blobs, "blobs_labels", coordinate_system="global", table_name="table")
-        assert _read_cached_centroids(sdata_blobs, "blobs_labels", "table", "global") is not None
-        # cached for "global" must not be reused for a different coordinate system
-        assert _read_cached_centroids(sdata_blobs, "blobs_labels", "table", "other_cs") is None
+        assert _read_cached_centroids(sdata_blobs, "blobs_labels", "table") is not None
+        # simulate cells added/removed: the recorded instance count no longer matches the table.
+        sdata_blobs["table"].uns[_CENTROID_PROVENANCE_UNS_KEY]["centroids"]["blobs_labels"]["n"] += 1
+        assert _read_cached_centroids(sdata_blobs, "blobs_labels", "table") is None
 
     def test_preexisting_obsm_spatial_is_trusted(self, sdata_blobs: SpatialData):
-        # a loader/user-provided obsm["spatial"] is used as the cells' locations (squidpy
-        # convention) without recomputation.
+        # a loader/user-provided obsm["spatial"] (no provenance) is trusted as the cells'
+        # intrinsic locations without recomputation.
         table = sdata_blobs["table"]
         coords = np.arange(table.n_obs * 2, dtype=float).reshape(table.n_obs, 2)
         table.obsm[_CENTROID_OBSM_KEY] = coords
-        got = _read_cached_centroids(sdata_blobs, "blobs_labels", "table", "global")
+        got = _read_cached_centroids(sdata_blobs, "blobs_labels", "table")
         assert got is not None
-        assert len(got) == table.n_obs  # the whole table annotates this single region
+        assert np.allclose(got.values, coords)  # whole table = this one region, order preserved
+
+    def test_unsupported_element_type_raises(self, sdata_blobs: SpatialData):
+        with pytest.raises(NotImplementedError, match="shapes and 2D labels"):
+            _compute_element_centroids(sdata_blobs, "blobs_points")
 
     def test_no_annotating_table_computes_without_caching(self, sdata_blobs: SpatialData):
         # blobs_circles has no annotating table -> compute and return, no persistence.

From 40d8cef54336e483a7bc6d23dff2aa9afdc16061 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Mon, 8 Jun 2026 15:47:56 +0200
Subject: [PATCH 04/28] Simplify centroids: numpy-affine transform on cache
 hits, drop private import, shared obsm gate
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Cleanup from /simplify:
- `_centroids_to_coordinate_system` ran `PointsModel.parse` + a dask
  `transform(...).compute()` round trip on every call, including cache hits
  (~19 ms fixed floor, ~100 ms at 1M cells) — defeating the cache. Replace with
  `to_affine_matrix` + a plain numpy matmul: numerically identical (verified
  against the dask path for multiple coordinate systems), ~80-140x faster, and
  it removes the private-API import `spatialdata._core.operations.transform`
  (a repo non-negotiable) plus the now-unused `PointsModel`.
- Widen `_transformable_raster` -> `_transform_carrier` to accept any element
  (rasters -> scale0, others as-is), dropping the `isinstance` branch in
  `_centroids_to_coordinate_system`.
- Extract `_valid_spatial_obsm(arr, n_obs)` shared by the read and write paths,
  reconciling their previously divergent obsm-shape checks (read accepted >=2
  columns, write required exactly 2) so they cannot drift.
---
 src/spatialdata_plot/pl/utils.py | 37 +++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 13 deletions(-)

diff --git a/src/spatialdata_plot/pl/utils.py b/src/spatialdata_plot/pl/utils.py
index 6348c689..78cb7301 100644
--- a/src/spatialdata_plot/pl/utils.py
+++ b/src/spatialdata_plot/pl/utils.py
@@ -66,13 +66,11 @@
     join_spatialelement_table,
     rasterize,
 )
-from spatialdata._core.operations.transform import transform as sd_transform
 from spatialdata._core.query.relational_query import _locate_value
 from spatialdata._types import ArrayLike
 from spatialdata.models import (
     Image2DModel,
     Labels2DModel,
-    PointsModel,
     ShapesModel,
     SpatialElement,
     get_model,
@@ -4440,8 +4438,8 @@ def _convert_alpha_to_datashader_range(alpha: float) -> float:
 _CENTROID_SCALE_LEVEL = "scale0"  # labels are reduced at full resolution (decision: exact)
 
 
-def _transformable_raster(element: DataArray | DataTree) -> DataArray:
-    """Return the raster level (``scale0`` for multiscale) carrying intrinsic coords + transforms."""
+def _transform_carrier(element: SpatialElement) -> Any:
+    """Return the object carrying ``element``'s transforms (the ``scale0`` level for multiscale rasters)."""
     if isinstance(element, DataTree):
         return next(iter(element[_CENTROID_SCALE_LEVEL].values()))
     return element
@@ -4455,7 +4453,7 @@ def _compute_label_centroids(element: DataArray | DataTree) -> pd.DataFrame:
     and scales with raster area). Returns intrinsic coords; the caller maps them to a target
     coordinate system on demand.
     """
-    raster = _transformable_raster(element)
+    raster = _transform_carrier(element)
     values = np.asarray(raster.data)  # materialize the intrinsic pixel grid
     props = regionprops_table(values, properties=("label", "centroid"))
 
@@ -4500,11 +4498,16 @@ def _compute_element_centroids(sdata: SpatialData, element_name: str) -> pd.Data
 def _centroids_to_coordinate_system(
     intrinsic: pd.DataFrame, element: SpatialElement, coordinate_system: str
 ) -> pd.DataFrame:
-    """Map intrinsic centroids to ``coordinate_system`` via the element's transform (preserves index)."""
-    target = _transformable_raster(element) if isinstance(element, DataArray | DataTree) else element
-    t = get_transformation(target, coordinate_system)
-    points = PointsModel.parse(intrinsic, transformations={coordinate_system: t})
-    return sd_transform(points, to_coordinate_system=coordinate_system).compute()[["x", "y"]]
+    """Map intrinsic centroids to ``coordinate_system`` via the element's affine transform.
+
+    Applies the transform as a plain numpy matmul rather than a ``PointsModel`` + dask round
+    trip — this runs on every render (including cache hits), so the dask overhead would defeat
+    the cache. Preserves the instance-id index.
+    """
+    t = get_transformation(_transform_carrier(element), coordinate_system)
+    matrix = t.to_affine_matrix(input_axes=("x", "y"), output_axes=("x", "y"))
+    xy = intrinsic[["x", "y"]].to_numpy() @ matrix[:2, :2].T + matrix[:2, 2]
+    return pd.DataFrame({"x": xy[:, 0], "y": xy[:, 1]}, index=intrinsic.index)
 
 
 def _region_mask_and_keys(table: AnnData, element_name: str) -> tuple[str, ArrayLike]:
@@ -4514,6 +4517,14 @@ def _region_mask_and_keys(table: AnnData, element_name: str) -> tuple[str, Array
     return instance_key, mask
 
 
+def _valid_spatial_obsm(arr: ArrayLike, n_obs: int) -> bool:
+    """Whether ``arr`` is a usable ``obsm["spatial"]``: a 2D ``(n_obs, 2)`` coordinate grid.
+
+    Read and write share this gate so they cannot drift on the obsm layout.
+    """
+    return bool(arr.ndim == 2 and arr.shape == (n_obs, 2))
+
+
 def _centroid_provenance(table: AnnData, element_name: str) -> dict[str, Any] | None:
     """Our centroid provenance marker for ``element_name``, or None if absent/malformed."""
     root = table.uns.get(_CENTROID_PROVENANCE_UNS_KEY)
@@ -4534,12 +4545,12 @@ def _read_cached_centroids(sdata: SpatialData, element_name: str, table_name: st
     if _CENTROID_OBSM_KEY not in table.obsm:
         return None
     coords = np.asarray(table.obsm[_CENTROID_OBSM_KEY])
-    if coords.ndim != 2 or coords.shape[0] != table.n_obs or coords.shape[1] < 2:
+    if not _valid_spatial_obsm(coords, table.n_obs):
         return None
     instance_key, mask = _region_mask_and_keys(table, element_name)
     if not mask.any():
         return None
-    region_coords = coords[mask][:, :2].astype(float)
+    region_coords = coords[mask].astype(float)
     if np.isnan(region_coords).any():
         return None  # not (fully) populated for this element
     prov = _centroid_provenance(table, element_name)
@@ -4562,7 +4573,7 @@ def _write_cached_centroids(sdata: SpatialData, element_name: str, table_name: s
         return
     if _CENTROID_OBSM_KEY in table.obsm:
         existing = np.asarray(table.obsm[_CENTROID_OBSM_KEY])
-        if existing.ndim != 2 or existing.shape != (table.n_obs, 2):
+        if not _valid_spatial_obsm(existing, table.n_obs):
             return  # don't clobber an incompatible obsm["spatial"]
         arr = existing.astype(float, copy=True)
     else:

From fc3af02115e0d8d0b99cbeeea6b7bdd2cf1f5c2a Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Mon, 8 Jun 2026 16:08:43 +0200
Subject: [PATCH 05/28] Add as_points fast mode: render shapes/labels as
 centroid dots
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`render_shapes(..., as_points=True)` and `render_labels(..., as_points=True)`
draw one dot per cell at its centroid instead of the full geometry / rasterized
mask — a large speedup when only cell location matters. New `size=` controls the
marker size.

- Shared `_render_centroids_as_points` draws the scatter (via `_scatter_points`)
  and the legend/colorbar. The per-cell color vector is the *same* one the
  geometry/raster path computes (`_set_color_source_vec`), so colors match the
  full rendering exactly; only the apply step (scatter vs patches/imshow) differs.
- Shapes: centroids from shapely `.centroid` of the (filtered) geometry,
  positionally aligned to the color vector, drawn in intrinsic coords via the
  element transform. Labels: centroids from `_get_or_compute_centroids`
  (regionprops, fast) reindexed to `instance_id`. Positions verified identical to
  `sd.get_centroids`.
- `as_points` short-circuits before the geometry/raster path; outline_*, shape
  (shapes) and contour_px, outline_* (labels) are ignored with an info log.
- Default (`as_points=False`) output is byte-identical to main.

Tests: non-visual checks that centroids land exactly on `get_centroids` for both
element types and that outline/shape are ignored without error.

Note: as_points currently always uses the matplotlib scatter backend; routing
through datashader for very large cell counts (and persisting the obsm cache to
the user's object rather than show()'s working copy) are follow-ups.
---
 src/spatialdata_plot/pl/basic.py         |   8 ++
 src/spatialdata_plot/pl/render.py        | 111 +++++++++++++++++++++++
 src/spatialdata_plot/pl/render_params.py |   6 ++
 tests/pl/test_render_labels.py           |  14 +++
 tests/pl/test_render_shapes.py           |  24 +++++
 5 files changed, 163 insertions(+)

diff --git a/src/spatialdata_plot/pl/basic.py b/src/spatialdata_plot/pl/basic.py
index f864482c..1d2f409b 100644
--- a/src/spatialdata_plot/pl/basic.py
+++ b/src/spatialdata_plot/pl/basic.py
@@ -332,6 +332,8 @@ def render_shapes(
         colorbar_params: dict[str, object] | None = None,
         datashader_reduction: _DsReduction | None = None,
         transfunc: Callable[[float], float] | None = None,
+        as_points: bool = False,
+        size: float | int = 1.0,
     ) -> sd.SpatialData:
         """
         Render shapes elements in SpatialData.
@@ -515,6 +517,8 @@ def render_shapes(
                     ds_reduction=param_values["ds_reduction"],
                     colorbar=param_values["colorbar"],
                     colorbar_params=param_values["colorbar_params"],
+                    as_points=as_points,
+                    size=size,
                     panel_key=panel_key,
                 )
                 n_steps += 1
@@ -953,6 +957,8 @@ def render_labels(
         table_layer: str | None = None,
         gene_symbols: str | None = None,
         transfunc: Callable[[float], float] | None = None,
+        as_points: bool = False,
+        size: float | int = 1.0,
     ) -> sd.SpatialData:
         """
         Render labels elements in SpatialData.
@@ -1101,6 +1107,8 @@ def render_labels(
                     zorder=n_steps,
                     colorbar=param_values["colorbar"],
                     colorbar_params=param_values["colorbar_params"],
+                    as_points=as_points,
+                    size=size,
                     panel_key=panel_key,
                 )
                 n_steps += 1
diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index 160b4087..9ebf625a 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -70,6 +70,7 @@
     _get_colors_for_categorical_obs,
     _get_extent_and_range_for_datashader_canvas,
     _get_linear_colormap,
+    _get_or_compute_centroids,
     _hex_no_alpha,
     _join_table_for_element,
     _make_continuous_mappable,
@@ -751,6 +752,35 @@ def _render_shapes(
         color_source_vector = color_source_vector.remove_unused_categories()
 
     shapes = gpd.GeoDataFrame(shapes, geometry="geometry")
+
+    if render_params.as_points:
+        # Fast mode: draw one dot per shape at its centroid instead of its geometry.
+        logger.info("`as_points=True`: rendering shape centroids; `outline_*` and `shape` are ignored.")
+        centroids = shapes.geometry.centroid  # intrinsic coords, positionally aligned to color_vector
+        _render_centroids_as_points(
+            ax,
+            x=centroids.x.to_numpy(),
+            y=centroids.y.to_numpy(),
+            color_vector=color_vector,
+            color_source_vector=color_source_vector,
+            cmap=render_params.cmap_params.cmap,
+            norm=norm,
+            na_color=render_params.cmap_params.na_color,
+            size=render_params.size,
+            alpha=render_params.fill_alpha,
+            zorder=render_params.zorder,
+            transform=trans_data,  # intrinsic -> coordinate system -> display
+            adata=table,
+            col_for_color=col_for_color,
+            palette=palette,
+            fig_params=fig_params,
+            legend_params=legend_params,
+            colorbar=render_params.colorbar,
+            colorbar_params=render_params.colorbar_params,
+            colorbar_requests=colorbar_requests,
+        )
+        return
+
     # convert shapes if necessary
     if render_params.shape is not None:
         current_type = shapes["geometry"].type
@@ -1086,6 +1116,55 @@ def _scatter_points(
     )
 
 
+def _render_centroids_as_points(
+    ax: matplotlib.axes.SubplotBase,
+    *,
+    x: Any,
+    y: Any,
+    color_vector: Any,
+    color_source_vector: pd.Series | None,
+    cmap: Colormap,
+    norm: Normalize | None,
+    na_color: Any,
+    size: float,
+    alpha: float,
+    zorder: int,
+    transform: Any,
+    adata: AnnData | None,
+    col_for_color: str | None,
+    palette: Any,
+    fig_params: FigParams,
+    legend_params: LegendParams,
+    colorbar: bool | str | None,
+    colorbar_params: dict[str, object] | None,
+    colorbar_requests: list[ColorbarSpec] | None,
+) -> None:
+    """Render one dot per cell at ``(x, y)`` colored like the fill, with legend/colorbar.
+
+    Shared "fast mode" draw for shapes/labels: ``color_vector`` is the same per-instance color
+    vector the geometry/raster path would use, so colors match the full rendering exactly.
+    """
+    cax = _scatter_points(
+        ax, x, y, color_vector, size=size, cmap=cmap, norm=norm, alpha=alpha, trans_data=transform, zorder=zorder
+    )
+    _add_legend_and_colorbar(
+        ax=ax,
+        cax=cax,
+        fig_params=fig_params,
+        adata=adata,
+        col_for_color=col_for_color,
+        color_source_vector=color_source_vector,
+        color_vector=color_vector,
+        palette=palette,
+        alpha=alpha,
+        na_color=na_color,
+        legend_params=legend_params,
+        colorbar=colorbar,
+        colorbar_params=colorbar_params,
+        colorbar_requests=colorbar_requests,
+    )
+
+
 def _render_points(
     sdata: sd.SpatialData,
     render_params: PointsRenderParams,
@@ -2272,6 +2351,38 @@ def _render_labels(
     if color_source_vector is None and render_params.transfunc is not None:
         color_vector = render_params.transfunc(color_vector)
 
+    if render_params.as_points:
+        # Fast mode: draw one dot per label at its centroid instead of the mask. Centroids come
+        # from `regionprops` (orders of magnitude faster than rasterizing) in coordinate-system
+        # coords, aligned to `instance_id` (and thus to `color_vector`).
+        logger.info("`as_points=True`: rendering label centroids; `contour_px` and `outline_*` are ignored.")
+        centroids = _get_or_compute_centroids(
+            sdata_filt, element, coordinate_system=coordinate_system, table_name=table_name
+        ).reindex(instance_id)
+        _render_centroids_as_points(
+            ax,
+            x=centroids["x"].to_numpy(),
+            y=centroids["y"].to_numpy(),
+            color_vector=color_vector,
+            color_source_vector=color_source_vector,
+            cmap=render_params.cmap_params.cmap,
+            norm=render_params.cmap_params.norm,
+            na_color=na_color,
+            size=render_params.size,
+            alpha=render_params.fill_alpha,
+            zorder=render_params.zorder,
+            transform=ax.transData,  # centroids already in coordinate-system (= axes data) space
+            adata=table if table_name is not None else None,
+            col_for_color=col_for_color,
+            palette=palette,
+            fig_params=fig_params,
+            legend_params=legend_params,
+            colorbar=render_params.colorbar,
+            colorbar_params=render_params.colorbar_params,
+            colorbar_requests=colorbar_requests,
+        )
+        return
+
     def _draw_labels(
         seg_erosionpx: int | None,
         seg_boundaries: bool,
diff --git a/src/spatialdata_plot/pl/render_params.py b/src/spatialdata_plot/pl/render_params.py
index b021c305..748735b7 100644
--- a/src/spatialdata_plot/pl/render_params.py
+++ b/src/spatialdata_plot/pl/render_params.py
@@ -253,6 +253,9 @@ class ShapesRenderParams:
     table_name: str | None = None
     table_layer: str | None = None
     shape: Literal["circle", "hex", "visium_hex", "square"] | None = None
+    # Fast mode: render each shape as a single dot at its centroid instead of its geometry.
+    as_points: bool = False
+    size: float = 1.0  # marker size for as_points (matplotlib scatter ``s``)
     ds_reduction: _DsReduction | None = None
     colorbar: bool | str | None = "auto"
     colorbar_params: dict[str, object] | None = None
@@ -328,6 +331,9 @@ class LabelsRenderParams:
     zorder: int = 0
     colorbar: bool | str | None = "auto"
     colorbar_params: dict[str, object] | None = None
+    # Fast mode: render each label as a single dot at its centroid instead of the mask.
+    as_points: bool = False
+    size: float = 1.0  # marker size for as_points (matplotlib scatter ``s``)
     # Multi-panel color: when set, this render entry belongs to the panel identified by this
     # color key. ``None`` means the entry is shared across every panel (e.g. a background layer).
     panel_key: str | None = None
diff --git a/tests/pl/test_render_labels.py b/tests/pl/test_render_labels.py
index 1babf756..925985ec 100644
--- a/tests/pl/test_render_labels.py
+++ b/tests/pl/test_render_labels.py
@@ -605,3 +605,17 @@ def test_render_labels_color_list_creates_one_panel_per_key(sdata_blobs: Spatial
     assert len(axs) == 2
     assert [ax.get_title() for ax in axs] == ["channel_0_sum", "channel_1_sum"]
     plt.close("all")
+
+
+def test_render_labels_as_points_renders_centroids(sdata_blobs: SpatialData):
+    """as_points draws one dot per label at its centroid instead of the rasterized mask."""
+    import spatialdata as sd
+
+    fig, ax = plt.subplots()
+    sdata_blobs.pl.render_labels("blobs_labels", color="instance_id", as_points=True, size=50).pl.show(ax=ax)
+    offsets = np.asarray(ax.collections[0].get_offsets())
+    ref = sd.get_centroids(sdata_blobs["blobs_labels"], coordinate_system="global").compute()[["x", "y"]]
+    assert len(offsets) == len(ref)
+    assert np.allclose(np.sort(offsets[:, 0]), np.sort(ref["x"].to_numpy()), atol=1e-6)
+    assert np.allclose(np.sort(offsets[:, 1]), np.sort(ref["y"].to_numpy()), atol=1e-6)
+    plt.close(fig)
diff --git a/tests/pl/test_render_shapes.py b/tests/pl/test_render_shapes.py
index f51cbf36..b30f13fe 100644
--- a/tests/pl/test_render_shapes.py
+++ b/tests/pl/test_render_shapes.py
@@ -1691,3 +1691,27 @@ def test_render_shapes_color_list_branches_are_independent(sdata_blobs: SpatialD
     # branch1 is still usable and unaffected
     assert len(branch1.plotting_tree) == base_steps + 2
     plt.close("all")
+
+
+def test_render_shapes_as_points_renders_centroids(sdata_blobs: SpatialData):
+    """as_points draws one dot per shape at its centroid (fast mode)."""
+    import spatialdata as sd
+
+    fig, ax = plt.subplots()
+    sdata_blobs.pl.render_shapes("blobs_circles", as_points=True, size=50).pl.show(ax=ax)
+    offsets = np.asarray(ax.collections[0].get_offsets())
+    ref = sd.get_centroids(sdata_blobs["blobs_circles"]).compute()[["x", "y"]]
+    assert len(offsets) == len(ref)
+    assert np.allclose(np.sort(offsets[:, 0]), np.sort(ref["x"].to_numpy()), atol=1e-6)
+    assert np.allclose(np.sort(offsets[:, 1]), np.sort(ref["y"].to_numpy()), atol=1e-6)
+    plt.close(fig)
+
+
+def test_render_shapes_as_points_ignores_outline_and_shape(sdata_blobs: SpatialData):
+    """outline_* and shape are ignored under as_points and must not error."""
+    fig, ax = plt.subplots()
+    sdata_blobs.pl.render_shapes(
+        "blobs_polygons", as_points=True, outline_alpha=1.0, outline_color="red", shape="square"
+    ).pl.show(ax=ax)
+    assert len(ax.collections) >= 1  # a scatter, not the patch collections of the geometry path
+    plt.close(fig)

From 169d89740aea74d9479695c38663fe2537eb6751 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Mon, 8 Jun 2026 18:10:16 +0200
Subject: [PATCH 06/28] Fix as_points crash for labels without a color column

`render_labels(element, as_points=True)` with no color crashed:
`instance_id` (the raster's unique values) includes the background label `0`,
which has no centroid, and the literal/no-color color vector is sized to the
raster (not per-instance), so `ax.scatter` got mismatched `c` vs `x`/`y`.

Drop the background label from the rendered instances and align the per-cell
color: for data-driven color the vector is already per-instance and is subset to
match; for the literal/no-color path it is replaced with one na/literal color
per centroid. Data-driven (categorical/continuous) renders are unchanged and
still land exactly on `get_centroids`.

Adds a regression test for the no-color labels case.
---
 src/spatialdata_plot/pl/render.py | 23 +++++++++++++++++++----
 tests/pl/test_render_labels.py    | 12 ++++++++++++
 2 files changed, 31 insertions(+), 4 deletions(-)

diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index 9ebf625a..01d42b24 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -2354,17 +2354,32 @@ def _render_labels(
     if render_params.as_points:
         # Fast mode: draw one dot per label at its centroid instead of the mask. Centroids come
         # from `regionprops` (orders of magnitude faster than rasterizing) in coordinate-system
-        # coords, aligned to `instance_id` (and thus to `color_vector`).
+        # coords.
         logger.info("`as_points=True`: rendering label centroids; `contour_px` and `outline_*` are ignored.")
+        # `instance_id` may include the background label 0 (which has no centroid); drop it.
+        keep = instance_id != 0
+        point_ids = instance_id[keep]
         centroids = _get_or_compute_centroids(
             sdata_filt, element, coordinate_system=coordinate_system, table_name=table_name
-        ).reindex(instance_id)
+        ).reindex(point_ids)
+        # Align the per-cell color to the rendered centroids. For data-driven color the vector is
+        # already per-instance (paired with `instance_id`); for the literal/no-color path it is
+        # not, so fall back to one na/literal color per centroid.
+        point_color_vector = np.asarray(color_vector)
+        point_color_source_vector = color_source_vector
+        if len(point_color_vector) == len(instance_id):
+            point_color_vector = point_color_vector[keep]
+            if point_color_source_vector is not None:
+                point_color_source_vector = point_color_source_vector[keep]
+        else:
+            point_color_vector = np.asarray([na_color.get_hex_with_alpha()] * len(point_ids))
+            point_color_source_vector = None
         _render_centroids_as_points(
             ax,
             x=centroids["x"].to_numpy(),
             y=centroids["y"].to_numpy(),
-            color_vector=color_vector,
-            color_source_vector=color_source_vector,
+            color_vector=point_color_vector,
+            color_source_vector=point_color_source_vector,
             cmap=render_params.cmap_params.cmap,
             norm=render_params.cmap_params.norm,
             na_color=na_color,
diff --git a/tests/pl/test_render_labels.py b/tests/pl/test_render_labels.py
index 925985ec..11adf30f 100644
--- a/tests/pl/test_render_labels.py
+++ b/tests/pl/test_render_labels.py
@@ -619,3 +619,15 @@ def test_render_labels_as_points_renders_centroids(sdata_blobs: SpatialData):
     assert np.allclose(np.sort(offsets[:, 0]), np.sort(ref["x"].to_numpy()), atol=1e-6)
     assert np.allclose(np.sort(offsets[:, 1]), np.sort(ref["y"].to_numpy()), atol=1e-6)
     plt.close(fig)
+
+
+def test_render_labels_as_points_without_color(sdata_blobs: SpatialData):
+    """as_points must not crash without a color column; the background label (0) is excluded."""
+    import spatialdata as sd
+
+    fig, ax = plt.subplots()
+    sdata_blobs.pl.render_labels("blobs_labels", as_points=True).pl.show(ax=ax)
+    offsets = np.asarray(ax.collections[0].get_offsets())
+    n_cells = len(sd.get_centroids(sdata_blobs["blobs_labels"], coordinate_system="global").compute())
+    assert len(offsets) == n_cells  # one dot per cell, no spurious background point
+    plt.close(fig)

From 4678297b0dc96f19afad269252299123cff4550b Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Mon, 8 Jun 2026 18:28:00 +0200
Subject: [PATCH 07/28] Compute label centroids with a streaming, out-of-core
 bincount aggregator
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the `regionprops` reduction in `_compute_label_centroids` with an
additive bincount aggregator that streams the labels raster block by block —
one dask chunk (or bounded numpy row-block) in memory at a time — accumulating
per-label `count`/`sum_x`/`sum_y`. This is what makes the feature usable at
Xenium scale:

- Out-of-core: peak memory is one chunk + O(n_labels) accumulators, NOT the
  whole raster (measured: 9 MB peak streaming a 268 MB mask). `regionprops`
  needs the full array materialized and OOMs on large morphology masks.
- Scales in cell count: 500k+ labels are just array indexing (562k labels in
  ~1.4 s with 13.5 MB of accumulators); `regionprops`' per-label table does not.
- Faster than `regionprops` (~1.3-1.6x) on in-memory rasters.
- Exact across chunk boundaries (additive reduction) — verified numpy ==
  dask-chunked, and identical to `sd.get_centroids`.
- `count` is the cell area, a free by-product (ready for footprint-based dot
  sizing).

Drops the `regionprops_table` import; adds `slices_from_chunks`. Adds a unit
test locking the chunk-exact, out-of-core, area-correct behavior.

Note: the chunk loop is currently sequential; parallelizing the per-chunk
partials (dask map_blocks + tree-reduce) is a future speedup.
---
 src/spatialdata_plot/pl/utils.py | 72 ++++++++++++++++++++++++--------
 tests/pl/test_utils.py           | 16 +++++++
 2 files changed, 71 insertions(+), 17 deletions(-)

diff --git a/src/spatialdata_plot/pl/utils.py b/src/spatialdata_plot/pl/utils.py
index 78cb7301..6fd2f39e 100644
--- a/src/spatialdata_plot/pl/utils.py
+++ b/src/spatialdata_plot/pl/utils.py
@@ -26,6 +26,7 @@
 import spatialdata as sd
 from anndata import AnnData
 from cycler import Cycler, cycler
+from dask.array.core import slices_from_chunks
 from datashader.core import Canvas
 from geopandas import GeoDataFrame
 from matplotlib import colors, patheffects, rcParams
@@ -55,7 +56,6 @@
 from scipy.spatial import ConvexHull
 from shapely.errors import GEOSException
 from skimage.color import label2rgb
-from skimage.measure import regionprops_table
 from skimage.morphology import erosion, footprint_rectangle
 from skimage.util import map_array
 from spatialdata import (
@@ -4445,21 +4445,62 @@ def _transform_carrier(element: SpatialElement) -> Any:
     return element
 
 
-def _compute_label_centroids(element: DataArray | DataTree) -> pd.DataFrame:
-    """Per-label centroids in the element's *intrinsic* coordinates via skimage ``regionprops``.
+def _stream_label_centroid_stats(data: Any) -> tuple[ArrayLike, ArrayLike, ArrayLike, ArrayLike]:
+    """Per-label ``(labels, mean_x_index, mean_y_index, area)`` via a streaming bincount aggregator.
+
+    Streams the raster block by block — one chunk in memory at a time for a dask array, a
+    bounded row-block at a time for a numpy array — accumulating per-label ``count`` (= area),
+    ``sum_x`` and ``sum_y``. The reduction is additive, so it is exact across block boundaries
+    and uses only O(n_labels) memory regardless of raster size. Background label 0 is excluded.
+    """
+    n_rows, n_cols = data.shape
+    is_dask = hasattr(data, "chunks") and not isinstance(data, np.ndarray)
+    if is_dask:
+        n_labels = int(data.max().compute()) + 1
+        block_slices = slices_from_chunks(data.chunks)
+    else:
+        data = np.asarray(data)
+        n_labels = int(data.max()) + 1
+        # bound the per-block coordinate-weight arrays to ~8M pixels
+        step = max(1, min(n_rows, (8 << 20) // max(1, n_cols)))
+        block_slices = [(slice(r0, min(r0 + step, n_rows)), slice(0, n_cols)) for r0 in range(0, n_rows, step)]
+
+    count = np.zeros(n_labels, dtype=np.float64)
+    sum_x = np.zeros(n_labels, dtype=np.float64)
+    sum_y = np.zeros(n_labels, dtype=np.float64)
+    for row_sl, col_sl in block_slices:
+        block = data[row_sl, col_sl]
+        block = np.asarray(block.compute() if hasattr(block, "compute") else block)
+        block_rows, block_cols = block.shape
+        flat = block.reshape(-1)
+        cols = np.tile(np.arange(col_sl.start, col_sl.start + block_cols, dtype=np.float64), block_rows)
+        rows = np.repeat(np.arange(row_sl.start, row_sl.start + block_rows, dtype=np.float64), block_cols)
+        count += np.bincount(flat, minlength=n_labels)
+        sum_x += np.bincount(flat, weights=cols, minlength=n_labels)
+        sum_y += np.bincount(flat, weights=rows, minlength=n_labels)
+
+    labels = np.flatnonzero(count)
+    labels = labels[labels != 0]  # drop background and absent labels
+    return labels, sum_x[labels] / count[labels], sum_y[labels] / count[labels], count[labels]
+
 
-    ``regionprops`` does the per-label reduction in a single C pass, orders of magnitude
-    faster than ``spatialdata.get_centroids`` on labels (which scans the raster row/column-wise
-    and scales with raster area). Returns intrinsic coords; the caller maps them to a target
-    coordinate system on demand.
+def _compute_label_centroids(element: DataArray | DataTree) -> pd.DataFrame:
+    """Per-label centroids in the element's *intrinsic* coordinates via a streaming bincount aggregator.
+
+    The centroid is the mean pixel coordinate per label, computed with an additive
+    ``bincount`` aggregator (``count``/``sum_x``/``sum_y`` per label). ``count`` is the cell
+    **area** — a free by-product. The aggregator streams the (possibly huge, dask-backed)
+    raster **block by block**, holding only one chunk plus O(n_labels) accumulators, so it
+    scales to Xenium-size masks with hundreds of thousands of cells where ``regionprops``
+    (whole-array, per-label table) would run out of memory. Returns intrinsic coords; the
+    caller maps them to a target coordinate system on demand.
     """
     raster = _transform_carrier(element)
-    values = np.asarray(raster.data)  # materialize the intrinsic pixel grid
-    props = regionprops_table(values, properties=("label", "centroid"))
+    labels, x_idx, y_idx, _area = _stream_label_centroid_stats(raster.data)
 
-    # regionprops excludes background (label 0); centroid-0 = row (y), centroid-1 = col (x)
-    # as 0-based fractional indices. Map them onto the raster's intrinsic coordinate arrays
-    # (spatialdata uses pixel-center coords 0.5, 1.5, ... and possibly non-unit spacing).
+    # bincount gives mean 0-based pixel indices; map them onto the raster's intrinsic
+    # coordinate arrays (spatialdata uses pixel-center coords 0.5, 1.5, ... and possibly
+    # non-unit spacing).
     def _index_to_coord(idx: ArrayLike, coord: ArrayLike) -> ArrayLike:
         spacing = (coord[1] - coord[0]) if len(coord) > 1 else 1.0
         return coord[0] + idx * spacing
@@ -4467,11 +4508,8 @@ def _index_to_coord(idx: ArrayLike, coord: ArrayLike) -> ArrayLike:
     xcoord = np.asarray(raster.coords["x"].values)
     ycoord = np.asarray(raster.coords["y"].values)
     return pd.DataFrame(
-        {
-            "x": _index_to_coord(props["centroid-1"], xcoord),
-            "y": _index_to_coord(props["centroid-0"], ycoord),
-        },
-        index=props["label"],
+        {"x": _index_to_coord(x_idx, xcoord), "y": _index_to_coord(y_idx, ycoord)},
+        index=labels,
     )
 
 
diff --git a/tests/pl/test_utils.py b/tests/pl/test_utils.py
index d5e51a64..17ead13f 100644
--- a/tests/pl/test_utils.py
+++ b/tests/pl/test_utils.py
@@ -518,6 +518,22 @@ def test_centroids_match_get_centroids(self, sdata_blobs: SpatialData, element:
         assert list(mine.index) == list(ref.index)
         assert np.allclose(mine.values, ref.values, atol=1e-9)
 
+    def test_label_centroids_stream_out_of_core_and_chunk_exact(self, sdata_blobs: SpatialData):
+        import dask.array as da
+
+        from spatialdata_plot.pl.utils import _stream_label_centroid_stats
+
+        lab = np.asarray(sdata_blobs["blobs_labels"].data.compute())
+        l_np, x_np, y_np, a_np = _stream_label_centroid_stats(lab)
+        # many small chunks -> exercises block streaming + global offsets; must be exact.
+        l_da, x_da, y_da, a_da = _stream_label_centroid_stats(da.from_array(lab, chunks=(64, 64)))
+        assert np.array_equal(l_np, l_da)
+        assert np.allclose(x_np, x_da) and np.allclose(y_np, y_da)
+        assert np.array_equal(a_np, a_da)
+        # area is the per-label pixel count; background label 0 is excluded.
+        assert np.array_equal(a_np.astype(int), np.bincount(lab.ravel())[l_np])
+        assert 0 not in l_np
+
     def test_cache_is_coordinate_system_independent(self, sdata_blobs: SpatialData):
         # one intrinsic cache serves every coordinate system: add a second CS and confirm both
         # match get_centroids while only one obsm["spatial"] is written.

From f8918fba50d2aad7650a7e26513be7ac766a3ec7 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Tue, 9 Jun 2026 23:27:24 +0200
Subject: [PATCH 08/28] Simplify _render_centroids_as_points: take
 render_params, not 6 unpacked fields

The fast-mode draw wrapper read cmap/size/alpha/zorder/colorbar/colorbar_params
straight off render_params at both call sites. Pass the render_params dataclass
instead and read them internally; only the genuinely per-branch values
(x/y/color vectors, norm, na_color, transform, adata, palette, col_for_color)
stay explicit. Signature 20->15 params; both as_points call sites lose the
restated render_params plumbing.
---
 src/spatialdata_plot/pl/render.py | 44 ++++++++++++++-----------------
 1 file changed, 20 insertions(+), 24 deletions(-)

diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index 300277ac..ae745a4d 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -759,24 +759,19 @@ def _render_shapes(
         centroids = shapes.geometry.centroid  # intrinsic coords, positionally aligned to color_vector
         _render_centroids_as_points(
             ax,
+            render_params,
             x=centroids.x.to_numpy(),
             y=centroids.y.to_numpy(),
             color_vector=color_vector,
             color_source_vector=color_source_vector,
-            cmap=render_params.cmap_params.cmap,
             norm=norm,
             na_color=render_params.cmap_params.na_color,
-            size=render_params.size,
-            alpha=render_params.fill_alpha,
-            zorder=render_params.zorder,
             transform=trans_data,  # intrinsic -> coordinate system -> display
             adata=table,
             col_for_color=col_for_color,
             palette=palette,
             fig_params=fig_params,
             legend_params=legend_params,
-            colorbar=render_params.colorbar,
-            colorbar_params=render_params.colorbar_params,
             colorbar_requests=colorbar_requests,
         )
         return
@@ -1118,34 +1113,40 @@ def _scatter_points(
 
 def _render_centroids_as_points(
     ax: matplotlib.axes.SubplotBase,
+    render_params: ShapesRenderParams | LabelsRenderParams,
     *,
     x: Any,
     y: Any,
     color_vector: Any,
     color_source_vector: pd.Series | None,
-    cmap: Colormap,
     norm: Normalize | None,
     na_color: Any,
-    size: float,
-    alpha: float,
-    zorder: int,
     transform: Any,
     adata: AnnData | None,
     col_for_color: str | None,
     palette: Any,
     fig_params: FigParams,
     legend_params: LegendParams,
-    colorbar: bool | str | None,
-    colorbar_params: dict[str, object] | None,
     colorbar_requests: list[ColorbarSpec] | None,
 ) -> None:
     """Render one dot per cell at ``(x, y)`` colored like the fill, with legend/colorbar.
 
-    Shared "fast mode" draw for shapes/labels: ``color_vector`` is the same per-instance color
-    vector the geometry/raster path would use, so colors match the full rendering exactly.
+    Shared "fast mode" draw for shapes/labels: cmap/size/alpha/zorder/colorbar come off
+    ``render_params``; ``color_vector`` is the same per-instance color vector the geometry/raster
+    path would use, so colors match the full rendering exactly. ``norm``/``na_color`` stay explicit
+    because they differ between the shapes (locally adjusted) and labels paths.
     """
     cax = _scatter_points(
-        ax, x, y, color_vector, size=size, cmap=cmap, norm=norm, alpha=alpha, trans_data=transform, zorder=zorder
+        ax,
+        x,
+        y,
+        color_vector,
+        size=render_params.size,
+        cmap=render_params.cmap_params.cmap,
+        norm=norm,
+        alpha=render_params.fill_alpha,
+        trans_data=transform,
+        zorder=render_params.zorder,
     )
     _add_legend_and_colorbar(
         ax=ax,
@@ -1156,11 +1157,11 @@ def _render_centroids_as_points(
         color_source_vector=color_source_vector,
         color_vector=color_vector,
         palette=palette,
-        alpha=alpha,
+        alpha=render_params.fill_alpha,
         na_color=na_color,
         legend_params=legend_params,
-        colorbar=colorbar,
-        colorbar_params=colorbar_params,
+        colorbar=render_params.colorbar,
+        colorbar_params=render_params.colorbar_params,
         colorbar_requests=colorbar_requests,
     )
 
@@ -2380,24 +2381,19 @@ def _render_labels(
             point_color_source_vector = None
         _render_centroids_as_points(
             ax,
+            render_params,
             x=centroids["x"].to_numpy(),
             y=centroids["y"].to_numpy(),
             color_vector=point_color_vector,
             color_source_vector=point_color_source_vector,
-            cmap=render_params.cmap_params.cmap,
             norm=render_params.cmap_params.norm,
             na_color=na_color,
-            size=render_params.size,
-            alpha=render_params.fill_alpha,
-            zorder=render_params.zorder,
             transform=centroid_trans,  # scale0 intrinsic coords -> coordinate system -> display
             adata=table if table_name is not None else None,
             col_for_color=col_for_color,
             palette=palette,
             fig_params=fig_params,
             legend_params=legend_params,
-            colorbar=render_params.colorbar,
-            colorbar_params=render_params.colorbar_params,
             colorbar_requests=colorbar_requests,
         )
         return

From 79892ee401168108fb3db25e6196477573c4be1b Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Tue, 9 Jun 2026 23:34:33 +0200
Subject: [PATCH 09/28] Tidy labels as_points color alignment

Collapse the per-centroid color alignment (drop the unconditional asarray
pre-init and the nested None-guard into a single if/else + ternary), and drop a
redundant np.asarray around the already-ndarray point_ids in the reindex.
Behavior unchanged.
---
 src/spatialdata_plot/pl/render.py | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index ae745a4d..cb395d50 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -2364,18 +2364,16 @@ def _render_labels(
         centroids = _compute_element_measurements(sdata_filt, element)  # scale0 intrinsic [x, y, area]
         # Coerce point_ids to the label-value dtype so str/object ids from `table.obs` (e.g. Xenium
         # readers) match the integer raster labels instead of silently reindexing to NaN.
-        centroids = centroids.reindex(np.asarray(point_ids).astype(centroids.index.dtype, copy=False))
+        centroids = centroids.reindex(point_ids.astype(centroids.index.dtype, copy=False))
         # Transform built from scale0 (matching the centroids), not the possibly-rasterized `label`.
         _, centroid_trans = _prepare_transformation(_get_top_data_array(sdata_filt[element]), coordinate_system, ax)
-        # Align the per-cell color to the rendered centroids. For data-driven color the vector is
-        # already per-instance (paired with `instance_id`); for the literal/no-color path it is
-        # not, so fall back to one na/literal color per centroid.
-        point_color_vector = np.asarray(color_vector)
-        point_color_source_vector = color_source_vector
-        if len(point_color_vector) == len(instance_id):
-            point_color_vector = point_color_vector[keep]
-            if point_color_source_vector is not None:
-                point_color_source_vector = point_color_source_vector[keep]
+        # Align the per-cell color to the rendered centroids. Data-driven color is already
+        # per-instance (paired with `instance_id`); the literal/no-color path is not, so fall back
+        # to one na/literal color per centroid.
+        color_vec = np.asarray(color_vector)
+        if len(color_vec) == len(instance_id):
+            point_color_vector = color_vec[keep]
+            point_color_source_vector = None if color_source_vector is None else color_source_vector[keep]
         else:
             point_color_vector = np.asarray([na_color.get_hex_with_alpha()] * len(point_ids))
             point_color_source_vector = None

From 85692e91133bab28053269972b2d820f397da5fd Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Tue, 9 Jun 2026 23:40:29 +0200
Subject: [PATCH 10/28] Trim verbose as_points comments to the load-bearing
 invariants

---
 src/spatialdata_plot/pl/render.py | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index cb395d50..264e17ba 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -2353,23 +2353,16 @@ def _render_labels(
         color_vector = render_params.transfunc(color_vector)
 
     if render_params.as_points:
-        # Fast mode: draw one dot per label at its full-resolution (scale0) centroid instead of the
-        # rasterized mask. The streaming bincount aggregator computes the centroids; we then draw
-        # them with the scale0 element's own coordinate-system transform so they land where the cells
-        # actually are (independent of any rasterization applied to the rendered `label` above).
+        # Fast mode: one dot per label at its full-resolution (scale0) centroid, not the rasterized mask.
         logger.info("`as_points=True`: rendering label centroids; `contour_px` and `outline_*` are ignored.")
-        # `instance_id` may include the background label 0 (which has no centroid); drop it.
-        keep = instance_id != 0
+        keep = instance_id != 0  # background label 0 has no centroid
         point_ids = instance_id[keep]
         centroids = _compute_element_measurements(sdata_filt, element)  # scale0 intrinsic [x, y, area]
-        # Coerce point_ids to the label-value dtype so str/object ids from `table.obs` (e.g. Xenium
-        # readers) match the integer raster labels instead of silently reindexing to NaN.
+        # coerce so str/object table ids (e.g. Xenium) match the integer raster labels instead of NaN
         centroids = centroids.reindex(point_ids.astype(centroids.index.dtype, copy=False))
-        # Transform built from scale0 (matching the centroids), not the possibly-rasterized `label`.
+        # transform from scale0 (matching the centroids), NOT the possibly-rasterized `label`
         _, centroid_trans = _prepare_transformation(_get_top_data_array(sdata_filt[element]), coordinate_system, ax)
-        # Align the per-cell color to the rendered centroids. Data-driven color is already
-        # per-instance (paired with `instance_id`); the literal/no-color path is not, so fall back
-        # to one na/literal color per centroid.
+        # data-driven color is per-instance; literal/no-color is not -> one na color per centroid
         color_vec = np.asarray(color_vector)
         if len(color_vec) == len(instance_id):
             point_color_vector = color_vec[keep]

From b087c1cc63b6ff93c8382cc2545c18d65bd9e0f5 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Wed, 10 Jun 2026 00:09:20 +0200
Subject: [PATCH 11/28] Make labels as_points fast: centroids on the rendered
 raster, not scale0

Benchmark showed labels as_points was 16-34x SLOWER than the normal render
because it recomputed full-resolution scale0 centroids while the normal path
downsamples + imshows. Compute centroids on the already-rendered (downsampled)
raster and draw with its trans_data instead: 671k cells goes 19.7s -> 0.88s
(now ~parity with imshow). Centroid error is sub-pixel at display resolution;
position tests updated to display-space within a few-px tolerance.
---
 src/spatialdata_plot/pl/render.py | 22 +++++++++++++++-------
 tests/pl/test_render_labels.py    | 24 ++++++++++++++----------
 2 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index 264e17ba..8074cbbc 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -63,7 +63,6 @@
     _build_shape_patches,
     _check_obs_var_shadow,
     _color_vector_to_rgba,
-    _compute_element_measurements,
     _convert_shapes,
     _datashader_canvas_from_dataframe,
     _decorate_axs,
@@ -78,11 +77,13 @@
     _maybe_set_colors,
     _mpl_ax_contains_elements,
     _multiscale_to_spatial_image,
+    _pixel_to_coord,
     _prepare_cmap_norm,
     _prepare_transformation,
     _rasterize_if_necessary,
     _rasterize_if_necessary_datashader,
     _set_color_source_vec,
+    _stream_label_centroid_stats,
     _validate_polygons,
 )
 
@@ -2353,15 +2354,22 @@ def _render_labels(
         color_vector = render_params.transfunc(color_vector)
 
     if render_params.as_points:
-        # Fast mode: one dot per label at its full-resolution (scale0) centroid, not the rasterized mask.
+        # Fast mode: one dot per label at its centroid. Compute on the *rendered* raster (already
+        # downsampled to ~display resolution above) and draw with its `trans_data`, so this is cheap
+        # and the dots land where the cells are. Centroid error is sub-pixel at display resolution.
         logger.info("`as_points=True`: rendering label centroids; `contour_px` and `outline_*` are ignored.")
         keep = instance_id != 0  # background label 0 has no centroid
         point_ids = instance_id[keep]
-        centroids = _compute_element_measurements(sdata_filt, element)  # scale0 intrinsic [x, y, area]
+        labels, x_idx, y_idx, _area = _stream_label_centroid_stats(label.data)
+        centroids = pd.DataFrame(
+            {
+                "x": _pixel_to_coord(x_idx, label.coords["x"].values),
+                "y": _pixel_to_coord(y_idx, label.coords["y"].values),
+            },
+            index=labels,
+        )
         # coerce so str/object table ids (e.g. Xenium) match the integer raster labels instead of NaN
-        centroids = centroids.reindex(point_ids.astype(centroids.index.dtype, copy=False))
-        # transform from scale0 (matching the centroids), NOT the possibly-rasterized `label`
-        _, centroid_trans = _prepare_transformation(_get_top_data_array(sdata_filt[element]), coordinate_system, ax)
+        centroids = centroids.reindex(point_ids.astype(labels.dtype, copy=False))
         # data-driven color is per-instance; literal/no-color is not -> one na color per centroid
         color_vec = np.asarray(color_vector)
         if len(color_vec) == len(instance_id):
@@ -2379,7 +2387,7 @@ def _render_labels(
             color_source_vector=point_color_source_vector,
             norm=render_params.cmap_params.norm,
             na_color=na_color,
-            transform=centroid_trans,  # scale0 intrinsic coords -> coordinate system -> display
+            transform=trans_data,  # rendered-raster intrinsic coords -> coordinate system -> display
             adata=table if table_name is not None else None,
             col_for_color=col_for_color,
             palette=palette,
diff --git a/tests/pl/test_render_labels.py b/tests/pl/test_render_labels.py
index e82416a0..6eada3f6 100644
--- a/tests/pl/test_render_labels.py
+++ b/tests/pl/test_render_labels.py
@@ -608,16 +608,20 @@ def test_render_labels_color_list_creates_one_panel_per_key(sdata_blobs: Spatial
 
 
 def test_render_labels_as_points_renders_centroids(sdata_blobs: SpatialData):
-    """as_points draws one dot per label at its centroid instead of the rasterized mask."""
+    """as_points draws one dot per label near its centroid. Centroids are computed on the rendered
+    (possibly downsampled) raster, so positions are checked in display space within a few-pixel
+    rasterization tolerance rather than against the exact full-resolution centroid."""
     import spatialdata as sd
 
     fig, ax = plt.subplots()
     sdata_blobs.pl.render_labels("blobs_labels", color="instance_id", as_points=True, size=50).pl.show(ax=ax)
-    offsets = np.asarray(ax.collections[0].get_offsets())
-    ref = sd.get_centroids(sdata_blobs["blobs_labels"], coordinate_system="global").compute()[["x", "y"]]
-    assert len(offsets) == len(ref)
-    assert np.allclose(np.sort(offsets[:, 0]), np.sort(ref["x"].to_numpy()), atol=1e-6)
-    assert np.allclose(np.sort(offsets[:, 1]), np.sort(ref["y"].to_numpy()), atol=1e-6)
+    coll = ax.collections[0]
+    dots = coll.get_offset_transform().transform(np.asarray(coll.get_offsets()))  # display px
+    ref_world = sd.get_centroids(sdata_blobs["blobs_labels"], coordinate_system="global").compute()[["x", "y"]]
+    ref = ax.transData.transform(ref_world.to_numpy())
+    assert len(dots) == len(ref)
+    od, oe = np.lexsort((dots[:, 1], dots[:, 0])), np.lexsort((ref[:, 1], ref[:, 0]))
+    assert np.allclose(dots[od], ref[oe], atol=3.0)  # within a few display px of the true centroid
     plt.close(fig)
 
 
@@ -634,9 +638,9 @@ def test_render_labels_as_points_without_color(sdata_blobs: SpatialData):
 
 
 def test_render_labels_as_points_applies_non_identity_transform(sdata_blobs: SpatialData):
-    """Regression guard: under a non-identity element->CS transform the dots must land at the
-    cells' coordinate-system positions. Offsets stay in scale0 space, so correctness lives in the
-    transform applied by the scatter; check it in display space."""
+    """Regression guard: under a non-identity element->CS transform the dots must land at the cells'
+    coordinate-system positions (in display space). A wrong transform would be off by the scale
+    factor (hundreds of px); the rendered-raster centroid is correct within a few px."""
     import spatialdata as sd
     from spatialdata.transformations import Scale, set_transformation
 
@@ -651,5 +655,5 @@ def test_render_labels_as_points_applies_non_identity_transform(sdata_blobs: Spa
     expected_display = ax.transData.transform(cs)  # where the cells truly are, in display pixels
     order_d = np.lexsort((dots_display[:, 1], dots_display[:, 0]))
     order_e = np.lexsort((expected_display[:, 1], expected_display[:, 0]))
-    assert np.allclose(dots_display[order_d], expected_display[order_e], atol=1e-2)
+    assert np.allclose(dots_display[order_d], expected_display[order_e], atol=3.0)
     plt.close(fig)

From 57bcf8db50b5bdfed36a0a634239c031995bd1b6 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Wed, 10 Jun 2026 01:19:41 +0200
Subject: [PATCH 12/28] Fast axis-bounds in show(): skip per-geometry transform
 when axis-aligned

show()'s get_extent(exact=True) transforms EVERY shapes/points geometry into
the coordinate system just to take a bounding box - the dominant cost for large
shape collections (~85% of a 5.5M-shape render), unrelated to what is drawn.

Add a self-contained get_extent_fast (drop-in for spatialdata.get_extent) that,
for axis-aligned transforms (scale/flip/90deg/swap + translation - all real
Visium/Xenium data), transforms only the 4 bounding-box corners and reads the
intrinsic bounds vectorised (no per-geometry .apply(is_empty)). Proven identical
to the exact extent for such transforms (spatialdata's own get_extent docstring
notes this); falls back to spatialdata's get_extent for rotation/shear, for
anisotropically-scaled circles (radius->ellipse divergence), and for
images/labels (whose get_extent is already a cheap corner transform).

Measured on real Visium HD render_shapes(as_points=True): 351k 8.5s->1.8s
(4.7x), 5.48M 129s->24s (5.5x); the full (non-as_points) render benefits too.
The whole block is isolated so it can be lifted into spatialdata's get_extent
verbatim (see issue #706). Tests assert it matches get_extent across scale/flip/
rotation/shear for circles and polygons.
---
 src/spatialdata_plot/pl/basic.py |   6 +-
 src/spatialdata_plot/pl/utils.py | 122 +++++++++++++++++++++++++++++++
 tests/pl/test_utils.py           |  51 +++++++++++++
 3 files changed, 178 insertions(+), 1 deletion(-)

diff --git a/src/spatialdata_plot/pl/basic.py b/src/spatialdata_plot/pl/basic.py
index 1d2f409b..0de6bed9 100644
--- a/src/spatialdata_plot/pl/basic.py
+++ b/src/spatialdata_plot/pl/basic.py
@@ -78,6 +78,7 @@
     _validate_shape_render_params,
     _validate_show_parameters,
     _verify_plotting_tree,
+    get_extent_fast,
     save_fig,
 )
 
@@ -1828,7 +1829,10 @@ def _draw_colorbar(
                         "all geometries are empty. Drop the element or restore at least one non-empty geometry."
                     )
 
-            extent = get_extent(
+            # `get_extent_fast` skips transforming every shapes/points geometry when the element's
+            # transform is axis-aligned (the common scale+translation case); identical result, but
+            # avoids the O(N-geometries) bottleneck for large shape collections.
+            extent = get_extent_fast(
                 sdata,
                 coordinate_system=cs,
                 has_images=has_images and wants_images,
diff --git a/src/spatialdata_plot/pl/utils.py b/src/spatialdata_plot/pl/utils.py
index b6eab503..b65afac4 100644
--- a/src/spatialdata_plot/pl/utils.py
+++ b/src/spatialdata_plot/pl/utils.py
@@ -72,6 +72,7 @@
 from spatialdata.models import (
     Image2DModel,
     Labels2DModel,
+    PointsModel,
     ShapesModel,
     SpatialElement,
     get_model,
@@ -4728,3 +4729,124 @@ def measure_obs(
         table = _resolve_measure_table(target, name, table_name)
         _measure_into_table(target, name, table, centroids=centroids, area=area, diameter=diameter)
     return None if inplace else target
+
+
+# --- Fast extent for axis-aligned transforms ------------------------------------------------------
+# `pl.show()` computes axis bounds via spatialdata's `get_extent(..., exact=True)`, which transforms
+# EVERY shapes/points geometry into the coordinate system (per-geometry, O(N)) just to take a bounding
+# box — the dominant cost when rendering large shape collections. When the element's transform is
+# axis-aligned (scale / flip / 90deg rotation / axis swap + translation), the exact extent equals the
+# bounding box of the *transformed corners* (spatialdata's own get_extent docstring notes this), so we
+# can transform 4 corners instead of N geometries, and read the intrinsic bounds vectorised (avoiding
+# spatialdata's per-geometry `.apply(is_empty)` filter). This whole block is self-contained so it can
+# be lifted into spatialdata's `get_extent` verbatim; it falls back to `get_extent` for rotation/shear.
+
+
+def _is_axis_aligned(linear2x2: ArrayLike, *, rtol: float = 1e-9) -> bool:
+    """Whether a 2x2 linear map sends axis-aligned boxes to axis-aligned boxes.
+
+    True for a *monomial matrix* (at most one non-zero per row and per column): scale, axis flips,
+    90/180/270-degree rotations and axis swaps. For such maps the exact extent equals the bounding box
+    of the transformed corners. A relative tolerance ignores floating-point noise in the affine matrix.
+    """
+    m = np.abs(np.asarray(linear2x2, dtype=float))
+    nz = m > rtol * (m.max() or 1.0)
+    return bool((nz.sum(0) <= 1).all() and (nz.sum(1) <= 1).all() and int(nz.sum()) == m.shape[0])
+
+
+def _intrinsic_xy_bounds(element: Any) -> tuple[float, float, float, float] | None:
+    """``(xmin, ymin, xmax, ymax)`` of a shapes/points element in its intrinsic coords, vectorised.
+
+    Circles (``Point`` + ``radius``) expand by the radius; polygons use the vectorised ``.bounds``;
+    points read the x/y columns. NaN bounds of empty geometries are skipped by min/max, so no
+    per-geometry empty filter is needed. Returns ``None`` for unsupported element types.
+    """
+    model = get_model(element)
+    if model is ShapesModel:
+        geom = element.geometry
+        if (geom.geom_type == "Point").all():  # circles
+            x, y = geom.x.to_numpy(), geom.y.to_numpy()
+            r = np.asarray(element["radius"], dtype=float)
+            return float(np.nanmin(x - r)), float(np.nanmin(y - r)), float(np.nanmax(x + r)), float(np.nanmax(y + r))
+        b = geom.bounds  # vectorised; columns minx/miny/maxx/maxy
+        return float(b["minx"].min()), float(b["miny"].min()), float(b["maxx"].max()), float(b["maxy"].max())
+    if model is PointsModel:
+        x, y = element["x"], element["y"]
+        return float(x.min().compute()), float(y.min().compute()), float(x.max().compute()), float(y.max().compute())
+    return None
+
+
+def _element_extent_fast(element: Any, coordinate_system: str) -> dict[str, tuple[float, float]] | None:
+    """Extent of one shapes/points element in ``coordinate_system`` via corner-transform.
+
+    Returns ``None`` (signalling the caller to fall back to ``get_extent``) when the element type is
+    unsupported or the transform is not axis-aligned (rotation/shear, where the cheap path would
+    over-estimate). For circles it also falls back under an *anisotropic* linear map: a scaled circle
+    is an ellipse, but spatialdata stores a single uniformly-scaled radius, so the cheap and exact
+    extents only agree when the scale is isotropic.
+    """
+    model = get_model(element)
+    if model not in (ShapesModel, PointsModel):
+        return None
+    matrix = get_transformation(element, get_all=True)[coordinate_system].to_affine_matrix(("x", "y"), ("x", "y"))
+    affine = matrix[:2, :2]
+    if not _is_axis_aligned(affine):
+        return None
+    if model is ShapesModel and bool((element.geometry.geom_type == "Point").all()):  # circles
+        nz = np.abs(affine)[np.abs(affine) > 1e-9 * (np.abs(affine).max() or 1.0)]
+        if not np.allclose(nz, nz[0]):  # anisotropic -> radius handling diverges from spatialdata
+            return None
+    bounds = _intrinsic_xy_bounds(element)
+    if bounds is None:
+        return None
+    xmin, ymin, xmax, ymax = bounds
+    corners = np.array([[xmin, ymin], [xmax, ymin], [xmin, ymax], [xmax, ymax]])
+    tc = corners @ affine.T + matrix[:2, 2]
+    return {"x": (float(tc[:, 0].min()), float(tc[:, 0].max())), "y": (float(tc[:, 1].min()), float(tc[:, 1].max()))}
+
+
+def get_extent_fast(
+    sdata: SpatialData,
+    coordinate_system: str,
+    *,
+    has_images: bool = True,
+    has_labels: bool = True,
+    has_points: bool = True,
+    has_shapes: bool = True,
+    elements: list[str] | None = None,
+) -> dict[str, tuple[float, float]]:
+    """Drop-in replacement for spatialdata ``get_extent(sdata, ...)`` with a fast path for shapes/points.
+
+    Shapes/points with axis-aligned transforms get the corner-transform extent (identical result, no
+    per-geometry transform); everything else (rotation/shear, images, labels) delegates to spatialdata's
+    ``get_extent``. The union semantics match spatialdata's ``get_extent``.
+    """
+    include = {"images": has_images, "labels": has_labels, "points": has_points, "shapes": has_shapes}
+    element_dicts = {"images": sdata.images, "labels": sdata.labels, "points": sdata.points, "shapes": sdata.shapes}
+    mins: dict[str, list[float]] = {"x": [], "y": []}
+    maxs: dict[str, list[float]] = {"x": [], "y": []}
+    for etype, edict in element_dicts.items():
+        if not include[etype]:
+            continue
+        for name, element in edict.items():
+            if elements is not None and name not in elements:
+                continue
+            if coordinate_system not in get_transformation(element, get_all=True):
+                continue
+            ext = _element_extent_fast(element, coordinate_system) if etype in ("shapes", "points") else None
+            if ext is None:  # rotation/shear, image/label (already cheap), or unsupported
+                ext = get_extent(element, coordinate_system=coordinate_system)
+            for ax in ("x", "y"):
+                mins[ax].append(ext[ax][0])
+                maxs[ax].append(ext[ax][1])
+    if not mins["x"]:  # nothing matched -> defer to spatialdata (preserves its error behaviour)
+        return get_extent(
+            sdata,
+            coordinate_system=coordinate_system,
+            has_images=has_images,
+            has_labels=has_labels,
+            has_points=has_points,
+            has_shapes=has_shapes,
+            elements=elements,
+        )
+    return {ax: (min(mins[ax]), max(maxs[ax])) for ax in ("x", "y")}
diff --git a/tests/pl/test_utils.py b/tests/pl/test_utils.py
index 87b41495..8617b8dd 100644
--- a/tests/pl/test_utils.py
+++ b/tests/pl/test_utils.py
@@ -679,3 +679,54 @@ def test_element_none_measures_single_table_elements(self, sdata_blobs: SpatialD
         # default blobs: only blobs_labels has a single annotating table
         measure_obs(sdata_blobs)
         assert "spatial" in sdata_blobs["table"].obsm
+
+
+class TestGetExtentFast:
+    """`get_extent_fast` matches spatialdata's `get_extent` while skipping the per-geometry transform."""
+
+    @pytest.mark.parametrize(
+        ("matrix", "expected"),
+        [
+            ([[2, 0], [0, 3]], True),  # anisotropic scale
+            ([[-1, 0], [0, 1]], True),  # flip
+            ([[0, -1], [1, 0]], True),  # 90-degree rotation
+            ([[0, 1], [1, 0]], True),  # axis swap
+            ([[0.7071, -0.7071], [0.7071, 0.7071]], False),  # 45-degree rotation
+            ([[1, 0.5], [0, 1]], False),  # shear
+        ],
+    )
+    def test_is_axis_aligned(self, matrix, expected):
+        from spatialdata_plot.pl.utils import _is_axis_aligned
+
+        assert _is_axis_aligned(matrix) is expected
+
+    @pytest.mark.parametrize("element", ["blobs_circles", "blobs_polygons"])
+    @pytest.mark.parametrize("kind", ["scale_iso", "scale_aniso", "translate", "flip", "rot90", "rot45", "shear"])
+    def test_matches_get_extent(self, sdata_blobs: SpatialData, element: str, kind: str):
+        import math
+
+        from spatialdata import get_extent
+        from spatialdata.transformations import Affine, Scale, Translation, set_transformation
+
+        from spatialdata_plot.pl.utils import get_extent_fast
+
+        def _rot(theta: float) -> Affine:
+            c, s = math.cos(theta), math.sin(theta)
+            return Affine([[c, -s, 0], [s, c, 0], [0, 0, 1]], input_axes=("x", "y"), output_axes=("x", "y"))
+
+        transforms = {
+            "scale_iso": Scale([2.0, 2.0], axes=("x", "y")),
+            "scale_aniso": Scale([2.0, 3.0], axes=("x", "y")),  # circles fall back here
+            "translate": Translation([10.0, 20.0], axes=("x", "y")),
+            "flip": Scale([-1.0, 1.0], axes=("x", "y")),
+            "rot90": _rot(math.pi / 2),
+            "rot45": _rot(math.pi / 4),  # not axis-aligned -> fall back
+            "shear": Affine([[1, 0.5, 0], [0, 1, 0], [0, 0, 1]], input_axes=("x", "y"), output_axes=("x", "y")),
+        }
+        set_transformation(sdata_blobs[element], transforms[kind], "cs")
+        sub = SpatialData(shapes={element: sdata_blobs[element]})
+        kw = dict(has_images=False, has_labels=False, has_points=False)
+        fast = get_extent_fast(sub, "cs", **kw)
+        exact = get_extent(sub, "cs", exact=True, **kw)
+        for ax in ("x", "y"):
+            np.testing.assert_allclose(fast[ax], exact[ax], atol=1e-6)

From ae5fcfb57b0067c470ddf17ffb0b98d77cb1c781 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Wed, 10 Jun 2026 13:49:28 +0200
Subject: [PATCH 13/28] refactor: tidy _get_extent_fast (fold helper,
 total_bounds, batched compute, underscore)

Follow-up cleanups from review of the get_extent fast path:
- fold _intrinsic_xy_bounds into _element_extent_fast (drop duplicate get_model / geom_type)
- geom.bounds -> geom.total_bounds (C-level union, avoids an Nx4 alloc on large collections)
- batch the four points min/max into one dask.compute
- rename get_extent_fast -> _get_extent_fast (internal helper; matches sibling underscored helpers)

No behavior change; output identical for axis-aligned and rotated/sheared elements.
---
 src/spatialdata_plot/pl/basic.py |  6 ++--
 src/spatialdata_plot/pl/utils.py | 55 +++++++++++++-------------------
 tests/pl/test_utils.py           |  6 ++--
 3 files changed, 29 insertions(+), 38 deletions(-)

diff --git a/src/spatialdata_plot/pl/basic.py b/src/spatialdata_plot/pl/basic.py
index 0de6bed9..ffeb085e 100644
--- a/src/spatialdata_plot/pl/basic.py
+++ b/src/spatialdata_plot/pl/basic.py
@@ -64,6 +64,7 @@
     _expand_color_panels,
     _get_cs_contents,
     _get_elements_to_be_rendered,
+    _get_extent_fast,
     _get_valid_cs,
     _get_wanted_render_elements,
     _maybe_set_colors,
@@ -78,7 +79,6 @@
     _validate_shape_render_params,
     _validate_show_parameters,
     _verify_plotting_tree,
-    get_extent_fast,
     save_fig,
 )
 
@@ -1829,10 +1829,10 @@ def _draw_colorbar(
                         "all geometries are empty. Drop the element or restore at least one non-empty geometry."
                     )
 
-            # `get_extent_fast` skips transforming every shapes/points geometry when the element's
+            # `_get_extent_fast` skips transforming every shapes/points geometry when the element's
             # transform is axis-aligned (the common scale+translation case); identical result, but
             # avoids the O(N-geometries) bottleneck for large shape collections.
-            extent = get_extent_fast(
+            extent = _get_extent_fast(
                 sdata,
                 coordinate_system=cs,
                 has_images=has_images and wants_images,
diff --git a/src/spatialdata_plot/pl/utils.py b/src/spatialdata_plot/pl/utils.py
index b65afac4..499b7889 100644
--- a/src/spatialdata_plot/pl/utils.py
+++ b/src/spatialdata_plot/pl/utils.py
@@ -4754,28 +4754,6 @@ def _is_axis_aligned(linear2x2: ArrayLike, *, rtol: float = 1e-9) -> bool:
     return bool((nz.sum(0) <= 1).all() and (nz.sum(1) <= 1).all() and int(nz.sum()) == m.shape[0])
 
 
-def _intrinsic_xy_bounds(element: Any) -> tuple[float, float, float, float] | None:
-    """``(xmin, ymin, xmax, ymax)`` of a shapes/points element in its intrinsic coords, vectorised.
-
-    Circles (``Point`` + ``radius``) expand by the radius; polygons use the vectorised ``.bounds``;
-    points read the x/y columns. NaN bounds of empty geometries are skipped by min/max, so no
-    per-geometry empty filter is needed. Returns ``None`` for unsupported element types.
-    """
-    model = get_model(element)
-    if model is ShapesModel:
-        geom = element.geometry
-        if (geom.geom_type == "Point").all():  # circles
-            x, y = geom.x.to_numpy(), geom.y.to_numpy()
-            r = np.asarray(element["radius"], dtype=float)
-            return float(np.nanmin(x - r)), float(np.nanmin(y - r)), float(np.nanmax(x + r)), float(np.nanmax(y + r))
-        b = geom.bounds  # vectorised; columns minx/miny/maxx/maxy
-        return float(b["minx"].min()), float(b["miny"].min()), float(b["maxx"].max()), float(b["maxy"].max())
-    if model is PointsModel:
-        x, y = element["x"], element["y"]
-        return float(x.min().compute()), float(y.min().compute()), float(x.max().compute()), float(y.max().compute())
-    return None
-
-
 def _element_extent_fast(element: Any, coordinate_system: str) -> dict[str, tuple[float, float]] | None:
     """Extent of one shapes/points element in ``coordinate_system`` via corner-transform.
 
@@ -4783,7 +4761,8 @@ def _element_extent_fast(element: Any, coordinate_system: str) -> dict[str, tupl
     unsupported or the transform is not axis-aligned (rotation/shear, where the cheap path would
     over-estimate). For circles it also falls back under an *anisotropic* linear map: a scaled circle
     is an ellipse, but spatialdata stores a single uniformly-scaled radius, so the cheap and exact
-    extents only agree when the scale is isotropic.
+    extents only agree when the scale is isotropic. Intrinsic bounds are read vectorised (no
+    per-geometry empty filter); NaN bounds of empty geometries are skipped by the reductions.
     """
     model = get_model(element)
     if model not in (ShapesModel, PointsModel):
@@ -4792,20 +4771,32 @@ def _element_extent_fast(element: Any, coordinate_system: str) -> dict[str, tupl
     affine = matrix[:2, :2]
     if not _is_axis_aligned(affine):
         return None
-    if model is ShapesModel and bool((element.geometry.geom_type == "Point").all()):  # circles
-        nz = np.abs(affine)[np.abs(affine) > 1e-9 * (np.abs(affine).max() or 1.0)]
-        if not np.allclose(nz, nz[0]):  # anisotropic -> radius handling diverges from spatialdata
-            return None
-    bounds = _intrinsic_xy_bounds(element)
-    if bounds is None:
-        return None
-    xmin, ymin, xmax, ymax = bounds
+
+    if model is PointsModel:
+        x, y = element["x"], element["y"]
+        xmin, ymin, xmax, ymax = (float(v) for v in dask.compute(x.min(), y.min(), x.max(), y.max()))
+    else:  # ShapesModel
+        geom = element.geometry
+        if (geom.geom_type == "Point").all():  # circles
+            a = np.abs(affine)
+            nz = a[a > 1e-9 * (a.max() or 1.0)]
+            if not np.allclose(nz, nz[0]):  # anisotropic -> radius handling diverges from spatialdata
+                return None
+            x, y = geom.x.to_numpy(), geom.y.to_numpy()
+            r = np.asarray(element["radius"], dtype=float)
+            xmin = float(np.nanmin(x - r))
+            ymin = float(np.nanmin(y - r))
+            xmax = float(np.nanmax(x + r))
+            ymax = float(np.nanmax(y + r))
+        else:  # polygons / multipolygons
+            xmin, ymin, xmax, ymax = (float(v) for v in geom.total_bounds)  # C-level union; skips empties
+
     corners = np.array([[xmin, ymin], [xmax, ymin], [xmin, ymax], [xmax, ymax]])
     tc = corners @ affine.T + matrix[:2, 2]
     return {"x": (float(tc[:, 0].min()), float(tc[:, 0].max())), "y": (float(tc[:, 1].min()), float(tc[:, 1].max()))}
 
 
-def get_extent_fast(
+def _get_extent_fast(
     sdata: SpatialData,
     coordinate_system: str,
     *,
diff --git a/tests/pl/test_utils.py b/tests/pl/test_utils.py
index 8617b8dd..be8bc0aa 100644
--- a/tests/pl/test_utils.py
+++ b/tests/pl/test_utils.py
@@ -682,7 +682,7 @@ def test_element_none_measures_single_table_elements(self, sdata_blobs: SpatialD
 
 
 class TestGetExtentFast:
-    """`get_extent_fast` matches spatialdata's `get_extent` while skipping the per-geometry transform."""
+    """`_get_extent_fast` matches spatialdata's `get_extent` while skipping the per-geometry transform."""
 
     @pytest.mark.parametrize(
         ("matrix", "expected"),
@@ -708,7 +708,7 @@ def test_matches_get_extent(self, sdata_blobs: SpatialData, element: str, kind:
         from spatialdata import get_extent
         from spatialdata.transformations import Affine, Scale, Translation, set_transformation
 
-        from spatialdata_plot.pl.utils import get_extent_fast
+        from spatialdata_plot.pl.utils import _get_extent_fast
 
         def _rot(theta: float) -> Affine:
             c, s = math.cos(theta), math.sin(theta)
@@ -726,7 +726,7 @@ def _rot(theta: float) -> Affine:
         set_transformation(sdata_blobs[element], transforms[kind], "cs")
         sub = SpatialData(shapes={element: sdata_blobs[element]})
         kw = dict(has_images=False, has_labels=False, has_points=False)
-        fast = get_extent_fast(sub, "cs", **kw)
+        fast = _get_extent_fast(sub, "cs", **kw)
         exact = get_extent(sub, "cs", exact=True, **kw)
         for ax in ("x", "y"):
             np.testing.assert_allclose(fast[ax], exact[ax], atol=1e-6)

From 4b9891c0ad18a4fabc12aca64be5a4e8138337ef Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Wed, 10 Jun 2026 14:30:19 +0200
Subject: [PATCH 14/28] perf(datashader): use _element_extent_fast for the
 shapes canvas extent

The datashader shapes canvas sized itself via spatialdata's exact get_extent, transforming every
geometry (O(N)) just for a bounding box -- the same cost _get_extent_fast already removed from
show()'s axis limits, in a second code path. Reuse _element_extent_fast (corner transform for
axis-aligned elements; None -> exact get_extent fallback for rotation/shear), so the result is
pixel-identical and the per-geometry pass is skipped for the common case.

Measured on Curio (69,713 colored shapes): render_shapes 3146 ms -> 1675 ms (1.88x), on top of
the get_extent_fast win already in show(). Mirrors _datashader_canvas_from_dataframe, which
already avoids get_extent for the points path.
---
 src/spatialdata_plot/pl/utils.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/spatialdata_plot/pl/utils.py b/src/spatialdata_plot/pl/utils.py
index 499b7889..7ab2303c 100644
--- a/src/spatialdata_plot/pl/utils.py
+++ b/src/spatialdata_plot/pl/utils.py
@@ -3912,7 +3912,11 @@ def _get_extent_and_range_for_datashader_canvas(
     coordinate_system: str,
     fig_params: FigParams,
 ) -> tuple[Any, Any, list[Any], list[Any], Any]:
-    extent = get_extent(spatial_element, coordinate_system=coordinate_system)
+    # The corner-transform fast path avoids transforming every geometry just to size the canvas;
+    # it is identical for axis-aligned transforms and returns None (-> exact get_extent) otherwise.
+    extent = _element_extent_fast(spatial_element, coordinate_system) or get_extent(
+        spatial_element, coordinate_system=coordinate_system
+    )
     x_ext = [float(extent["x"][0]), float(extent["x"][1])]
     y_ext = [float(extent["y"][0]), float(extent["y"][1])]
     return _compute_datashader_canvas_params(x_ext, y_ext, fig_params)

From ee2513e94a8bae92556cb6530db10a4c3ccbe69d Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Wed, 10 Jun 2026 18:50:33 +0200
Subject: [PATCH 15/28] fix(labels): correct as_points no-color rendering +
 validate size (code review)

From the perf-stack review of labels as_points:
- No color column collapsed every dot to a single na_color; now each cell gets a distinct random
  colour, matching the mask path's _map_color_seg Case C. Adds a color assertion to the regression test.
- The rasterize drop-filter only ran when a color column was set, so as_points could emit dots at NaN
  positions (or drop cells) when rasterization removed labels; extend it to as_points so point ids stay
  within the rendered raster.
- ax.scatter autoscales the Normalize in place; copy the shared cmap_params.norm (the shapes path already does).
- render_shapes/render_labels(as_points=True) did not validate size; add the points-path numeric/positive
  check so size=-5 / 'big' raise an actionable error instead of a raw matplotlib failure.
---
 src/spatialdata_plot/pl/basic.py  | 10 ++++++++++
 src/spatialdata_plot/pl/render.py | 18 ++++++++++++------
 tests/pl/test_render_labels.py    |  3 +++
 3 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/spatialdata_plot/pl/basic.py b/src/spatialdata_plot/pl/basic.py
index ffeb085e..2377edda 100644
--- a/src/spatialdata_plot/pl/basic.py
+++ b/src/spatialdata_plot/pl/basic.py
@@ -451,6 +451,11 @@ def render_shapes(
         sd.SpatialData
             A copy of the SpatialData object with the rendering parameters stored in its plotting tree.
         """
+        if as_points:
+            if isinstance(size, bool) or not isinstance(size, (int, float)):
+                raise TypeError("Parameter 'size' must be numeric.")
+            if size <= 0:
+                raise ValueError("Parameter 'size' must be a positive number.")
         panel_param_dicts = _expand_color_panels(
             self._sdata,
             color,
@@ -1051,6 +1056,11 @@ def render_labels(
         sd.SpatialData
             A copy of the SpatialData object with the rendering parameters stored in its plotting tree.
         """
+        if as_points:
+            if isinstance(size, bool) or not isinstance(size, (int, float)):
+                raise TypeError("Parameter 'size' must be numeric.")
+            if size <= 0:
+                raise ValueError("Parameter 'size' must be a positive number.")
         panel_param_dicts = _expand_color_panels(
             self._sdata,
             color,
diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index 8074cbbc..48a86728 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -2302,9 +2302,9 @@ def _render_labels(
             len(instance_id),
         )
 
-    # rasterize could have removed labels from label
-    # only problematic if color is specified
-    if rasterize and (col_for_color is not None or col_for_outline_color is not None):
+    # rasterize/downsampling can drop labels from the raster; remove their (now-absent) instance ids
+    # so per-instance colors stay aligned and as_points does not emit dots for dropped cells.
+    if rasterize and (col_for_color is not None or col_for_outline_color is not None or render_params.as_points):
         mask = np.isin(instance_id, unique_labels)
         instance_id = instance_id[mask]
         if col_for_color is not None:
@@ -2370,12 +2370,18 @@ def _render_labels(
         )
         # coerce so str/object table ids (e.g. Xenium) match the integer raster labels instead of NaN
         centroids = centroids.reindex(point_ids.astype(labels.dtype, copy=False))
-        # data-driven color is per-instance; literal/no-color is not -> one na color per centroid
         color_vec = np.asarray(color_vector)
-        if len(color_vec) == len(instance_id):
+        if col_for_color is None and not na_color.color_modified_by_user():
+            # no color column: one distinct random colour per cell, matching the mask path
+            # (`_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
+        elif len(color_vec) == len(instance_id):
+            # data-driven colour is per-instance
             point_color_vector = color_vec[keep]
             point_color_source_vector = None if color_source_vector is None else color_source_vector[keep]
         else:
+            # literal colour / user-set na_color -> one colour per centroid
             point_color_vector = np.asarray([na_color.get_hex_with_alpha()] * len(point_ids))
             point_color_source_vector = None
         _render_centroids_as_points(
@@ -2385,7 +2391,7 @@ def _render_labels(
             y=centroids["y"].to_numpy(),
             color_vector=point_color_vector,
             color_source_vector=point_color_source_vector,
-            norm=render_params.cmap_params.norm,
+            norm=copy(render_params.cmap_params.norm),  # ax.scatter autoscales in place; don't mutate the shared norm
             na_color=na_color,
             transform=trans_data,  # rendered-raster intrinsic coords -> coordinate system -> display
             adata=table if table_name is not None else None,
diff --git a/tests/pl/test_render_labels.py b/tests/pl/test_render_labels.py
index 6eada3f6..07d5a39d 100644
--- a/tests/pl/test_render_labels.py
+++ b/tests/pl/test_render_labels.py
@@ -634,6 +634,9 @@ def test_render_labels_as_points_without_color(sdata_blobs: SpatialData):
     offsets = np.asarray(ax.collections[0].get_offsets())
     n_cells = len(sd.get_centroids(sdata_blobs["blobs_labels"], coordinate_system="global").compute())
     assert len(offsets) == n_cells  # one dot per cell, no spurious background point
+    # without a color column, cells get distinct random colours (like the mask path), not one na_color
+    facecolors = ax.collections[0].get_facecolors()
+    assert len({tuple(np.round(c, 4)) for c in facecolors}) > 1
     plt.close(fig)
 
 

From 158b10870eeb74978f8b9957d3f98c8452a8352c Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Wed, 10 Jun 2026 19:01:41 +0200
Subject: [PATCH 16/28] refactor(labels): dedup as_points size validation, lazy
 color conversion

Extract the duplicated as_points size-validation block from render_shapes
and render_labels into a shared _validate_as_points_size helper. Defer the
np.asarray(color_vector) conversion in the centroid color path to the only
branch that uses it.
---
 src/spatialdata_plot/pl/basic.py  | 11 +++--------
 src/spatialdata_plot/pl/render.py |  5 ++---
 src/spatialdata_plot/pl/utils.py  |  8 ++++++++
 3 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/spatialdata_plot/pl/basic.py b/src/spatialdata_plot/pl/basic.py
index 2377edda..d9ddc044 100644
--- a/src/spatialdata_plot/pl/basic.py
+++ b/src/spatialdata_plot/pl/basic.py
@@ -72,6 +72,7 @@
     _prepare_cmap_norm,
     _prepare_params_plot,
     _set_outline,
+    _validate_as_points_size,
     _validate_graph_render_params,
     _validate_image_render_params,
     _validate_label_render_params,
@@ -452,10 +453,7 @@ def render_shapes(
             A copy of the SpatialData object with the rendering parameters stored in its plotting tree.
         """
         if as_points:
-            if isinstance(size, bool) or not isinstance(size, (int, float)):
-                raise TypeError("Parameter 'size' must be numeric.")
-            if size <= 0:
-                raise ValueError("Parameter 'size' must be a positive number.")
+            _validate_as_points_size(size)
         panel_param_dicts = _expand_color_panels(
             self._sdata,
             color,
@@ -1057,10 +1055,7 @@ def render_labels(
             A copy of the SpatialData object with the rendering parameters stored in its plotting tree.
         """
         if as_points:
-            if isinstance(size, bool) or not isinstance(size, (int, float)):
-                raise TypeError("Parameter 'size' must be numeric.")
-            if size <= 0:
-                raise ValueError("Parameter 'size' must be a positive number.")
+            _validate_as_points_size(size)
         panel_param_dicts = _expand_color_panels(
             self._sdata,
             color,
diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index 48a86728..c0e8ebc1 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -2370,15 +2370,14 @@ def _render_labels(
         )
         # coerce so str/object table ids (e.g. Xenium) match the integer raster labels instead of NaN
         centroids = centroids.reindex(point_ids.astype(labels.dtype, copy=False))
-        color_vec = np.asarray(color_vector)
         if col_for_color is None and not na_color.color_modified_by_user():
             # no color column: one distinct random colour per cell, matching the mask path
             # (`_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
-        elif len(color_vec) == len(instance_id):
+        elif len(color_vector) == len(instance_id):
             # data-driven colour is per-instance
-            point_color_vector = color_vec[keep]
+            point_color_vector = np.asarray(color_vector)[keep]
             point_color_source_vector = None if color_source_vector is None else color_source_vector[keep]
         else:
             # literal colour / user-set na_color -> one colour per centroid
diff --git a/src/spatialdata_plot/pl/utils.py b/src/spatialdata_plot/pl/utils.py
index 7ab2303c..48063c6f 100644
--- a/src/spatialdata_plot/pl/utils.py
+++ b/src/spatialdata_plot/pl/utils.py
@@ -3078,6 +3078,14 @@ def _expand_color_panels(
     return panel_param_dicts
 
 
+def _validate_as_points_size(size: float) -> None:
+    """Validate the centroid marker `size` used by ``render_shapes``/``render_labels`` with ``as_points=True``."""
+    if isinstance(size, bool) or not isinstance(size, (int, float)):
+        raise TypeError("Parameter 'size' must be numeric.")
+    if size <= 0:
+        raise ValueError("Parameter 'size' must be a positive number.")
+
+
 def _validate_label_render_params(
     sdata: sd.SpatialData,
     element: str | None,

From ae2f1248f914381d5e36966a156cf421fc6e44cf Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Wed, 10 Jun 2026 19:13:31 +0200
Subject: [PATCH 17/28] perf(extent): reuse fetched transformations in
 _element_extent_fast

_get_extent_fast already reads get_transformation(element, get_all=True) for
the coordinate-system membership check; pass it through so the fast path does
not re-fetch it per element. The optional kwarg leaves the datashader-canvas
call site unchanged.
---
 src/spatialdata_plot/pl/utils.py | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/spatialdata_plot/pl/utils.py b/src/spatialdata_plot/pl/utils.py
index cb07307e..89f5758c 100644
--- a/src/spatialdata_plot/pl/utils.py
+++ b/src/spatialdata_plot/pl/utils.py
@@ -4822,7 +4822,9 @@ def _is_axis_aligned(linear2x2: ArrayLike, *, rtol: float = 1e-9) -> bool:
     return bool((nz.sum(0) <= 1).all() and (nz.sum(1) <= 1).all() and int(nz.sum()) == m.shape[0])
 
 
-def _element_extent_fast(element: Any, coordinate_system: str) -> dict[str, tuple[float, float]] | None:
+def _element_extent_fast(
+    element: Any, coordinate_system: str, *, transformations: Mapping[str, Any] | None = None
+) -> dict[str, tuple[float, float]] | None:
     """Extent of one shapes/points element in ``coordinate_system`` via corner-transform.
 
     Returns ``None`` (signalling the caller to fall back to ``get_extent``) when the element type is
@@ -4831,11 +4833,16 @@ def _element_extent_fast(element: Any, coordinate_system: str) -> dict[str, tupl
     is an ellipse, but spatialdata stores a single uniformly-scaled radius, so the cheap and exact
     extents only agree when the scale is isotropic. Intrinsic bounds are read vectorised (no
     per-geometry empty filter); NaN bounds of empty geometries are skipped by the reductions.
+
+    ``transformations`` may pass a pre-fetched ``get_transformation(element, get_all=True)`` to avoid
+    re-reading it when the caller already has it.
     """
     model = get_model(element)
     if model not in (ShapesModel, PointsModel):
         return None
-    matrix = get_transformation(element, get_all=True)[coordinate_system].to_affine_matrix(("x", "y"), ("x", "y"))
+    if transformations is None:
+        transformations = get_transformation(element, get_all=True)
+    matrix = transformations[coordinate_system].to_affine_matrix(("x", "y"), ("x", "y"))
     affine = matrix[:2, :2]
     if not _is_axis_aligned(affine):
         return None
@@ -4890,9 +4897,14 @@ def _get_extent_fast(
         for name, element in edict.items():
             if elements is not None and name not in elements:
                 continue
-            if coordinate_system not in get_transformation(element, get_all=True):
+            transformations = get_transformation(element, get_all=True)
+            if coordinate_system not in transformations:
                 continue
-            ext = _element_extent_fast(element, coordinate_system) if etype in ("shapes", "points") else None
+            ext = (
+                _element_extent_fast(element, coordinate_system, transformations=transformations)
+                if etype in ("shapes", "points")
+                else None
+            )
             if ext is None:  # rotation/shear, image/label (already cheap), or unsupported
                 ext = get_extent(element, coordinate_system=coordinate_system)
             for ax in ("x", "y"):

From 6b78f38724b0cf135cccb2f2fd710f2a0c68f0ee Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Wed, 10 Jun 2026 19:26:14 +0200
Subject: [PATCH 18/28] fix(extent): defer all-empty elements to get_extent;
 trim comments

_element_extent_fast returned a NaN extent for an element whose geometries are
all empty, which silently poisoned the union in _get_extent_fast (blank axes)
instead of raising spatialdata's clear 'empty collection' error. Guard against
non-finite bounds and fall back. Also trims the verbose extent-block comment and
the scatter/centroid docstrings (net -12 LOC, no behavior change).
---
 src/spatialdata_plot/pl/basic.py  |  4 +---
 src/spatialdata_plot/pl/render.py | 11 ++++-------
 src/spatialdata_plot/pl/utils.py  | 27 ++++++++++-----------------
 3 files changed, 15 insertions(+), 27 deletions(-)

diff --git a/src/spatialdata_plot/pl/basic.py b/src/spatialdata_plot/pl/basic.py
index d9ddc044..2170189b 100644
--- a/src/spatialdata_plot/pl/basic.py
+++ b/src/spatialdata_plot/pl/basic.py
@@ -1834,9 +1834,7 @@ def _draw_colorbar(
                         "all geometries are empty. Drop the element or restore at least one non-empty geometry."
                     )
 
-            # `_get_extent_fast` skips transforming every shapes/points geometry when the element's
-            # transform is axis-aligned (the common scale+translation case); identical result, but
-            # avoids the O(N-geometries) bottleneck for large shape collections.
+            # fast path for axis-aligned transforms; identical result, falls back to get_extent otherwise
             extent = _get_extent_fast(
                 sdata,
                 coordinate_system=cs,
diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index 56f6bdda..d165f603 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -1092,9 +1092,8 @@ def _scatter_points(
 ) -> Any:
     """Draw one marker per (x, y) colored by ``color_vector`` via ``ax.scatter``.
 
-    Shared matplotlib scatter primitive: used by ``_render_points`` and (later) by the
-    centroid-point "fast" rendering of shapes/labels. ``color_vector`` is per-point hex
-    strings (categorical) or numeric values mapped through ``cmap``/``norm`` (continuous).
+    Shared scatter primitive for points and the centroid "fast mode" of shapes/labels;
+    ``color_vector`` is per-point hex strings or numeric values mapped through ``cmap``/``norm``.
     """
     return ax.scatter(
         x,
@@ -1131,10 +1130,8 @@ def _render_centroids_as_points(
 ) -> None:
     """Render one dot per cell at ``(x, y)`` colored like the fill, with legend/colorbar.
 
-    Shared "fast mode" draw for shapes/labels: cmap/size/alpha/zorder/colorbar come off
-    ``render_params``; ``color_vector`` is the same per-instance color vector the geometry/raster
-    path would use, so colors match the full rendering exactly. ``norm``/``na_color`` stay explicit
-    because they differ between the shapes (locally adjusted) and labels paths.
+    Shared "fast mode" draw for shapes/labels; style comes off ``render_params``. ``norm``/``na_color``
+    stay explicit because they differ between the shapes (locally adjusted) and labels paths.
     """
     cax = _scatter_points(
         ax,
diff --git a/src/spatialdata_plot/pl/utils.py b/src/spatialdata_plot/pl/utils.py
index 89f5758c..a0230850 100644
--- a/src/spatialdata_plot/pl/utils.py
+++ b/src/spatialdata_plot/pl/utils.py
@@ -4800,14 +4800,10 @@ def measure_obs(
 
 
 # --- Fast extent for axis-aligned transforms ------------------------------------------------------
-# `pl.show()` computes axis bounds via spatialdata's `get_extent(..., exact=True)`, which transforms
-# EVERY shapes/points geometry into the coordinate system (per-geometry, O(N)) just to take a bounding
-# box — the dominant cost when rendering large shape collections. When the element's transform is
-# axis-aligned (scale / flip / 90deg rotation / axis swap + translation), the exact extent equals the
-# bounding box of the *transformed corners* (spatialdata's own get_extent docstring notes this), so we
-# can transform 4 corners instead of N geometries, and read the intrinsic bounds vectorised (avoiding
-# spatialdata's per-geometry `.apply(is_empty)` filter). This whole block is self-contained so it can
-# be lifted into spatialdata's `get_extent` verbatim; it falls back to `get_extent` for rotation/shear.
+# spatialdata's `get_extent(..., exact=True)` transforms every shapes/points geometry (O(N)) just to
+# take a bounding box. For an axis-aligned transform (scale/flip/90deg-rotation/axis-swap + translation)
+# the exact extent equals the bbox of the *transformed corners*, so we transform 4 corners instead;
+# rotation/shear and other element types fall back to `get_extent`. Self-contained for upstreaming.
 
 
 def _is_axis_aligned(linear2x2: ArrayLike, *, rtol: float = 1e-9) -> bool:
@@ -4827,15 +4823,10 @@ def _element_extent_fast(
 ) -> dict[str, tuple[float, float]] | None:
     """Extent of one shapes/points element in ``coordinate_system`` via corner-transform.
 
-    Returns ``None`` (signalling the caller to fall back to ``get_extent``) when the element type is
-    unsupported or the transform is not axis-aligned (rotation/shear, where the cheap path would
-    over-estimate). For circles it also falls back under an *anisotropic* linear map: a scaled circle
-    is an ellipse, but spatialdata stores a single uniformly-scaled radius, so the cheap and exact
-    extents only agree when the scale is isotropic. Intrinsic bounds are read vectorised (no
-    per-geometry empty filter); NaN bounds of empty geometries are skipped by the reductions.
-
-    ``transformations`` may pass a pre-fetched ``get_transformation(element, get_all=True)`` to avoid
-    re-reading it when the caller already has it.
+    Returns ``None`` to fall back to ``get_extent`` for an unsupported type, a non-axis-aligned
+    transform, or an anisotropically-scaled circle (an ellipse, but spatialdata stores one radius, so
+    cheap and exact agree only under isotropic scale). ``transformations`` may pass a pre-fetched
+    ``get_transformation(element, get_all=True)`` to avoid re-reading it.
     """
     model = get_model(element)
     if model not in (ShapesModel, PointsModel):
@@ -4866,6 +4857,8 @@ def _element_extent_fast(
         else:  # polygons / multipolygons
             xmin, ymin, xmax, ymax = (float(v) for v in geom.total_bounds)  # C-level union; skips empties
 
+    if not np.isfinite((xmin, ymin, xmax, ymax)).all():  # all-empty element: defer to get_extent's clear error
+        return None
     corners = np.array([[xmin, ymin], [xmax, ymin], [xmin, ymax], [xmax, ymax]])
     tc = corners @ affine.T + matrix[:2, 2]
     return {"x": (float(tc[:, 0].min()), float(tc[:, 0].max())), "y": (float(tc[:, 1].min()), float(tc[:, 1].max()))}

From ddb4cc5125b5c5d5f8a45e52f2e8575c4a0f8729 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Wed, 10 Jun 2026 19:38:00 +0200
Subject: [PATCH 19/28] test(as_points): add visual tests for shapes/labels
 centroid mode + size

Four PlotTester baselines: render_shapes/labels(as_points=True) at a base size
and a larger size (size = scatter marker area). Baselines to be generated from CI.
---
 tests/pl/test_render_labels.py | 8 ++++++++
 tests/pl/test_render_shapes.py | 8 ++++++++
 2 files changed, 16 insertions(+)

diff --git a/tests/pl/test_render_labels.py b/tests/pl/test_render_labels.py
index 07d5a39d..c38f4d5f 100644
--- a/tests/pl/test_render_labels.py
+++ b/tests/pl/test_render_labels.py
@@ -435,6 +435,14 @@ def test_plot_can_color_labels_by_gene_symbols(self, sdata_blobs: SpatialData):
             "blobs_labels", color="GeneA", table_name="table", gene_symbols="gene_symbol"
         ).pl.show()
 
+    def test_plot_can_render_labels_as_points(self, sdata_blobs: SpatialData):
+        """as_points draws one colored dot per label at its centroid instead of the mask."""
+        sdata_blobs.pl.render_labels("blobs_labels", color="instance_id", as_points=True, size=100).pl.show()
+
+    def test_plot_labels_as_points_respects_size(self, sdata_blobs: SpatialData):
+        """size sets the scatter marker area; larger size -> larger dots."""
+        sdata_blobs.pl.render_labels("blobs_labels", color="instance_id", as_points=True, size=600).pl.show()
+
 
 def test_raises_when_table_does_not_annotate_element(sdata_blobs: SpatialData):
     # Work on an independent copy since we mutate tables
diff --git a/tests/pl/test_render_shapes.py b/tests/pl/test_render_shapes.py
index 27fc762c..ce502ca2 100644
--- a/tests/pl/test_render_shapes.py
+++ b/tests/pl/test_render_shapes.py
@@ -1108,6 +1108,14 @@ def test_plot_can_color_shapes_by_gene_symbols(self, sdata_blobs: SpatialData):
             "blobs_circles", color="GeneA", table_name="table", gene_symbols="gene_symbol"
         ).pl.show()
 
+    def test_plot_can_render_circles_as_points(self, sdata_blobs: SpatialData):
+        """as_points draws one dot per shape at its centroid instead of the geometry."""
+        sdata_blobs.pl.render_shapes("blobs_circles", as_points=True, size=100).pl.show()
+
+    def test_plot_shapes_as_points_respects_size(self, sdata_blobs: SpatialData):
+        """size sets the scatter marker area; larger size -> larger dots."""
+        sdata_blobs.pl.render_shapes("blobs_circles", as_points=True, size=600).pl.show()
+
 
 def test_gene_symbols_auto_detect_table(sdata_blobs: SpatialData):
     """gene_symbols resolves correctly without explicit table_name (#247)."""

From 1e884953d2ebcad717499975dc0272355674c3a3 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Wed, 10 Jun 2026 20:13:27 +0200
Subject: [PATCH 20/28] test(as_points): add CI-generated baselines for the 4
 as_points visual tests

Rendered on hatch-test.py3.11-stable; verified dots land at shape/label
centroids, colored by instance_id (labels), larger at size=600.
---
 .../Labels_can_render_labels_as_points.png      | Bin 0 -> 32708 bytes
 .../Labels_labels_as_points_respects_size.png   | Bin 0 -> 46243 bytes
 .../Shapes_can_render_circles_as_points.png     | Bin 0 -> 16548 bytes
 .../Shapes_shapes_as_points_respects_size.png   | Bin 0 -> 17584 bytes
 4 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 tests/_images/Labels_can_render_labels_as_points.png
 create mode 100644 tests/_images/Labels_labels_as_points_respects_size.png
 create mode 100644 tests/_images/Shapes_can_render_circles_as_points.png
 create mode 100644 tests/_images/Shapes_shapes_as_points_respects_size.png

diff --git a/tests/_images/Labels_can_render_labels_as_points.png b/tests/_images/Labels_can_render_labels_as_points.png
new file mode 100644
index 0000000000000000000000000000000000000000..405d744a832ea300d9d19e4a9aac90918ae4d084
GIT binary patch
literal 32708
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

literal 0
HcmV?d00001

diff --git a/tests/_images/Labels_labels_as_points_respects_size.png b/tests/_images/Labels_labels_as_points_respects_size.png
new file mode 100644
index 0000000000000000000000000000000000000000..305c0d95778758ebbbc4f660587b96cf9acd78e8
GIT binary patch
literal 46243
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

literal 0
HcmV?d00001

diff --git a/tests/_images/Shapes_can_render_circles_as_points.png b/tests/_images/Shapes_can_render_circles_as_points.png
new file mode 100644
index 0000000000000000000000000000000000000000..d6b8d3fbb4e82f74de5cdd7e2c8efd7301b8d743
GIT binary patch
literal 16548
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
Lx?G8@Y0&=wS&Jx5

literal 0
HcmV?d00001

diff --git a/tests/_images/Shapes_shapes_as_points_respects_size.png b/tests/_images/Shapes_shapes_as_points_respects_size.png
new file mode 100644
index 0000000000000000000000000000000000000000..69451763e04c7857031d6cd11cf97a0b1ae9fc17
GIT binary patch
literal 17584
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

literal 0
HcmV?d00001


From 97c5624be30226e9cbc0dc55813c06ff10525d06 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Thu, 11 Jun 2026 00:51:55 +0200
Subject: [PATCH 21/28] perf(shapes): vectorize the all-empty-geometry guard in
 show()

The empty-shape check ran a per-geometry Python lambda (`.apply(lambda g: not
g.is_empty)`) over every geometry on every shapes render; GeoSeries.is_empty is
GEOS-vectorized. `.is_empty.all()` is identical and ~134x faster on this guard
(665ms -> 5ms at 351k shapes, ~10s -> 80ms at 5.5M).
---
 src/spatialdata_plot/pl/basic.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/spatialdata_plot/pl/basic.py b/src/spatialdata_plot/pl/basic.py
index 2170189b..93e92a91 100644
--- a/src/spatialdata_plot/pl/basic.py
+++ b/src/spatialdata_plot/pl/basic.py
@@ -1826,7 +1826,7 @@ def _draw_colorbar(
                 empty_shape_elements = [
                     name
                     for name in wanted_elements
-                    if name in sdata.shapes and not sdata.shapes[name]["geometry"].apply(lambda g: not g.is_empty).any()
+                    if name in sdata.shapes and sdata.shapes[name]["geometry"].is_empty.all()
                 ]
                 if empty_shape_elements:
                     raise ValueError(

From 4c0c478a8e77138a1f69b45c78f63979075669cc Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Thu, 11 Jun 2026 03:19:52 +0200
Subject: [PATCH 22/28] refactor(points): extract _datashader_points from
 _render_points

Shared datashader draw primitive (canvas->aggregate->norm->color-key->shade->
image->colorbar), taking explicit primitives instead of render_params so it can
also serve the as_points centroid path (shapes/labels params use fill_alpha and
lack the density fields). Returns the possibly-recomputed color vectors so the
caller's legend/colorbar stays identical. Verified pixel-identical on
render_points datashader (categorical/continuous/plain/density).
---
 src/spatialdata_plot/pl/render.py | 265 ++++++++++++++++--------------
 1 file changed, 143 insertions(+), 122 deletions(-)

diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index d165f603..9d1463de 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -1163,6 +1163,134 @@ def _render_centroids_as_points(
     )
 
 
+def _datashader_points(
+    ax: matplotlib.axes.SubplotBase,
+    df: pd.DataFrame,
+    *,
+    col_for_color: str | None,
+    color_vector: Any,
+    color_source_vector: Any,
+    norm: Normalize | None,
+    cmap_params: CmapParams,
+    alpha: float,
+    size: float,
+    zorder: int,
+    ds_reduction: _DsReduction | None,
+    density: bool,
+    density_how: str,
+    fig_params: FigParams,
+    default_reduction: _DsReduction = "sum",
+) -> tuple[Any, Any, Any]:
+    """Datashade an x/y(+color) point frame onto ``ax``; returns ``(cax, color_vector, color_source_vector)``.
+
+    Shared datashader draw for ``render_points`` and the centroid "fast mode" of shapes/labels. ``df``
+    holds ``x``/``y`` in coordinate-system coords (+ an optional color column). The (possibly
+    recomputed) color vectors are returned so the caller's legend/colorbar uses the same values.
+    Primitives are taken explicitly rather than a ``render_params`` because shapes/labels params use
+    ``fill_alpha`` and lack the density fields.
+    """
+    # NOTE: s in matplotlib is in units of points**2; use dpi/100 so dpi!=100 still spreads correctly.
+    # Under density, spreading would smear the count signal across pixels, so disable it.
+    px: int | None = None if density else int(np.round(np.sqrt(size) * (fig_params.fig.dpi / 100)))
+
+    plot_width, plot_height, x_ext, y_ext, factor = _datashader_canvas_from_dataframe(df, fig_params)
+    cvs = ds.Canvas(plot_width=plot_width, plot_height=plot_height, x_range=x_ext, y_range=y_ext)
+
+    # ensure color column exists on the frame with positional alignment
+    if col_for_color is not None and col_for_color not in df.columns:
+        series_index = df.index
+        if color_source_vector is not None:
+            if isinstance(color_source_vector, dd.Series):
+                color_source_vector = color_source_vector.compute()
+            source_series = (
+                color_source_vector.reindex(series_index)
+                if isinstance(color_source_vector, pd.Series)
+                else pd.Series(color_source_vector, index=series_index)
+            )
+            df[col_for_color] = source_series
+        else:
+            if isinstance(color_vector, dd.Series):
+                color_vector = color_vector.compute()
+            color_series = (
+                color_vector.reindex(series_index)
+                if isinstance(color_vector, pd.Series)
+                else pd.Series(color_vector, index=series_index)
+            )
+            df[col_for_color] = color_series
+
+    color_dtype = df[col_for_color].dtype if col_for_color is not None else None
+    color_by_categorical = col_for_color is not None and (
+        color_source_vector is not None
+        or isinstance(color_dtype, pd.CategoricalDtype)
+        or pd.api.types.is_object_dtype(color_dtype)
+        or pd.api.types.is_string_dtype(color_dtype)
+    )
+    if color_by_categorical and not isinstance(color_dtype, pd.CategoricalDtype):
+        df[col_for_color] = df[col_for_color].astype("category")
+
+    agg, reduction_bounds, nan_agg = _ds_aggregate(
+        cvs,
+        df,
+        col_for_color,
+        color_by_categorical,
+        ds_reduction,
+        default_reduction,
+        "points",
+    )
+
+    agg, color_span = _apply_ds_norm(agg, norm)
+    na_color_hex = _hex_no_alpha(cmap_params.na_color.get_hex())
+    if cmap_params.na_color.is_fully_transparent():
+        nan_agg = None
+    color_key = _build_color_key(df, col_for_color, color_by_categorical, color_vector, na_color_hex)
+
+    if (
+        color_vector is not None
+        and len(color_vector) > 0
+        and isinstance(color_vector[0], str)
+        and color_vector[0].startswith("#")
+    ):
+        # color_vector usually holds only a few distinct hex strings (one per category), so strip
+        # alpha on the unique values and map back rather than parsing once per point.
+        unique_hex, inverse = np.unique(color_vector, return_inverse=True)
+        color_vector = np.asarray([_hex_no_alpha(c) for c in unique_hex])[inverse]
+
+    shade_how = density_how if density else "linear"
+    # Plain density (no color column) uses the cmap as a sequential gradient over counts; the
+    # categorical path collapses to a single color and only modulates alpha.
+    plain_density = density and col_for_color is None
+
+    nan_shaded = None
+    if not plain_density and (color_by_categorical or col_for_color is None):
+        shaded = _ds_shade_categorical(
+            agg,
+            color_key,
+            color_vector,
+            alpha,
+            spread_px=px,
+            how=shade_how,
+            density=density,
+        )
+    else:
+        shaded, nan_shaded, reduction_bounds = _ds_shade_continuous(
+            agg,
+            color_span,
+            norm,
+            cmap_params.cmap,
+            alpha,
+            reduction_bounds,
+            nan_agg,
+            na_color_hex,
+            spread_px=px,
+            ds_reduction=ds_reduction,
+            how=shade_how,
+        )
+
+    _render_ds_image(ax, shaded, factor, zorder, x_min=x_ext[0], y_min=y_ext[0], nan_result=nan_shaded)
+    cax = _build_ds_colorbar(reduction_bounds, norm, cmap_params.cmap)
+    return cax, color_vector, color_source_vector
+
+
 def _render_points(
     sdata: sd.SpatialData,
     render_params: PointsRenderParams,
@@ -1373,14 +1501,6 @@ def _render_points(
     if method == "datashader":
         _log_datashader_method(method, render_params.ds_reduction, _default_reduction)
 
-        # NOTE: s in matplotlib is in units of points**2
-        # use dpi/100 as a factor for cases where dpi!=100
-        # Under density, spreading would smear the count signal across pixels and
-        # distort apparent density at sparse edges, so disable it unconditionally.
-        px: int | None = (
-            None if render_params.density else int(np.round(np.sqrt(render_params.size) * (fig_params.fig.dpi / 100)))
-        )
-
         # Apply transformations and materialize to pandas immediately so
         # datashader aggregates without dask scheduler overhead.  See #379.
         transformed_element = PointsModel.parse(
@@ -1395,123 +1515,24 @@ def _render_points(
             # any other elements on the axes.
             return
 
-        plot_width, plot_height, x_ext, y_ext, factor = _datashader_canvas_from_dataframe(
-            transformed_element, fig_params
-        )
-
-        # use datashader for the visualization of points
-        cvs = ds.Canvas(plot_width=plot_width, plot_height=plot_height, x_range=x_ext, y_range=y_ext)
-
-        # ensure color column exists on the transformed element with positional alignment
-        if col_for_color is not None and col_for_color not in transformed_element.columns:
-            series_index = transformed_element.index
-            if color_source_vector is not None:
-                if isinstance(color_source_vector, dd.Series):
-                    color_source_vector = color_source_vector.compute()
-                source_series = (
-                    color_source_vector.reindex(series_index)
-                    if isinstance(color_source_vector, pd.Series)
-                    else pd.Series(color_source_vector, index=series_index)
-                )
-                transformed_element[col_for_color] = source_series
-            else:
-                if isinstance(color_vector, dd.Series):
-                    color_vector = color_vector.compute()
-                color_series = (
-                    color_vector.reindex(series_index)
-                    if isinstance(color_vector, pd.Series)
-                    else pd.Series(color_vector, index=series_index)
-                )
-                transformed_element[col_for_color] = color_series
-
-        color_dtype = transformed_element[col_for_color].dtype if col_for_color is not None else None
-        color_by_categorical = col_for_color is not None and (
-            color_source_vector is not None
-            or isinstance(color_dtype, pd.CategoricalDtype)
-            or pd.api.types.is_object_dtype(color_dtype)
-            or pd.api.types.is_string_dtype(color_dtype)
-        )
-        if color_by_categorical and not isinstance(color_dtype, pd.CategoricalDtype):
-            transformed_element[col_for_color] = transformed_element[col_for_color].astype("category")
-
-        agg, reduction_bounds, nan_agg = _ds_aggregate(
-            cvs,
-            transformed_element,
-            col_for_color,
-            color_by_categorical,
-            render_params.ds_reduction,
-            _default_reduction,
-            "points",
-        )
-
-        agg, color_span = _apply_ds_norm(agg, norm)
-        na_color_hex = _hex_no_alpha(render_params.cmap_params.na_color.get_hex())
-        if render_params.cmap_params.na_color.is_fully_transparent():
-            nan_agg = None
-        color_key = _build_color_key(
-            transformed_element,
-            col_for_color,
-            color_by_categorical,
-            color_vector,
-            na_color_hex,
-        )
-
-        if (
-            color_vector is not None
-            and len(color_vector) > 0
-            and isinstance(color_vector[0], str)
-            and color_vector[0].startswith("#")
-        ):
-            # color_vector usually holds only a few distinct hex strings (one per
-            # category), so strip alpha on the unique values and map back rather than
-            # calling the per-string parser once per point.
-            unique_hex, inverse = np.unique(color_vector, return_inverse=True)
-            color_vector = np.asarray([_hex_no_alpha(c) for c in unique_hex])[inverse]
-
-        shade_how = render_params.density_how if render_params.density else "linear"
-        # Plain density (no color column) must use the user-facing cmap as a sequential
-        # gradient over counts; the categorical path collapses to a single color and only
-        # modulates alpha, which renders as a flat hue regardless of density.
-        plain_density = render_params.density and col_for_color is None
-
-        nan_shaded = None
-        if not plain_density and (color_by_categorical or col_for_color is None):
-            shaded = _ds_shade_categorical(
-                agg,
-                color_key,
-                color_vector,
-                render_params.alpha,
-                spread_px=px,
-                how=shade_how,
-                density=render_params.density,
-            )
-        else:
-            shaded, nan_shaded, reduction_bounds = _ds_shade_continuous(
-                agg,
-                color_span,
-                norm,
-                render_params.cmap_params.cmap,
-                render_params.alpha,
-                reduction_bounds,
-                nan_agg,
-                na_color_hex,
-                spread_px=px,
-                ds_reduction=render_params.ds_reduction,
-                how=shade_how,
-            )
-
-        _render_ds_image(
+        cax, color_vector, color_source_vector = _datashader_points(
             ax,
-            shaded,
-            factor,
-            render_params.zorder,
-            x_min=x_ext[0],
-            y_min=y_ext[0],
-            nan_result=nan_shaded,
+            transformed_element,
+            col_for_color=col_for_color,
+            color_vector=color_vector,
+            color_source_vector=color_source_vector,
+            norm=norm,
+            cmap_params=render_params.cmap_params,
+            alpha=render_params.alpha,
+            size=render_params.size,
+            zorder=render_params.zorder,
+            ds_reduction=render_params.ds_reduction,
+            density=render_params.density,
+            density_how=render_params.density_how,
+            fig_params=fig_params,
+            default_reduction=_default_reduction,
         )
 
-        cax = _build_ds_colorbar(reduction_bounds, norm, render_params.cmap_params.cmap)
-
     elif method == "matplotlib":
         # update axis limits if plot was empty before (necessary if datashader comes after)
         update_parameters = not _mpl_ax_contains_elements(ax)

From 5854ae6d564a5ef9d25ceae644eb6e8f92ecd852 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Thu, 11 Jun 2026 03:47:44 +0200
Subject: [PATCH 23/28] feat(as_points): datashader backend + fix shapes
 centroid coordinates
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Route as_points centroids through the shared _datashader_points when method=
  'datashader' or above ~500k dots (AS_POINTS_DS_AUTO); matplotlib otherwise.
- No-color labels (one random colour per cell) cannot be aggregated by datashader;
  force matplotlib there (warn on explicit method='datashader').
- Fix: shapes as_points drew dots at intrinsic centroid coords while the axes are
  in coordinate-system coords, so non-identity transforms misplaced them. Transform
  centroids to CS via the element->CS affine for both backends (labels too).
- render_labels gains 'method'; LabelsRenderParams gains 'method'. as_points uses a
  fixed datashader reduction ('max', closest to matplotlib) — no user knob.
---
 src/spatialdata_plot/pl/basic.py         |   6 ++
 src/spatialdata_plot/pl/render.py        | 103 ++++++++++++++++++-----
 src/spatialdata_plot/pl/render_params.py |   2 +
 3 files changed, 89 insertions(+), 22 deletions(-)

diff --git a/src/spatialdata_plot/pl/basic.py b/src/spatialdata_plot/pl/basic.py
index 93e92a91..89b6292c 100644
--- a/src/spatialdata_plot/pl/basic.py
+++ b/src/spatialdata_plot/pl/basic.py
@@ -963,6 +963,7 @@ def render_labels(
         transfunc: Callable[[float], float] | None = None,
         as_points: bool = False,
         size: float | int = 1.0,
+        method: str | None = None,
     ) -> sd.SpatialData:
         """
         Render labels elements in SpatialData.
@@ -1048,6 +1049,10 @@ def render_labels(
             in another column of ``var``. Mimics scanpy's ``gene_symbols`` parameter.
         transfunc : Callable[[float], float] | None, optional
             Optional transformation applied to the continuous color vector before normalization and colormap mapping.
+        method : str | None, optional
+            Backend for ``as_points`` centroids: ``'matplotlib'`` or ``'datashader'``. When ``None``,
+            matplotlib is used unless there are more than ~500k centroids. Datashader is skipped (with a
+            warning) when the colouring cannot be aggregated (e.g. labels with no color column).
 
         Returns
         -------
@@ -1115,6 +1120,7 @@ def render_labels(
                     colorbar_params=param_values["colorbar_params"],
                     as_points=as_points,
                     size=size,
+                    method=method,
                     panel_key=panel_key,
                 )
                 n_steps += 1
diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index 9d1463de..8ed88ac9 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -757,16 +757,17 @@ def _render_shapes(
         # Fast mode: draw one dot per shape at its centroid instead of its geometry.
         logger.info("`as_points=True`: rendering shape centroids; `outline_*` and `shape` are ignored.")
         centroids = shapes.geometry.centroid  # intrinsic coords, positionally aligned to color_vector
+        # transform to coordinate-system coords so dots land correctly under non-identity transforms
+        xy = trans.transform(np.column_stack([centroids.x.to_numpy(), centroids.y.to_numpy()]))
         _render_centroids_as_points(
             ax,
             render_params,
-            x=centroids.x.to_numpy(),
-            y=centroids.y.to_numpy(),
+            x=xy[:, 0],
+            y=xy[:, 1],
             color_vector=color_vector,
             color_source_vector=color_source_vector,
             norm=norm,
             na_color=render_params.cmap_params.na_color,
-            transform=trans_data,  # intrinsic -> coordinate system -> display
             adata=table,
             col_for_color=col_for_color,
             palette=palette,
@@ -1110,6 +1111,34 @@ def _scatter_points(
     )
 
 
+# as_points: matplotlib draws crisp markers; above this many dots its per-glyph draw dominates
+# (≈18 µs/dot), so auto-switch to datashader. Datashader changes appearance (density raster), so
+# the threshold is conservative and only applies when the user did not pick a backend explicitly.
+AS_POINTS_DS_AUTO = 500_000
+
+
+def _resolve_as_points_method(
+    render_params: ShapesRenderParams | LabelsRenderParams, *, n: int, allow_datashader: bool
+) -> str:
+    """Pick the as_points backend. matplotlib by default; datashader only when it can represent the colors."""
+    method = render_params.method
+    if not allow_datashader or n == 0:
+        # e.g. no-color labels get one distinct random colour per cell (`_map_color_seg` Case C),
+        # which datashader's aggregate-then-shade model cannot represent.
+        if method == "datashader":
+            logger.warning("`as_points` cannot use datashader for this colouring; falling back to matplotlib.")
+        return "matplotlib"
+    if method == "datashader":
+        return "datashader"
+    if method is None and n > AS_POINTS_DS_AUTO:
+        logger.info(
+            f"`as_points`: {n} centroids exceed {AS_POINTS_DS_AUTO}; using the datashader backend "
+            "(pass `method='matplotlib'` to override)."
+        )
+        return "datashader"
+    return "matplotlib"
+
+
 def _render_centroids_as_points(
     ax: matplotlib.axes.SubplotBase,
     render_params: ShapesRenderParams | LabelsRenderParams,
@@ -1120,31 +1149,56 @@ def _render_centroids_as_points(
     color_source_vector: pd.Series | None,
     norm: Normalize | None,
     na_color: Any,
-    transform: Any,
     adata: AnnData | None,
     col_for_color: str | None,
     palette: Any,
     fig_params: FigParams,
     legend_params: LegendParams,
     colorbar_requests: list[ColorbarSpec] | None,
+    allow_datashader: bool = True,
 ) -> None:
     """Render one dot per cell at ``(x, y)`` colored like the fill, with legend/colorbar.
 
-    Shared "fast mode" draw for shapes/labels; style comes off ``render_params``. ``norm``/``na_color``
-    stay explicit because they differ between the shapes (locally adjusted) and labels paths.
+    Shared "fast mode" draw for shapes/labels. ``x``/``y`` are in **coordinate-system coords** (so the
+    datashader canvas and matplotlib's ``transData`` agree). Backend is matplotlib unless
+    ``render_params.method`` / the size threshold selects datashader (and the colouring supports it).
+    ``norm``/``na_color`` stay explicit because they differ between the shapes and labels paths.
     """
-    cax = _scatter_points(
-        ax,
-        x,
-        y,
-        color_vector,
-        size=render_params.size,
-        cmap=render_params.cmap_params.cmap,
-        norm=norm,
-        alpha=render_params.fill_alpha,
-        trans_data=transform,
-        zorder=render_params.zorder,
-    )
+    method = _resolve_as_points_method(render_params, n=len(np.asarray(x)), allow_datashader=allow_datashader)
+    if method == "datashader":
+        df = pd.DataFrame({"x": np.asarray(x), "y": np.asarray(y)})
+        cax, color_vector, color_source_vector = _datashader_points(
+            ax,
+            df,
+            col_for_color=col_for_color,
+            color_vector=color_vector,
+            color_source_vector=color_source_vector,
+            norm=norm,
+            cmap_params=render_params.cmap_params,
+            alpha=render_params.fill_alpha,
+            size=render_params.size,
+            zorder=render_params.zorder,
+            # as_points has no user reduction knob: centroids rarely share a pixel, and "max"
+            # (the top cell) keeps the datashader output closest to the matplotlib backend.
+            ds_reduction=None,
+            default_reduction="max",
+            density=False,
+            density_how="linear",
+            fig_params=fig_params,
+        )
+    else:
+        cax = _scatter_points(
+            ax,
+            x,
+            y,
+            color_vector,
+            size=render_params.size,
+            cmap=render_params.cmap_params.cmap,
+            norm=norm,
+            alpha=render_params.fill_alpha,
+            trans_data=ax.transData,  # x/y are coordinate-system coords
+            zorder=render_params.zorder,
+        )
     _add_legend_and_colorbar(
         ax=ax,
         cax=cax,
@@ -2266,7 +2320,7 @@ def _render_labels(
         # get instance id based on subsetted table
         instance_id = np.unique(table.obs[instance_key].values)
 
-    _, trans_data = _prepare_transformation(label, coordinate_system, ax)
+    trans, trans_data = _prepare_transformation(label, coordinate_system, ax)
 
     na_color = (
         render_params.color
@@ -2387,11 +2441,14 @@ def _render_labels(
         )
         # coerce so str/object table ids (e.g. Xenium) match the integer raster labels instead of NaN
         centroids = centroids.reindex(point_ids.astype(labels.dtype, copy=False))
+        # datashader cannot represent one distinct random colour per cell (the no-color path below)
+        allow_datashader = True
         if col_for_color is None and not na_color.color_modified_by_user():
             # no color column: one distinct random colour per cell, matching the mask path
             # (`_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
+            allow_datashader = False
         elif len(color_vector) == len(instance_id):
             # data-driven colour is per-instance
             point_color_vector = np.asarray(color_vector)[keep]
@@ -2400,22 +2457,24 @@ def _render_labels(
             # literal colour / user-set na_color -> one colour per centroid
             point_color_vector = np.asarray([na_color.get_hex_with_alpha()] * len(point_ids))
             point_color_source_vector = None
+        # 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=centroids["x"].to_numpy(),
-            y=centroids["y"].to_numpy(),
+            x=xy[:, 0],
+            y=xy[:, 1],
             color_vector=point_color_vector,
             color_source_vector=point_color_source_vector,
             norm=copy(render_params.cmap_params.norm),  # ax.scatter autoscales in place; don't mutate the shared norm
             na_color=na_color,
-            transform=trans_data,  # rendered-raster intrinsic coords -> coordinate system -> display
             adata=table if table_name is not None else None,
             col_for_color=col_for_color,
             palette=palette,
             fig_params=fig_params,
             legend_params=legend_params,
             colorbar_requests=colorbar_requests,
+            allow_datashader=allow_datashader,
         )
         return
 
diff --git a/src/spatialdata_plot/pl/render_params.py b/src/spatialdata_plot/pl/render_params.py
index 748735b7..28a110b9 100644
--- a/src/spatialdata_plot/pl/render_params.py
+++ b/src/spatialdata_plot/pl/render_params.py
@@ -334,6 +334,8 @@ class LabelsRenderParams:
     # Fast mode: render each label as a single dot at its centroid instead of the mask.
     as_points: bool = False
     size: float = 1.0  # marker size for as_points (matplotlib scatter ``s``)
+    # Backend for the as_points centroids: None auto-selects (datashader above ~500k dots).
+    method: str | None = None
     # Multi-panel color: when set, this render entry belongs to the panel identified by this
     # color key. ``None`` means the entry is shared across every panel (e.g. a background layer).
     panel_key: str | None = None

From 77ac531c2141bd14c45abfc7b977cbb2b97d7314 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Thu, 11 Jun 2026 03:53:23 +0200
Subject: [PATCH 24/28] test(as_points): datashader backend + shapes
 non-identity regression

- shapes non-identity transform regression (the coordinate bug fixed in 5854ae6)
- backend selection: method='datashader' -> datashader image; default -> matplotlib
- no-color labels force matplotlib even with method='datashader' (warns)
- _resolve_as_points_method unit test (threshold/explicit/no-color/empty)
- two test_plot_* visual tests for datashader as_points (baselines from CI)
---
 tests/pl/test_render_labels.py | 48 ++++++++++++++++++++++++++++++++++
 tests/pl/test_render_shapes.py | 41 +++++++++++++++++++++++++++++
 2 files changed, 89 insertions(+)

diff --git a/tests/pl/test_render_labels.py b/tests/pl/test_render_labels.py
index c38f4d5f..8599d69a 100644
--- a/tests/pl/test_render_labels.py
+++ b/tests/pl/test_render_labels.py
@@ -443,6 +443,12 @@ def test_plot_labels_as_points_respects_size(self, sdata_blobs: SpatialData):
         """size sets the scatter marker area; larger size -> larger dots."""
         sdata_blobs.pl.render_labels("blobs_labels", color="instance_id", as_points=True, size=600).pl.show()
 
+    def test_plot_labels_as_points_datashader(self, sdata_blobs: SpatialData):
+        """as_points with method='datashader' rasterizes the colored centroids instead of drawing markers."""
+        sdata_blobs.pl.render_labels(
+            "blobs_labels", color="instance_id", as_points=True, method="datashader", size=600
+        ).pl.show()
+
 
 def test_raises_when_table_does_not_annotate_element(sdata_blobs: SpatialData):
     # Work on an independent copy since we mutate tables
@@ -668,3 +674,45 @@ def test_render_labels_as_points_applies_non_identity_transform(sdata_blobs: Spa
     order_e = np.lexsort((expected_display[:, 1], expected_display[:, 0]))
     assert np.allclose(dots_display[order_d], expected_display[order_e], atol=3.0)
     plt.close(fig)
+
+
+def test_render_labels_as_points_method_datashader_renders_image(sdata_blobs: SpatialData):
+    """method='datashader' under as_points (with a color column) draws a datashaded raster."""
+    fig, ax = plt.subplots()
+    sdata_blobs.pl.render_labels(
+        "blobs_labels", color="instance_id", as_points=True, method="datashader", size=50
+    ).pl.show(ax=ax)
+    assert len(ax.images) >= 1
+    assert len(ax.collections) == 0
+    plt.close(fig)
+
+
+def test_render_labels_as_points_no_color_forces_matplotlib(sdata_blobs: SpatialData, caplog):
+    """No-color labels get one random colour per cell, which datashader cannot represent; even
+    method='datashader' must fall back to a matplotlib scatter (with a warning)."""
+    fig, ax = plt.subplots()
+    with logger_warns(caplog, logger, match="cannot use datashader"):
+        sdata_blobs.pl.render_labels("blobs_labels", as_points=True, method="datashader").pl.show(ax=ax)
+    assert len(ax.collections) == 1  # matplotlib scatter, not a datashader image
+    assert len(ax.images) == 0
+    plt.close(fig)
+
+
+def test_resolve_as_points_method_threshold_and_fallback():
+    """Backend selection: explicit honored, no-color/empty force matplotlib, auto switches past the cap."""
+    from types import SimpleNamespace
+
+    from spatialdata_plot.pl.render import AS_POINTS_DS_AUTO, _resolve_as_points_method
+
+    rp_auto = SimpleNamespace(method=None)
+    rp_ds = SimpleNamespace(method="datashader")
+    rp_mpl = SimpleNamespace(method="matplotlib")
+    # auto: matplotlib below the cap, datashader above
+    assert _resolve_as_points_method(rp_auto, n=1000, allow_datashader=True) == "matplotlib"
+    assert _resolve_as_points_method(rp_auto, n=AS_POINTS_DS_AUTO + 1, allow_datashader=True) == "datashader"
+    # explicit datashader honored only when the colouring allows it
+    assert _resolve_as_points_method(rp_ds, n=10, allow_datashader=True) == "datashader"
+    assert _resolve_as_points_method(rp_ds, n=10, allow_datashader=False) == "matplotlib"
+    # explicit matplotlib always matplotlib; empty always matplotlib
+    assert _resolve_as_points_method(rp_mpl, n=10**9, allow_datashader=True) == "matplotlib"
+    assert _resolve_as_points_method(rp_auto, n=0, allow_datashader=True) == "matplotlib"
diff --git a/tests/pl/test_render_shapes.py b/tests/pl/test_render_shapes.py
index ce502ca2..1c5d100f 100644
--- a/tests/pl/test_render_shapes.py
+++ b/tests/pl/test_render_shapes.py
@@ -1116,6 +1116,10 @@ def test_plot_shapes_as_points_respects_size(self, sdata_blobs: SpatialData):
         """size sets the scatter marker area; larger size -> larger dots."""
         sdata_blobs.pl.render_shapes("blobs_circles", as_points=True, size=600).pl.show()
 
+    def test_plot_shapes_as_points_datashader(self, sdata_blobs: SpatialData):
+        """as_points with method='datashader' rasterizes the centroids instead of drawing markers."""
+        sdata_blobs.pl.render_shapes("blobs_circles", as_points=True, method="datashader", size=600).pl.show()
+
 
 def test_gene_symbols_auto_detect_table(sdata_blobs: SpatialData):
     """gene_symbols resolves correctly without explicit table_name (#247)."""
@@ -1737,3 +1741,40 @@ def test_render_shapes_as_points_ignores_outline_and_shape(sdata_blobs: SpatialD
     ).pl.show(ax=ax)
     assert len(ax.collections) >= 1  # a scatter, not the patch collections of the geometry path
     plt.close(fig)
+
+
+def test_render_shapes_as_points_applies_non_identity_transform(sdata_blobs: SpatialData):
+    """Regression: shapes as_points must place dots at coordinate-system positions, not intrinsic ones.
+    A wrong transform is off by the scale factor (hundreds of px)."""
+    import spatialdata as sd
+    from spatialdata.transformations import Scale, set_transformation
+
+    set_transformation(sdata_blobs["blobs_circles"], Scale([3.0, 5.0], axes=("x", "y")), "scaled")
+    fig, ax = plt.subplots()
+    sdata_blobs.pl.render_shapes("blobs_circles", as_points=True, size=50).pl.show(
+        ax=ax, coordinate_systems="scaled"
+    )
+    coll = ax.collections[0]
+    dots = coll.get_offset_transform().transform(np.asarray(coll.get_offsets()))
+    cs = sd.get_centroids(sdata_blobs["blobs_circles"], coordinate_system="scaled").compute()[["x", "y"]].to_numpy()
+    expected = ax.transData.transform(cs)
+    od, oe = np.lexsort((dots[:, 1], dots[:, 0])), np.lexsort((expected[:, 1], expected[:, 0]))
+    assert np.allclose(dots[od], expected[oe], atol=3.0)
+    plt.close(fig)
+
+
+def test_render_shapes_as_points_method_datashader_renders_image(sdata_blobs: SpatialData):
+    """method='datashader' under as_points draws a datashaded raster, not a scatter collection."""
+    fig, ax = plt.subplots()
+    sdata_blobs.pl.render_shapes("blobs_circles", as_points=True, method="datashader", size=50).pl.show(ax=ax)
+    assert len(ax.images) >= 1  # datashader image
+    assert len(ax.collections) == 0  # no matplotlib scatter
+    plt.close(fig)
+
+
+def test_render_shapes_as_points_default_is_matplotlib(sdata_blobs: SpatialData):
+    """Small element with method=None uses matplotlib (crisp markers), not datashader."""
+    fig, ax = plt.subplots()
+    sdata_blobs.pl.render_shapes("blobs_circles", as_points=True, size=50).pl.show(ax=ax)
+    assert len(ax.collections) == 1 and len(ax.images) == 0
+    plt.close(fig)

From b18bb181ab94e5765cc58e835ebb47d3d5b27adf Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Thu, 11 Jun 2026 04:03:01 +0200
Subject: [PATCH 25/28] test(as_points): CI baselines for datashader as_points
 visual tests

Rendered on hatch-test.py3.11-stable; verified centroids datashade at the correct
positions (shapes: na_color blobs; labels: colored by instance_id with colorbar).
Only these two tests failed on the stable CI envs (missing baselines); no existing
baseline regressed from the coordinate fix.
---
 .../Labels_labels_as_points_datashader.png      | Bin 0 -> 39946 bytes
 .../Shapes_shapes_as_points_datashader.png      | Bin 0 -> 17377 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 tests/_images/Labels_labels_as_points_datashader.png
 create mode 100644 tests/_images/Shapes_shapes_as_points_datashader.png

diff --git a/tests/_images/Labels_labels_as_points_datashader.png b/tests/_images/Labels_labels_as_points_datashader.png
new file mode 100644
index 0000000000000000000000000000000000000000..96161dd81b66fa6dcacc7d46fd0b0a1a0745d5e7
GIT binary patch
literal 39946
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

literal 0
HcmV?d00001

diff --git a/tests/_images/Shapes_shapes_as_points_datashader.png b/tests/_images/Shapes_shapes_as_points_datashader.png
new file mode 100644
index 0000000000000000000000000000000000000000..a09677a15a5d71082fdd846521cf47813ccf5eb8
GIT binary patch
literal 17377
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
MI32ZDDpukD4`f*YZ2$lO

literal 0
HcmV?d00001


From 47ae7bcf452badf41d4263c217b37cefd8a52b43 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Thu, 11 Jun 2026 05:16:50 +0200
Subject: [PATCH 26/28] refactor(as_points): trim comments, drop redundant
 asarray, fix empty-element warning

Code-review cleanup: lean the datashader as_points comments/docstrings, drop
np.asarray on already-array x/y, and stop emitting the 'cannot use datashader
for this colouring' warning for an empty element (it now warns only for the
genuinely unsupported no-color case). Net -5 lines, no behavior change.
---
 src/spatialdata_plot/pl/render.py | 37 +++++++++++++------------------
 1 file changed, 16 insertions(+), 21 deletions(-)

diff --git a/src/spatialdata_plot/pl/render.py b/src/spatialdata_plot/pl/render.py
index 8ed88ac9..3e8dea53 100644
--- a/src/spatialdata_plot/pl/render.py
+++ b/src/spatialdata_plot/pl/render.py
@@ -1111,9 +1111,8 @@ def _scatter_points(
     )
 
 
-# as_points: matplotlib draws crisp markers; above this many dots its per-glyph draw dominates
-# (≈18 µs/dot), so auto-switch to datashader. Datashader changes appearance (density raster), so
-# the threshold is conservative and only applies when the user did not pick a backend explicitly.
+# Above this many centroids matplotlib's per-glyph draw (~18 µs/dot) dominates, so auto-switch to
+# datashader. Conservative because datashader changes the look (density raster); only used when method=None.
 AS_POINTS_DS_AUTO = 500_000
 
 
@@ -1123,9 +1122,9 @@ def _resolve_as_points_method(
     """Pick the as_points backend. matplotlib by default; datashader only when it can represent the colors."""
     method = render_params.method
     if not allow_datashader or n == 0:
-        # e.g. no-color labels get one distinct random colour per cell (`_map_color_seg` Case C),
-        # which datashader's aggregate-then-shade model cannot represent.
-        if method == "datashader":
+        # no-color labels get one random colour per cell (`_map_color_seg` Case C), which datashader's
+        # aggregate-then-shade model cannot represent; an empty element just has nothing to draw.
+        if method == "datashader" and not allow_datashader:
             logger.warning("`as_points` cannot use datashader for this colouring; falling back to matplotlib.")
         return "matplotlib"
     if method == "datashader":
@@ -1157,16 +1156,15 @@ def _render_centroids_as_points(
     colorbar_requests: list[ColorbarSpec] | None,
     allow_datashader: bool = True,
 ) -> None:
-    """Render one dot per cell at ``(x, y)`` colored like the fill, with legend/colorbar.
+    """Render one dot per cell at ``(x, y)`` (coordinate-system coords), colored like the fill.
 
-    Shared "fast mode" draw for shapes/labels. ``x``/``y`` are in **coordinate-system coords** (so the
-    datashader canvas and matplotlib's ``transData`` agree). Backend is matplotlib unless
-    ``render_params.method`` / the size threshold selects datashader (and the colouring supports it).
-    ``norm``/``na_color`` stay explicit because they differ between the shapes and labels paths.
+    Shared "fast mode" for shapes/labels. Backend is matplotlib unless ``render_params.method`` or the
+    size threshold selects datashader (and the colouring supports it). ``norm``/``na_color`` are explicit
+    because they differ between the shapes and labels paths.
     """
-    method = _resolve_as_points_method(render_params, n=len(np.asarray(x)), allow_datashader=allow_datashader)
+    method = _resolve_as_points_method(render_params, n=len(x), allow_datashader=allow_datashader)
     if method == "datashader":
-        df = pd.DataFrame({"x": np.asarray(x), "y": np.asarray(y)})
+        df = pd.DataFrame({"x": x, "y": y})
         cax, color_vector, color_source_vector = _datashader_points(
             ax,
             df,
@@ -1235,16 +1233,13 @@ def _datashader_points(
     fig_params: FigParams,
     default_reduction: _DsReduction = "sum",
 ) -> tuple[Any, Any, Any]:
-    """Datashade an x/y(+color) point frame onto ``ax``; returns ``(cax, color_vector, color_source_vector)``.
+    """Datashade an x/y(+color) point frame onto ``ax``; return ``(cax, color_vector, color_source_vector)``.
 
-    Shared datashader draw for ``render_points`` and the centroid "fast mode" of shapes/labels. ``df``
-    holds ``x``/``y`` in coordinate-system coords (+ an optional color column). The (possibly
-    recomputed) color vectors are returned so the caller's legend/colorbar uses the same values.
-    Primitives are taken explicitly rather than a ``render_params`` because shapes/labels params use
-    ``fill_alpha`` and lack the density fields.
+    Shared by ``render_points`` and the centroid "fast mode" of shapes/labels; ``df`` holds ``x``/``y``
+    in coordinate-system coords. The (possibly recomputed) color vectors are returned so the caller's
+    legend uses the same values. Primitives are explicit because shapes/labels params lack ``alpha``/density.
     """
-    # NOTE: s in matplotlib is in units of points**2; use dpi/100 so dpi!=100 still spreads correctly.
-    # Under density, spreading would smear the count signal across pixels, so disable it.
+    # spread radius from marker size (matplotlib points**2, dpi-scaled); off under density to keep counts crisp
     px: int | None = None if density else int(np.round(np.sqrt(size) * (fig_params.fig.dpi / 100)))
 
     plot_width, plot_height, x_ext, y_ext, factor = _datashader_canvas_from_dataframe(df, fig_params)

From c50e6103e0ad14db4c9083225fa6fc7a6c8a1ad5 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Thu, 11 Jun 2026 06:32:17 +0200
Subject: [PATCH 27/28] test(as_points): visual test for categorical datashader
 as_points

Covers the categorical-column datashader path (color_source_vector + legend),
which the existing no-color (shapes) and continuous (labels/instance_id) tests
don't exercise. Baseline to be generated from CI.
---
 tests/pl/test_render_labels.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/pl/test_render_labels.py b/tests/pl/test_render_labels.py
index 8599d69a..a46cf3b3 100644
--- a/tests/pl/test_render_labels.py
+++ b/tests/pl/test_render_labels.py
@@ -449,6 +449,16 @@ def test_plot_labels_as_points_datashader(self, sdata_blobs: SpatialData):
             "blobs_labels", color="instance_id", as_points=True, method="datashader", size=600
         ).pl.show()
 
+    def test_plot_labels_as_points_datashader_categorical(self, sdata_blobs: SpatialData):
+        """Categorical-coloured as_points centroids datashade with a legend (color_source_vector path)."""
+        max_col = sdata_blobs["table"].to_df().idxmax(axis=1)
+        sdata_blobs["table"].obs["which_max"] = pd.Categorical(
+            max_col, categories=sdata_blobs["table"].to_df().columns, ordered=True
+        )
+        sdata_blobs.pl.render_labels(
+            "blobs_labels", color="which_max", as_points=True, method="datashader", size=600
+        ).pl.show()
+
 
 def test_raises_when_table_does_not_annotate_element(sdata_blobs: SpatialData):
     # Work on an independent copy since we mutate tables

From 575cf305d0f34374a799530e211f89f07c3e5ec7 Mon Sep 17 00:00:00 2001
From: anon <tim.treis@helmholtz-munich.de>
Date: Thu, 11 Jun 2026 06:40:33 +0200
Subject: [PATCH 28/28] test(as_points): CI baseline for categorical datashader
 as_points

Rendered on hatch-test.py3.11-stable; verified datashaded centroids coloured by
category with a categorical legend. Only this test failed on stable CI (missing
baseline); existing datashader baselines unchanged.
---
 ..._labels_as_points_datashader_categorical.png | Bin 0 -> 34136 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 tests/_images/Labels_labels_as_points_datashader_categorical.png

diff --git a/tests/_images/Labels_labels_as_points_datashader_categorical.png b/tests/_images/Labels_labels_as_points_datashader_categorical.png
new file mode 100644
index 0000000000000000000000000000000000000000..bf716cb2bc2bfa1a29e90b601a5beabdadc5070b
GIT binary patch
literal 34136
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

literal 0
HcmV?d00001