fix(as_points): size datashader canvas to the axes, not the figure

The datashader result is a data-coordinate image that scales with the axes,
while matplotlib markers are fixed in display points. The canvas was sized from
fig.get_size_inches()*dpi (the whole figure), but the axes are smaller (margins,
colorbar), so the image - and every dot - was scaled down: labels (with colorbar)
0.81x matplotlib, shapes 0.88x. Size the as_markers canvas to the axes display box
(ax.get_window_extent()) so 1 canvas px == 1 axes-display px and the sqrt(s)*dpi/144
spread radius matches the marker. Now mean 0.99 +/-5% across sizes/figs/dpi/elements;
render_points untouched (byte-identical). Visual tests render at a non-overlapping
size so the engines' overlap handling (stack vs aggregate) doesn't enter the pairs.

Author: timtreis

src/spatialdata_plot/pl/render.py

@@ -63,7 +63,6 @@
     _build_shape_patches,
     _check_obs_var_shadow,
     _color_vector_to_rgba,
-    _compute_datashader_canvas_params,
     _convert_shapes,
     _datashader_canvas_from_dataframe,
     _decorate_axs,
@@ -1258,10 +1257,17 @@ def _datashader_points(
     px: int | None = None if density else int(np.round(np.sqrt(size) * (fig_params.fig.dpi / px_div)))
 
     if as_markers and axes_extent is not None:
-        # rasterize over the same extent the axes will use, so 1 canvas px == 1 display px (as render_points)
+        # Rasterize over the element extent (the frame the axes use) at the AXES' display resolution, not
+        # the figure's. The datashader result is a data-coordinate image that scales with the axes, while
+        # matplotlib markers are fixed in display points; sizing the canvas to the figure (which is larger
+        # than the axes once margins/colorbar are accounted for) shrank the dots. With 1 canvas px == 1
+        # axes-display px, the spread radius (matplotlib's marker radius, sqrt(s)*dpi/144) matches.
         x_ext = [float(axes_extent["x"][0]), float(axes_extent["x"][1])]
         y_ext = [float(axes_extent["y"][0]), float(axes_extent["y"][1])]
-        plot_width, plot_height, x_ext, y_ext, factor = _compute_datashader_canvas_params(x_ext, y_ext, fig_params)
+        bb = ax.get_window_extent()
+        rx, ry = x_ext[1] - x_ext[0], y_ext[1] - y_ext[0]
+        factor = max(rx / bb.width, ry / bb.height)
+        plot_width, plot_height = int(round(rx / factor)), int(round(ry / factor))
     else:
         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)

tests/pl/test_render_labels.py

@@ -437,8 +437,9 @@ def test_plot_can_color_labels_by_gene_symbols(self, sdata_blobs: SpatialData):
 
     @staticmethod
     def _as_points(sdata_blobs: SpatialData, method: str, color: str = "instance_id"):
-        # identical params for both backends, so the matplotlib and datashader baselines are comparable
-        return sdata_blobs.pl.render_labels("blobs_labels", color=color, as_points=True, method=method, size=600)
+        # identical params for both backends; non-overlapping size so the only place the engines differ
+        # (overlap: matplotlib stacks markers, datashader aggregates) doesn't enter the comparison
+        return sdata_blobs.pl.render_labels("blobs_labels", color=color, as_points=True, method=method, size=120)
 
     @staticmethod
     def _add_categorical_color(sdata_blobs: SpatialData) -> str:

tests/pl/test_render_shapes.py

@@ -1111,7 +1111,9 @@ def test_plot_can_color_shapes_by_gene_symbols(self, sdata_blobs: SpatialData):
     @staticmethod
     def _as_points(sdata_blobs: SpatialData, method: str):
         # identical params for both backends, so the matplotlib and datashader baselines are comparable
-        return sdata_blobs.pl.render_shapes("blobs_circles", as_points=True, method=method, size=600)
+        # non-overlapping size: matplotlib (vector, stacks markers) and datashader (raster, aggregates)
+        # only diverge where dots overlap, so keep them apart to compare the backends fairly
+        return sdata_blobs.pl.render_shapes("blobs_circles", as_points=True, method=method, size=120)
 
     def test_plot_shapes_as_points_matplotlib(self, sdata_blobs: SpatialData):
         """as_points draws one dot per shape at its centroid (matplotlib backend)."""