refactor(as_points): dedup fast-extent idiom, fix stale 50k docs

- extract _fast_extent(element, cs) helper; the '_element_extent_fast(...) or
  get_extent(...)' idiom was duplicated verbatim at the shapes as_points site
  and the datashader-canvas helper
- fix docstrings that still said '~500k' after the threshold dropped to 50k
- trim _render_centroids_as_points docstring and a non-actionable comment

No behavior change: _fast_extent is identical to the inline form (verified
== get_extent on blobs), render_points byte-identical.

Author: timtreis

src/spatialdata_plot/pl/basic.py

@@ -1051,7 +1051,7 @@ def render_labels(
             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
+            matplotlib is used unless there are more than ~50k centroids. Datashader is skipped (with a
             warning) when the colouring cannot be aggregated (e.g. labels with no color column).
 
         Returns

src/spatialdata_plot/pl/render.py

@@ -66,7 +66,7 @@
     _convert_shapes,
     _datashader_canvas_from_dataframe,
     _decorate_axs,
-    _element_extent_fast,
+    _fast_extent,
     _get_collection_shape,
     _get_colors_for_categorical_obs,
     _get_extent_and_range_for_datashader_canvas,
@@ -775,10 +775,7 @@ def _render_shapes(
             fig_params=fig_params,
             legend_params=legend_params,
             colorbar_requests=colorbar_requests,
-            # fast corner-transform extent (avoids transforming every geometry); identical for
-            # axis-aligned transforms, falls back to get_extent for rotation/shear
-            axes_extent=_element_extent_fast(sdata_filt.shapes[element], coordinate_system)
-            or get_extent(sdata_filt.shapes[element], coordinate_system=coordinate_system),
+            axes_extent=_fast_extent(sdata_filt.shapes[element], coordinate_system),
         )
         return
 
@@ -1164,11 +1161,9 @@ def _render_centroids_as_points(
 ) -> None:
     """Render one dot per cell at ``(x, y)`` (coordinate-system coords), colored like the fill.
 
-    Shared "fast mode" for shapes/labels. Backend is matplotlib unless ``render_params.method`` or the
-    size threshold selects datashader (and the colouring supports it). ``axes_extent`` is the element's
-    extent in the coordinate system (the frame the axes will use), which the datashader backend rasterizes
-    over so its dots match the matplotlib markers. ``norm``/``na_color`` are explicit because they differ
-    between the shapes and labels paths.
+    Shared "fast mode" for shapes/labels; backend chosen by ``_resolve_as_points_method``. ``axes_extent``
+    (the element's extent, i.e. the frame the axes will use) is what the datashader backend rasterizes over
+    so its dots match the matplotlib markers.
     """
     method = _resolve_as_points_method(render_params, n=len(x), allow_datashader=allow_datashader)
     if method == "datashader":

src/spatialdata_plot/pl/render_params.py

@@ -334,7 +334,7 @@ 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).
+    # Backend for the as_points centroids: None auto-selects (datashader above ~50k 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).

src/spatialdata_plot/pl/utils.py

@@ -3976,11 +3976,7 @@ def _get_extent_and_range_for_datashader_canvas(
     coordinate_system: str,
     fig_params: FigParams,
 ) -> tuple[Any, Any, list[Any], list[Any], Any]:
-    # 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
-    )
+    extent = _fast_extent(spatial_element, 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)
@@ -4803,7 +4799,7 @@ def measure_obs(
 # 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.
+# rotation/shear and other element types fall back to `get_extent`.
 
 
 def _is_axis_aligned(linear2x2: ArrayLike, *, rtol: float = 1e-9) -> bool:
@@ -4864,6 +4860,12 @@ def _element_extent_fast(
     return {"x": (float(tc[:, 0].min()), float(tc[:, 0].max())), "y": (float(tc[:, 1].min()), float(tc[:, 1].max()))}
 
 
+def _fast_extent(element: Any, coordinate_system: str) -> dict[str, tuple[float, float]]:
+    """Element extent via the fast corner-transform; identical to ``get_extent`` but avoids transforming
+    every geometry for axis-aligned transforms (falls back to ``get_extent`` for rotation/shear)."""
+    return _element_extent_fast(element, coordinate_system) or get_extent(element, coordinate_system=coordinate_system)
+
+
 def _get_extent_fast(
     sdata: SpatialData,
     coordinate_system: str,