Donut-MultiPolygons are now correctly rendered again

.github/workflows/test.yaml

@@ -57,17 +57,11 @@ jobs:
           DISPLAY: :42
         run: |
           pytest -v --cov --color=yes --cov-report=xml
-      # - name: Generate GH action "groundtruth" figures as artifacts, uncomment if needed
-      #   if: always()
-      #   uses: actions/upload-artifact@v3
-      #   with:
-      #       name: groundtruth-figures
-      #       path: /home/runner/work/spatialdata-plot/spatialdata-plot/tests/_images/*
       - name: Archive figures generated during testing
         if: always()
         uses: actions/upload-artifact@v3
         with:
-          name: plotting-results
+          name: visual_test_results_${{ matrix.os }}-python${{ matrix.python }}
           path: /home/runner/work/spatialdata-plot/spatialdata-plot/tests/figures/*
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v4

src/spatialdata_plot/pl/utils.py

@@ -11,10 +11,8 @@
 
 import matplotlib
 import matplotlib.patches as mpatches
-import matplotlib.patches as mplp
 import matplotlib.path as mpath
 import matplotlib.pyplot as plt
-import multiscale_spatial_image as msi
 import numpy as np
 import pandas as pd
 import shapely
@@ -48,7 +46,6 @@
 from scanpy.plotting._tools.scatterplots import _add_categorical_legend
 from scanpy.plotting._utils import add_colors_for_categorical_sample_annotation
 from scanpy.plotting.palettes import default_20, default_28, default_102
-from shapely.geometry import LineString, Polygon
 from skimage.color import label2rgb
 from skimage.morphology import erosion, square
 from skimage.segmentation import find_boundaries
@@ -233,6 +230,30 @@ def _sanitise_na_color(na_color: ColorLike | None) -> tuple[str, bool]:
     raise ValueError(f"Invalid na_color value: {na_color}")
 
 
+def _get_centroid_of_pathpatch(pathpatch: mpatches.PathPatch) -> tuple[float, float]:
+    # Extract the vertices from the PathPatch
+    path = pathpatch.get_path()
+    vertices = path.vertices
+    x = vertices[:, 0]
+    y = vertices[:, 1]
+
+    area = 0.5 * np.sum(x[:-1] * y[1:] - x[1:] * y[:-1])
+
+    # Calculate the centroid coordinates
+    centroid_x = np.sum((x[:-1] + x[1:]) * (x[:-1] * y[1:] - x[1:] * y[:-1])) / (6 * area)
+    centroid_y = np.sum((y[:-1] + y[1:]) * (x[:-1] * y[1:] - x[1:] * y[:-1])) / (6 * area)
+
+    return centroid_x, centroid_y
+
+
+def _scale_pathpatch_around_centroid(pathpatch: mpatches.PathPatch, scale_factor: float) -> None:
+
+    centroid = _get_centroid_of_pathpatch(pathpatch)
+    vertices = pathpatch.get_path().vertices
+    scaled_vertices = np.array([centroid + (vertex - centroid) * scale_factor for vertex in vertices])
+    pathpatch.get_path().vertices = scaled_vertices
+
+
 def _get_collection_shape(
     shapes: list[GeoDataFrame],
     c: Any,
@@ -302,63 +323,64 @@ def _get_collection_shape(
     outline_c = outline_c * fill_c.shape[0]
 
     shapes_df = pd.DataFrame(shapes, copy=True)
-
-    # remove empty points/polygons
     shapes_df = shapes_df[shapes_df["geometry"].apply(lambda geom: not geom.is_empty)]
-
-    # reset index of shapes_df for case of spatial query
     shapes_df = shapes_df.reset_index(drop=True)
 
-    rows = []
-
-    def assign_fill_and_outline_to_row(
-        shapes: list[GeoDataFrame], fill_c: list[Any], outline_c: list[Any], row: pd.Series, idx: int
+    def _assign_fill_and_outline_to_row(
+        fill_c: list[Any], outline_c: list[Any], row: dict[str, Any], idx: int, is_multiple_shapes: bool
     ) -> None:
         try:
-            if len(shapes) > 1 and len(fill_c) == 1:
-                row["fill_c"] = fill_c
-                row["outline_c"] = outline_c
+            if is_multiple_shapes and len(fill_c) == 1:
+                row["fill_c"] = fill_c[0]
+                row["outline_c"] = outline_c[0]
             else:
                 row["fill_c"] = fill_c[idx]
                 row["outline_c"] = outline_c[idx]
         except IndexError as e:
-            raise IndexError("Could not assign fill and outline colors due to a mismatch in row-numbers.") from e
-
-    # Match colors to the geometry, potentially expanding the row in case of
-    # multipolygons
-    for idx, row in shapes_df.iterrows():
-        geom = row["geometry"]
-        if geom.geom_type == "Polygon":
-            row = row.to_dict()
-            coords = np.array(geom.exterior.coords)
-            centroid = np.mean(coords, axis=0)
-            scaled_coords = [(centroid + (np.array(coord) - centroid) * s).tolist() for coord in geom.exterior.coords]
-            row["geometry"] = mplp.Polygon(scaled_coords, closed=True)
-            assign_fill_and_outline_to_row(shapes, fill_c, outline_c, row, idx)
-            rows.append(row)
-
-        elif geom.geom_type == "MultiPolygon":
-            # mp = _make_patch_from_multipolygon(geom)
-            for polygon in geom.geoms:
-                mp_copy = row.to_dict()
-                coords = np.array(polygon.exterior.coords)
-                centroid = np.mean(coords, axis=0)
-                scaled_coords = [(centroid + (coord - centroid) * s).tolist() for coord in coords]
-                mp_copy["geometry"] = mplp.Polygon(scaled_coords, closed=True)
-                assign_fill_and_outline_to_row(shapes, fill_c, outline_c, mp_copy, idx)
-                rows.append(mp_copy)
-
-        elif geom.geom_type == "Point":
-            row = row.to_dict()
-            scaled_radius = row["radius"] * s
-            row["geometry"] = mplp.Circle(
-                (geom.x, geom.y), radius=scaled_radius
-            )  # Circle is always scaled from its center
-            assign_fill_and_outline_to_row(shapes, fill_c, outline_c, row, idx)
-            rows.append(row)
-
-    patches = pd.DataFrame(rows)
-
+            raise IndexError("Could not assign fill and outline colors due to a mismatch in row numbers.") from e
+
+    def _process_polygon(row: pd.Series, s: float) -> dict[str, Any]:
+        coords = np.array(row["geometry"].exterior.coords)
+        centroid = np.mean(coords, axis=0)
+        scaled_coords = (centroid + (coords - centroid) * s).tolist()
+        return {**row.to_dict(), "geometry": mpatches.Polygon(scaled_coords, closed=True)}
+
+    def _process_multipolygon(row: pd.Series, s: float) -> list[dict[str, Any]]:
+        mp = _make_patch_from_multipolygon(row["geometry"])
+        row_dict = row.to_dict()
+        for m in mp:
+            _scale_pathpatch_around_centroid(m, s)
+
+        return [{**row_dict, "geometry": m} for m in mp]
+
+    def _process_point(row: pd.Series, s: float) -> dict[str, Any]:
+        return {
+            **row.to_dict(),
+            "geometry": mpatches.Circle((row["geometry"].x, row["geometry"].y), radius=row["radius"] * s),
+        }
+
+    def _create_patches(shapes_df: GeoDataFrame, fill_c: list[Any], outline_c: list[Any], s: float) -> pd.DataFrame:
+        rows = []
+        is_multiple_shapes = len(shapes_df) > 1
+
+        for idx, row in shapes_df.iterrows():
+            geom_type = row["geometry"].geom_type
+            processed_rows = []
+
+            if geom_type == "Polygon":
+                processed_rows.append(_process_polygon(row, s))
+            elif geom_type == "MultiPolygon":
+                processed_rows.extend(_process_multipolygon(row, s))
+            elif geom_type == "Point":
+                processed_rows.append(_process_point(row, s))
+
+            for processed_row in processed_rows:
+                _assign_fill_and_outline_to_row(fill_c, outline_c, processed_row, idx, is_multiple_shapes)
+                rows.append(processed_row)
+
+        return pd.DataFrame(rows)
+
+    patches = _create_patches(shapes_df, fill_c, outline_c, s)
     return PatchCollection(
         patches["geometry"].values.tolist(),
         snap=False,
@@ -738,7 +760,7 @@ def _map_color_seg(
     cell_id = np.array(cell_id)
     if color_vector is not None and isinstance(color_vector.dtype, pd.CategoricalDtype):
         # users wants to plot a categorical column
-        if isinstance(na_color, tuple) and len(na_color) == 4 and np.any(color_source_vector.isna()):
+        if np.any(color_source_vector.isna()):
             cell_id[color_source_vector.isna()] = 0
         val_im: ArrayLike = map_array(seg, cell_id, color_vector.codes + 1)
         cols = colors.to_rgba_array(color_vector.categories)
@@ -823,9 +845,9 @@ def _modify_categorical_color_mapping(
         modified_mapping = {key: mapping[key] for key in mapping if key in groups or key == "NaN"}
     elif len(palette) == len(groups) and isinstance(groups, list) and isinstance(palette, list):
         modified_mapping = dict(zip(groups, palette))
-
     else:
         raise ValueError(f"Expected palette to be of length `{len(groups)}`, found `{len(palette)}`.")
+
     return modified_mapping
 
 
@@ -841,7 +863,7 @@ def _get_default_categorial_color_mapping(
         palette = default_102
     else:
         palette = ["grey" for _ in range(len_cat)]
-        logger.info("input has more than 103 categories. Uniform " "'grey' color will be used for all categories.")
+        logger.info("input has more than 103 categories. Uniform 'grey' color will be used for all categories.")
 
     return {cat: to_hex(to_rgba(col)[:3]) for cat, col in zip(color_source_vector.categories, palette[:len_cat])}
 
@@ -872,54 +894,6 @@ def _get_categorical_color_mapping(
     return _modify_categorical_color_mapping(base_mapping, groups, palette)
 
 
-def _get_palette(
-    categories: Sequence[Any],
-    adata: AnnData | None = None,
-    cluster_key: None | str = None,
-    palette: ListedColormap | str | list[str] | None = None,
-    alpha: float = 1.0,
-) -> Mapping[str, str] | None:
-    palette = None if isinstance(palette, list) and palette[0] is None else palette
-    if adata is not None and palette is None:
-        try:
-            palette = adata.uns[f"{cluster_key}_colors"]  # type: ignore[arg-type]
-            if len(palette) != len(categories):
-                raise ValueError(
-                    f"Expected palette to be of length `{len(categories)}`, found `{len(palette)}`. "
-                    + f"Removing the colors in `adata.uns` with `adata.uns.pop('{cluster_key}_colors')` may help."
-                )
-            return {cat: to_hex(to_rgba(col)[:3]) for cat, col in zip(categories, palette)}
-        except KeyError as e:
-            logger.warning(e)
-            return None
-
-    len_cat = len(categories)
-
-    if palette is None:
-        if len_cat <= 20:
-            palette = default_20
-        elif len_cat <= 28:
-            palette = default_28
-        elif len_cat <= len(default_102):  # 103 colors
-            palette = default_102
-        else:
-            palette = ["grey" for _ in range(len_cat)]
-            logger.info("input has more than 103 categories. Uniform " "'grey' color will be used for all categories.")
-        return {cat: to_hex(to_rgba(col)[:3]) for cat, col in zip(categories, palette[:len_cat])}
-
-    if isinstance(palette, str):
-        cmap = ListedColormap([palette])
-    elif isinstance(palette, list):
-        cmap = ListedColormap(palette)
-    elif isinstance(palette, ListedColormap):
-        cmap = palette
-    else:
-        raise TypeError(f"Palette is {type(palette)} but should be string or list.")
-    palette = [to_hex(np.round(x, 5)) for x in cmap(np.linspace(0, 1, len_cat), alpha=alpha)]
-
-    return dict(zip(categories, palette))
-
-
 def _maybe_set_colors(
     source: AnnData, target: AnnData, key: str, palette: str | ListedColormap | Cycler | Sequence[Any] | None = None
 ) -> None:
@@ -1087,34 +1061,6 @@ def save_fig(fig: Figure, path: str | Path, make_dir: bool = True, ext: str = "p
     fig.savefig(path, **kwargs)
 
 
-def _get_cs_element_map(
-    element: str | Sequence[str] | None,
-    element_map: Mapping[str, Any],
-) -> Mapping[str, str]:
-    """Get the mapping between the coordinate system and the class."""
-    # from spatialdata.models import Image2DModel, Image3DModel, Labels2DModel, Labels3DModel, PointsModel, ShapesModel
-    element = list(element_map.keys())[0] if element is None else element
-    element = [element] if isinstance(element, str) else element
-    d = {}
-    for e in element:
-        cs = list(element_map[e].attrs["transform"].keys())[0]
-        d[cs] = e
-        # model = get_model(element_map["blobs_labels"])
-        # if model in [Image2DModel, Image3DModel, Labels2DModel, Labels3DModel]
-    return d
-
-
-def _multiscale_to_image(sdata: sd.SpatialData) -> sd.SpatialData:
-    if sdata.images is None:
-        raise ValueError("No images found in the SpatialData object.")
-
-    for k, v in sdata.images.items():
-        if isinstance(v, msi.multiscale_spatial_image.DataTree):
-            sdata.images[k] = Image2DModel.parse(v["scale0"].ds.to_array().squeeze(axis=0))
-
-    return sdata
-
-
 def _get_linear_colormap(colors: list[str], background: str) -> list[LinearSegmentedColormap]:
     return [LinearSegmentedColormap.from_list(c, [background, c], N=256) for c in colors]
 
@@ -1126,62 +1072,6 @@ def _get_listed_colormap(color_dict: dict[str, str]) -> ListedColormap:
     return ListedColormap(["black"] + colors, N=len(colors) + 1)
 
 
-def _translate_image(
-    image: DataArray,
-    translation: sd.transformations.transformations.Translation,
-) -> DataArray:
-    shifts: dict[str, int] = {axis: int(translation.translation[idx]) for idx, axis in enumerate(translation.axes)}
-    img = image.values.copy()
-    # for yx images (important for rasterized MultiscaleImages as labels)
-    expanded_dims = False
-    if len(img.shape) == 2:
-        img = np.expand_dims(img, axis=0)
-        expanded_dims = True
-
-    shifted_channels = []
-
-    # split channels, shift axes individually, them recombine
-    if len(img.shape) == 3:
-        for c in range(img.shape[0]):
-            channel = img[c, :, :]
-
-            # iterates over [x, y]
-            for axis, shift in shifts.items():
-                pad_x, pad_y = (0, 0), (0, 0)
-                if axis == "x" and shift > 0:
-                    pad_x = (abs(shift), 0)
-                elif axis == "x" and shift < 0:
-                    pad_x = (0, abs(shift))
-
-                if axis == "y" and shift > 0:
-                    pad_y = (abs(shift), 0)
-                elif axis == "y" and shift < 0:
-                    pad_y = (0, abs(shift))
-
-                channel = np.pad(channel, (pad_y, pad_x), mode="constant")
-
-            shifted_channels.append(channel)
-
-    if expanded_dims:
-        return Labels2DModel.parse(
-            np.array(shifted_channels[0]),
-            dims=["y", "x"],
-            transformations=image.attrs["transform"],
-        )
-    return Image2DModel.parse(
-        np.array(shifted_channels),
-        dims=["c", "y", "x"],
-        transformations=image.attrs["transform"],
-    )
-
-
-def _convert_polygon_to_linestrings(polygon: Polygon) -> list[LineString]:
-    b = polygon.boundary.coords
-    linestrings = [LineString(b[k : k + 2]) for k in range(len(b) - 1)]
-
-    return [list(ls.coords) for ls in linestrings]
-
-
 def _split_multipolygon_into_outer_and_inner(mp: shapely.MultiPolygon):  # type: ignore
     # https://stackoverflow.com/a/21922058