Fix MultiPolygon patch creation for inverted inner rings

src/spatialdata_plot/pl/utils.py

@@ -52,6 +52,7 @@
 from scanpy.plotting._utils import add_colors_for_categorical_sample_annotation
 from scanpy.plotting.palettes import default_20, default_28, default_102
 from scipy.spatial import ConvexHull
+from shapely.errors import GEOSException
 from skimage.color import label2rgb
 from skimage.morphology import erosion, square
 from skimage.segmentation import find_boundaries
@@ -445,8 +446,35 @@ def _as_rgba_array(x: Any) -> np.ndarray:
  else:
  outline_c = [None] * fill_c.shape[0]
 
- # Build DataFrame of valid geometries
- shapes_df = pd.DataFrame(shapes, copy=True)
+ if isinstance(shapes, GeoDataFrame):
+ shapes_df: GeoDataFrame | pd.DataFrame = shapes.copy()
+ else:
+ shapes_df = pd.DataFrame(shapes, copy=True)
+
+ # Robustly normalise geometries to a canonical representation.
+ # This ensures consistent exterior/interior ring orientation so that
+ # matplotlib's fill rules handle holes correctly regardless of user input.
+ if "geometry" in shapes_df.columns:
+
+ def _normalize_geom(geom: Any) -> Any:
+ if geom is None or getattr(geom, "is_empty", False):
+ return geom
+ # shapely.normalize is available in shapely>=2; fall back to geom.normalize()
+ normalize_func = getattr(shapely, "normalize", None)
+ if callable(normalize_func):
+ try:
+ return normalize_func(geom)
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ if hasattr(geom, "normalize"):
+ try:
+ return geom.normalize()
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ return geom
+
+ shapes_df["geometry"] = shapes_df["geometry"].apply(_normalize_geom)
+
  shapes_df = shapes_df[shapes_df["geometry"].apply(lambda geom: not geom.is_empty)]
  shapes_df = shapes_df.reset_index(drop=True)
 
@@ -1672,52 +1700,36 @@ def _validate_polygons(shapes: GeoDataFrame) -> GeoDataFrame:
  return shapes
 
 
-def _collect_polygon_rings(
- geom: shapely.Polygon | shapely.MultiPolygon,
-) -> list[tuple[np.ndarray, list[np.ndarray]]]:
- """Collect exterior/interior coordinate rings from (Multi)Polygons."""
- polygons: list[tuple[np.ndarray, list[np.ndarray]]] = []
-
- def _collect(part: shapely.Polygon | shapely.MultiPolygon) -> None:
- if part.geom_type == "Polygon":
- exterior = np.asarray(part.exterior.coords)
- interiors = [np.asarray(interior.coords) for interior in part.interiors]
- polygons.append((exterior, interiors))
- elif part.geom_type == "MultiPolygon":
- for child in part.geoms:
- _collect(child)
- else:
- raise ValueError(f"Unhandled geometry type: {repr(part.geom_type)}")
-
- _collect(geom)
- return polygons
-
+def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> list[mpatches.PathPatch]:
+ """
+ Create PathPatches from a MultiPolygon, preserving holes robustly.
 
-def _create_ring_codes(length: int) -> npt.NDArray[np.uint8]:
- codes = np.full(length, mpath.Path.LINETO, dtype=mpath.Path.code_type)
- codes[0] = mpath.Path.MOVETO
- return codes
+ This follows the same strategy as GeoPandas' internal Polygon plotting:
+ each (multi)polygon part becomes a compound Path composed of the exterior
+ ring and all interior rings. Orientation is handled by prior geometry
+ normalization rather than manual ring reversal.
+ """
+ patches: list[mpatches.PathPatch] = []
 
+ for poly in mp.geoms:
+ if poly.is_empty:
+ continue
 
-def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> mpatches.PathPatch:
- # https://matplotlib.org/stable/gallery/shapes_and_collections/donut.html
+ # Ensure 2D vertices in case geometries carry Z
+ exterior = np.asarray(poly.exterior.coords)[..., :2]
+ interiors = [np.asarray(ring.coords)[..., :2] for ring in poly.interiors]
 
- patches = []
- for exterior, interiors in _collect_polygon_rings(mp):
  if len(interiors) == 0:
+ # Simple polygon without holes
  patches.append(mpatches.Polygon(exterior, closed=True))
  continue
 
- ring_vertices = [exterior]
- ring_codes = [_create_ring_codes(len(exterior))]
- for hole in interiors:
- reversed_hole = hole[::-1]
- ring_vertices.append(reversed_hole)
- ring_codes.append(_create_ring_codes(len(reversed_hole)))
-
- vertices = np.concatenate(ring_vertices)
- all_codes = np.concatenate(ring_codes)
- patches.append(mpatches.PathPatch(mpath.Path(vertices, all_codes)))
+ # Build a compound path: exterior + all interior rings
+ compound_path = mpath.Path.make_compound_path(
+ mpath.Path(exterior, closed=True),
+ *[mpath.Path(ring, closed=True) for ring in interiors],
+ )
+ patches.append(mpatches.PathPatch(compound_path))
 
  return patches
 

tests/pl/test_render_shapes.py

@@ -130,6 +130,81 @@ def test_plot_can_render_multipolygons_that_say_they_are_polygons(self):
 
  fig.tight_layout()
 
+ def test_plot_can_render_polygon_with_inverted_inner_ring(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ polygon = Polygon(ext, [interior])
+ geo_df = gpd.GeoDataFrame(geometry=[polygon])
+ sdata = SpatialData(shapes={"inverted_ring": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring").pl.show(ax=ax)
+ ax.set_xlim(0, 250)
+ ax.set_ylim(0, 250)
+
+ fig.tight_layout()
+
+ def test_plot_can_render_multipolygon_with_inverted_inner_ring_and_disjoint_part(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ # Part with a hole and non-standard orientation, plus a disjoint simple part
+ poly_with_hole = Polygon(ext, [interior])
+ disjoint_poly = Polygon(
+ [
+ (300.0, 300.0),
+ (320.0, 300.0),
+ (320.0, 320.0),
+ (300.0, 320.0),
+ (300.0, 300.0),
+ ]
+ )
+ multipoly = MultiPolygon([poly_with_hole, disjoint_poly])
+ geo_df = gpd.GeoDataFrame(geometry=[multipoly])
+ sdata = SpatialData(shapes={"inverted_ring_multipoly": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring_multipoly").pl.show(ax=ax)
+ ax.set_xlim(0, 350)
+ ax.set_ylim(0, 350)
+
+ fig.tight_layout()
+
  def test_plot_can_color_multipolygons_with_multiple_holes(self):
  square = [(0.0, 0.0), (5.0, 0.0), (5.0, 5.0), (0.0, 5.0), (0.0, 0.0)]
  first_hole = [(1.0, 1.0), (2.0, 1.0), (2.0, 2.0), (1.0, 2.0), (1.0, 1.0)]

src/spatialdata_plot/pl/utils.py

@@ -52,6 +52,7 @@
 from scanpy.plotting._utils import add_colors_for_categorical_sample_annotation
 from scanpy.plotting.palettes import default_20, default_28, default_102
 from scipy.spatial import ConvexHull
+from shapely.errors import GEOSException
 from skimage.color import label2rgb
 from skimage.morphology import erosion, square
 from skimage.segmentation import find_boundaries
@@ -445,8 +446,35 @@ def _as_rgba_array(x: Any) -> np.ndarray:
  else:
  outline_c = [None] * fill_c.shape[0]
 
- # Build DataFrame of valid geometries
- shapes_df = pd.DataFrame(shapes, copy=True)
+ if isinstance(shapes, GeoDataFrame):
+ shapes_df: GeoDataFrame | pd.DataFrame = shapes.copy()
+ else:
+ shapes_df = pd.DataFrame(shapes, copy=True)
+
+ # Robustly normalise geometries to a canonical representation.
+ # This ensures consistent exterior/interior ring orientation so that
+ # matplotlib's fill rules handle holes correctly regardless of user input.
+ if "geometry" in shapes_df.columns:
+
+ def _normalize_geom(geom: Any) -> Any:
+ if geom is None or getattr(geom, "is_empty", False):
+ return geom
+ # shapely.normalize is available in shapely>=2; fall back to geom.normalize()
+ normalize_func = getattr(shapely, "normalize", None)
+ if callable(normalize_func):
+ try:
+ return normalize_func(geom)
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ if hasattr(geom, "normalize"):
+ try:
+ return geom.normalize()
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ return geom
+
+ shapes_df["geometry"] = shapes_df["geometry"].apply(_normalize_geom)
+
  shapes_df = shapes_df[shapes_df["geometry"].apply(lambda geom: not geom.is_empty)]
  shapes_df = shapes_df.reset_index(drop=True)
 
@@ -1672,52 +1700,36 @@ def _validate_polygons(shapes: GeoDataFrame) -> GeoDataFrame:
  return shapes
 
 
-def _collect_polygon_rings(
- geom: shapely.Polygon | shapely.MultiPolygon,
-) -> list[tuple[np.ndarray, list[np.ndarray]]]:
- """Collect exterior/interior coordinate rings from (Multi)Polygons."""
- polygons: list[tuple[np.ndarray, list[np.ndarray]]] = []
-
- def _collect(part: shapely.Polygon | shapely.MultiPolygon) -> None:
- if part.geom_type == "Polygon":
- exterior = np.asarray(part.exterior.coords)
- interiors = [np.asarray(interior.coords) for interior in part.interiors]
- polygons.append((exterior, interiors))
- elif part.geom_type == "MultiPolygon":
- for child in part.geoms:
- _collect(child)
- else:
- raise ValueError(f"Unhandled geometry type: {repr(part.geom_type)}")
-
- _collect(geom)
- return polygons
-
+def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> list[mpatches.PathPatch]:
+ """
+ Create PathPatches from a MultiPolygon, preserving holes robustly.
 
-def _create_ring_codes(length: int) -> npt.NDArray[np.uint8]:
- codes = np.full(length, mpath.Path.LINETO, dtype=mpath.Path.code_type)
- codes[0] = mpath.Path.MOVETO
- return codes
+ This follows the same strategy as GeoPandas' internal Polygon plotting:
+ each (multi)polygon part becomes a compound Path composed of the exterior
+ ring and all interior rings. Orientation is handled by prior geometry
+ normalization rather than manual ring reversal.
+ """
+ patches: list[mpatches.PathPatch] = []
 
+ for poly in mp.geoms:
+ if poly.is_empty:
+ continue
 
-def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> mpatches.PathPatch:
- # https://matplotlib.org/stable/gallery/shapes_and_collections/donut.html
+ # Ensure 2D vertices in case geometries carry Z
+ exterior = np.asarray(poly.exterior.coords)[..., :2]
+ interiors = [np.asarray(ring.coords)[..., :2] for ring in poly.interiors]
 
- patches = []
- for exterior, interiors in _collect_polygon_rings(mp):
  if len(interiors) == 0:
+ # Simple polygon without holes
  patches.append(mpatches.Polygon(exterior, closed=True))
  continue
 
- ring_vertices = [exterior]
- ring_codes = [_create_ring_codes(len(exterior))]
- for hole in interiors:
- reversed_hole = hole[::-1]
- ring_vertices.append(reversed_hole)
- ring_codes.append(_create_ring_codes(len(reversed_hole)))
-
- vertices = np.concatenate(ring_vertices)
- all_codes = np.concatenate(ring_codes)
- patches.append(mpatches.PathPatch(mpath.Path(vertices, all_codes)))
+ # Build a compound path: exterior + all interior rings
+ compound_path = mpath.Path.make_compound_path(
+ mpath.Path(exterior, closed=True),
+ *[mpath.Path(ring, closed=True) for ring in interiors],
+ )
+ patches.append(mpatches.PathPatch(compound_path))
 
  return patches
 

tests/pl/test_render_shapes.py

@@ -130,6 +130,81 @@ def test_plot_can_render_multipolygons_that_say_they_are_polygons(self):
 
  fig.tight_layout()
 
+ def test_plot_can_render_polygon_with_inverted_inner_ring(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ polygon = Polygon(ext, [interior])
+ geo_df = gpd.GeoDataFrame(geometry=[polygon])
+ sdata = SpatialData(shapes={"inverted_ring": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring").pl.show(ax=ax)
+ ax.set_xlim(0, 250)
+ ax.set_ylim(0, 250)
+
+ fig.tight_layout()
+
+ def test_plot_can_render_multipolygon_with_inverted_inner_ring_and_disjoint_part(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ # Part with a hole and non-standard orientation, plus a disjoint simple part
+ poly_with_hole = Polygon(ext, [interior])
+ disjoint_poly = Polygon(
+ [
+ (300.0, 300.0),
+ (320.0, 300.0),
+ (320.0, 320.0),
+ (300.0, 320.0),
+ (300.0, 300.0),
+ ]
+ )
+ multipoly = MultiPolygon([poly_with_hole, disjoint_poly])
+ geo_df = gpd.GeoDataFrame(geometry=[multipoly])
+ sdata = SpatialData(shapes={"inverted_ring_multipoly": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring_multipoly").pl.show(ax=ax)
+ ax.set_xlim(0, 350)
+ ax.set_ylim(0, 350)
+
+ fig.tight_layout()
+
  def test_plot_can_color_multipolygons_with_multiple_holes(self):
  square = [(0.0, 0.0), (5.0, 0.0), (5.0, 5.0), (0.0, 5.0), (0.0, 0.0)]
  first_hole = [(1.0, 1.0), (2.0, 1.0), (2.0, 2.0), (1.0, 2.0), (1.0, 1.0)]

src/spatialdata_plot/pl/utils.py

@@ -52,6 +52,7 @@
 from scanpy.plotting._utils import add_colors_for_categorical_sample_annotation
 from scanpy.plotting.palettes import default_20, default_28, default_102
 from scipy.spatial import ConvexHull
+from shapely.errors import GEOSException
 from skimage.color import label2rgb
 from skimage.morphology import erosion, square
 from skimage.segmentation import find_boundaries
@@ -445,8 +446,35 @@ def _as_rgba_array(x: Any) -> np.ndarray:
  else:
  outline_c = [None] * fill_c.shape[0]
 
- # Build DataFrame of valid geometries
- shapes_df = pd.DataFrame(shapes, copy=True)
+ if isinstance(shapes, GeoDataFrame):
+ shapes_df: GeoDataFrame | pd.DataFrame = shapes.copy()
+ else:
+ shapes_df = pd.DataFrame(shapes, copy=True)
+
+ # Robustly normalise geometries to a canonical representation.
+ # This ensures consistent exterior/interior ring orientation so that
+ # matplotlib's fill rules handle holes correctly regardless of user input.
+ if "geometry" in shapes_df.columns:
+
+ def _normalize_geom(geom: Any) -> Any:
+ if geom is None or getattr(geom, "is_empty", False):
+ return geom
+ # shapely.normalize is available in shapely>=2; fall back to geom.normalize()
+ normalize_func = getattr(shapely, "normalize", None)
+ if callable(normalize_func):
+ try:
+ return normalize_func(geom)
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ if hasattr(geom, "normalize"):
+ try:
+ return geom.normalize()
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ return geom
+
+ shapes_df["geometry"] = shapes_df["geometry"].apply(_normalize_geom)
+
  shapes_df = shapes_df[shapes_df["geometry"].apply(lambda geom: not geom.is_empty)]
  shapes_df = shapes_df.reset_index(drop=True)
 
@@ -1672,52 +1700,36 @@ def _validate_polygons(shapes: GeoDataFrame) -> GeoDataFrame:
  return shapes
 
 
-def _collect_polygon_rings(
- geom: shapely.Polygon | shapely.MultiPolygon,
-) -> list[tuple[np.ndarray, list[np.ndarray]]]:
- """Collect exterior/interior coordinate rings from (Multi)Polygons."""
- polygons: list[tuple[np.ndarray, list[np.ndarray]]] = []
-
- def _collect(part: shapely.Polygon | shapely.MultiPolygon) -> None:
- if part.geom_type == "Polygon":
- exterior = np.asarray(part.exterior.coords)
- interiors = [np.asarray(interior.coords) for interior in part.interiors]
- polygons.append((exterior, interiors))
- elif part.geom_type == "MultiPolygon":
- for child in part.geoms:
- _collect(child)
- else:
- raise ValueError(f"Unhandled geometry type: {repr(part.geom_type)}")
-
- _collect(geom)
- return polygons
-
+def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> list[mpatches.PathPatch]:
+ """
+ Create PathPatches from a MultiPolygon, preserving holes robustly.
 
-def _create_ring_codes(length: int) -> npt.NDArray[np.uint8]:
- codes = np.full(length, mpath.Path.LINETO, dtype=mpath.Path.code_type)
- codes[0] = mpath.Path.MOVETO
- return codes
+ This follows the same strategy as GeoPandas' internal Polygon plotting:
+ each (multi)polygon part becomes a compound Path composed of the exterior
+ ring and all interior rings. Orientation is handled by prior geometry
+ normalization rather than manual ring reversal.
+ """
+ patches: list[mpatches.PathPatch] = []
 
+ for poly in mp.geoms:
+ if poly.is_empty:
+ continue
 
-def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> mpatches.PathPatch:
- # https://matplotlib.org/stable/gallery/shapes_and_collections/donut.html
+ # Ensure 2D vertices in case geometries carry Z
+ exterior = np.asarray(poly.exterior.coords)[..., :2]
+ interiors = [np.asarray(ring.coords)[..., :2] for ring in poly.interiors]
 
- patches = []
- for exterior, interiors in _collect_polygon_rings(mp):
  if len(interiors) == 0:
+ # Simple polygon without holes
  patches.append(mpatches.Polygon(exterior, closed=True))
  continue
 
- ring_vertices = [exterior]
- ring_codes = [_create_ring_codes(len(exterior))]
- for hole in interiors:
- reversed_hole = hole[::-1]
- ring_vertices.append(reversed_hole)
- ring_codes.append(_create_ring_codes(len(reversed_hole)))
-
- vertices = np.concatenate(ring_vertices)
- all_codes = np.concatenate(ring_codes)
- patches.append(mpatches.PathPatch(mpath.Path(vertices, all_codes)))
+ # Build a compound path: exterior + all interior rings
+ compound_path = mpath.Path.make_compound_path(
+ mpath.Path(exterior, closed=True),
+ *[mpath.Path(ring, closed=True) for ring in interiors],
+ )
+ patches.append(mpatches.PathPatch(compound_path))
 
  return patches
 

tests/pl/test_render_shapes.py

@@ -130,6 +130,81 @@ def test_plot_can_render_multipolygons_that_say_they_are_polygons(self):
 
  fig.tight_layout()
 
+ def test_plot_can_render_polygon_with_inverted_inner_ring(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ polygon = Polygon(ext, [interior])
+ geo_df = gpd.GeoDataFrame(geometry=[polygon])
+ sdata = SpatialData(shapes={"inverted_ring": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring").pl.show(ax=ax)
+ ax.set_xlim(0, 250)
+ ax.set_ylim(0, 250)
+
+ fig.tight_layout()
+
+ def test_plot_can_render_multipolygon_with_inverted_inner_ring_and_disjoint_part(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ # Part with a hole and non-standard orientation, plus a disjoint simple part
+ poly_with_hole = Polygon(ext, [interior])
+ disjoint_poly = Polygon(
+ [
+ (300.0, 300.0),
+ (320.0, 300.0),
+ (320.0, 320.0),
+ (300.0, 320.0),
+ (300.0, 300.0),
+ ]
+ )
+ multipoly = MultiPolygon([poly_with_hole, disjoint_poly])
+ geo_df = gpd.GeoDataFrame(geometry=[multipoly])
+ sdata = SpatialData(shapes={"inverted_ring_multipoly": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring_multipoly").pl.show(ax=ax)
+ ax.set_xlim(0, 350)
+ ax.set_ylim(0, 350)
+
+ fig.tight_layout()
+
  def test_plot_can_color_multipolygons_with_multiple_holes(self):
  square = [(0.0, 0.0), (5.0, 0.0), (5.0, 5.0), (0.0, 5.0), (0.0, 0.0)]
  first_hole = [(1.0, 1.0), (2.0, 1.0), (2.0, 2.0), (1.0, 2.0), (1.0, 1.0)]

src/spatialdata_plot/pl/utils.py

@@ -52,6 +52,7 @@
 from scanpy.plotting._utils import add_colors_for_categorical_sample_annotation
 from scanpy.plotting.palettes import default_20, default_28, default_102
 from scipy.spatial import ConvexHull
+from shapely.errors import GEOSException
 from skimage.color import label2rgb
 from skimage.morphology import erosion, square
 from skimage.segmentation import find_boundaries
@@ -445,8 +446,35 @@ def _as_rgba_array(x: Any) -> np.ndarray:
  else:
  outline_c = [None] * fill_c.shape[0]
 
- # Build DataFrame of valid geometries
- shapes_df = pd.DataFrame(shapes, copy=True)
+ if isinstance(shapes, GeoDataFrame):
+ shapes_df: GeoDataFrame | pd.DataFrame = shapes.copy()
+ else:
+ shapes_df = pd.DataFrame(shapes, copy=True)
+
+ # Robustly normalise geometries to a canonical representation.
+ # This ensures consistent exterior/interior ring orientation so that
+ # matplotlib's fill rules handle holes correctly regardless of user input.
+ if "geometry" in shapes_df.columns:
+
+ def _normalize_geom(geom: Any) -> Any:
+ if geom is None or getattr(geom, "is_empty", False):
+ return geom
+ # shapely.normalize is available in shapely>=2; fall back to geom.normalize()
+ normalize_func = getattr(shapely, "normalize", None)
+ if callable(normalize_func):
+ try:
+ return normalize_func(geom)
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ if hasattr(geom, "normalize"):
+ try:
+ return geom.normalize()
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ return geom
+
+ shapes_df["geometry"] = shapes_df["geometry"].apply(_normalize_geom)
+
  shapes_df = shapes_df[shapes_df["geometry"].apply(lambda geom: not geom.is_empty)]
  shapes_df = shapes_df.reset_index(drop=True)
 
@@ -1672,52 +1700,36 @@ def _validate_polygons(shapes: GeoDataFrame) -> GeoDataFrame:
  return shapes
 
 
-def _collect_polygon_rings(
- geom: shapely.Polygon | shapely.MultiPolygon,
-) -> list[tuple[np.ndarray, list[np.ndarray]]]:
- """Collect exterior/interior coordinate rings from (Multi)Polygons."""
- polygons: list[tuple[np.ndarray, list[np.ndarray]]] = []
-
- def _collect(part: shapely.Polygon | shapely.MultiPolygon) -> None:
- if part.geom_type == "Polygon":
- exterior = np.asarray(part.exterior.coords)
- interiors = [np.asarray(interior.coords) for interior in part.interiors]
- polygons.append((exterior, interiors))
- elif part.geom_type == "MultiPolygon":
- for child in part.geoms:
- _collect(child)
- else:
- raise ValueError(f"Unhandled geometry type: {repr(part.geom_type)}")
-
- _collect(geom)
- return polygons
-
+def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> list[mpatches.PathPatch]:
+ """
+ Create PathPatches from a MultiPolygon, preserving holes robustly.
 
-def _create_ring_codes(length: int) -> npt.NDArray[np.uint8]:
- codes = np.full(length, mpath.Path.LINETO, dtype=mpath.Path.code_type)
- codes[0] = mpath.Path.MOVETO
- return codes
+ This follows the same strategy as GeoPandas' internal Polygon plotting:
+ each (multi)polygon part becomes a compound Path composed of the exterior
+ ring and all interior rings. Orientation is handled by prior geometry
+ normalization rather than manual ring reversal.
+ """
+ patches: list[mpatches.PathPatch] = []
 
+ for poly in mp.geoms:
+ if poly.is_empty:
+ continue
 
-def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> mpatches.PathPatch:
- # https://matplotlib.org/stable/gallery/shapes_and_collections/donut.html
+ # Ensure 2D vertices in case geometries carry Z
+ exterior = np.asarray(poly.exterior.coords)[..., :2]
+ interiors = [np.asarray(ring.coords)[..., :2] for ring in poly.interiors]
 
- patches = []
- for exterior, interiors in _collect_polygon_rings(mp):
  if len(interiors) == 0:
+ # Simple polygon without holes
  patches.append(mpatches.Polygon(exterior, closed=True))
  continue
 
- ring_vertices = [exterior]
- ring_codes = [_create_ring_codes(len(exterior))]
- for hole in interiors:
- reversed_hole = hole[::-1]
- ring_vertices.append(reversed_hole)
- ring_codes.append(_create_ring_codes(len(reversed_hole)))
-
- vertices = np.concatenate(ring_vertices)
- all_codes = np.concatenate(ring_codes)
- patches.append(mpatches.PathPatch(mpath.Path(vertices, all_codes)))
+ # Build a compound path: exterior + all interior rings
+ compound_path = mpath.Path.make_compound_path(
+ mpath.Path(exterior, closed=True),
+ *[mpath.Path(ring, closed=True) for ring in interiors],
+ )
+ patches.append(mpatches.PathPatch(compound_path))
 
  return patches
 

tests/pl/test_render_shapes.py

@@ -130,6 +130,81 @@ def test_plot_can_render_multipolygons_that_say_they_are_polygons(self):
 
  fig.tight_layout()
 
+ def test_plot_can_render_polygon_with_inverted_inner_ring(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ polygon = Polygon(ext, [interior])
+ geo_df = gpd.GeoDataFrame(geometry=[polygon])
+ sdata = SpatialData(shapes={"inverted_ring": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring").pl.show(ax=ax)
+ ax.set_xlim(0, 250)
+ ax.set_ylim(0, 250)
+
+ fig.tight_layout()
+
+ def test_plot_can_render_multipolygon_with_inverted_inner_ring_and_disjoint_part(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ # Part with a hole and non-standard orientation, plus a disjoint simple part
+ poly_with_hole = Polygon(ext, [interior])
+ disjoint_poly = Polygon(
+ [
+ (300.0, 300.0),
+ (320.0, 300.0),
+ (320.0, 320.0),
+ (300.0, 320.0),
+ (300.0, 300.0),
+ ]
+ )
+ multipoly = MultiPolygon([poly_with_hole, disjoint_poly])
+ geo_df = gpd.GeoDataFrame(geometry=[multipoly])
+ sdata = SpatialData(shapes={"inverted_ring_multipoly": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring_multipoly").pl.show(ax=ax)
+ ax.set_xlim(0, 350)
+ ax.set_ylim(0, 350)
+
+ fig.tight_layout()
+
  def test_plot_can_color_multipolygons_with_multiple_holes(self):
  square = [(0.0, 0.0), (5.0, 0.0), (5.0, 5.0), (0.0, 5.0), (0.0, 0.0)]
  first_hole = [(1.0, 1.0), (2.0, 1.0), (2.0, 2.0), (1.0, 2.0), (1.0, 1.0)]

src/spatialdata_plot/pl/utils.py

@@ -52,6 +52,7 @@
 from scanpy.plotting._utils import add_colors_for_categorical_sample_annotation
 from scanpy.plotting.palettes import default_20, default_28, default_102
 from scipy.spatial import ConvexHull
+from shapely.errors import GEOSException
 from skimage.color import label2rgb
 from skimage.morphology import erosion, square
 from skimage.segmentation import find_boundaries
@@ -445,8 +446,35 @@ def _as_rgba_array(x: Any) -> np.ndarray:
  else:
  outline_c = [None] * fill_c.shape[0]
 
- # Build DataFrame of valid geometries
- shapes_df = pd.DataFrame(shapes, copy=True)
+ if isinstance(shapes, GeoDataFrame):
+ shapes_df: GeoDataFrame | pd.DataFrame = shapes.copy()
+ else:
+ shapes_df = pd.DataFrame(shapes, copy=True)
+
+ # Robustly normalise geometries to a canonical representation.
+ # This ensures consistent exterior/interior ring orientation so that
+ # matplotlib's fill rules handle holes correctly regardless of user input.
+ if "geometry" in shapes_df.columns:
+
+ def _normalize_geom(geom: Any) -> Any:
+ if geom is None or getattr(geom, "is_empty", False):
+ return geom
+ # shapely.normalize is available in shapely>=2; fall back to geom.normalize()
+ normalize_func = getattr(shapely, "normalize", None)
+ if callable(normalize_func):
+ try:
+ return normalize_func(geom)
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ if hasattr(geom, "normalize"):
+ try:
+ return geom.normalize()
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ return geom
+
+ shapes_df["geometry"] = shapes_df["geometry"].apply(_normalize_geom)
+
  shapes_df = shapes_df[shapes_df["geometry"].apply(lambda geom: not geom.is_empty)]
  shapes_df = shapes_df.reset_index(drop=True)
 
@@ -1672,52 +1700,36 @@ def _validate_polygons(shapes: GeoDataFrame) -> GeoDataFrame:
  return shapes
 
 
-def _collect_polygon_rings(
- geom: shapely.Polygon | shapely.MultiPolygon,
-) -> list[tuple[np.ndarray, list[np.ndarray]]]:
- """Collect exterior/interior coordinate rings from (Multi)Polygons."""
- polygons: list[tuple[np.ndarray, list[np.ndarray]]] = []
-
- def _collect(part: shapely.Polygon | shapely.MultiPolygon) -> None:
- if part.geom_type == "Polygon":
- exterior = np.asarray(part.exterior.coords)
- interiors = [np.asarray(interior.coords) for interior in part.interiors]
- polygons.append((exterior, interiors))
- elif part.geom_type == "MultiPolygon":
- for child in part.geoms:
- _collect(child)
- else:
- raise ValueError(f"Unhandled geometry type: {repr(part.geom_type)}")
-
- _collect(geom)
- return polygons
-
+def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> list[mpatches.PathPatch]:
+ """
+ Create PathPatches from a MultiPolygon, preserving holes robustly.
 
-def _create_ring_codes(length: int) -> npt.NDArray[np.uint8]:
- codes = np.full(length, mpath.Path.LINETO, dtype=mpath.Path.code_type)
- codes[0] = mpath.Path.MOVETO
- return codes
+ This follows the same strategy as GeoPandas' internal Polygon plotting:
+ each (multi)polygon part becomes a compound Path composed of the exterior
+ ring and all interior rings. Orientation is handled by prior geometry
+ normalization rather than manual ring reversal.
+ """
+ patches: list[mpatches.PathPatch] = []
 
+ for poly in mp.geoms:
+ if poly.is_empty:
+ continue
 
-def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> mpatches.PathPatch:
- # https://matplotlib.org/stable/gallery/shapes_and_collections/donut.html
+ # Ensure 2D vertices in case geometries carry Z
+ exterior = np.asarray(poly.exterior.coords)[..., :2]
+ interiors = [np.asarray(ring.coords)[..., :2] for ring in poly.interiors]
 
- patches = []
- for exterior, interiors in _collect_polygon_rings(mp):
  if len(interiors) == 0:
+ # Simple polygon without holes
  patches.append(mpatches.Polygon(exterior, closed=True))
  continue
 
- ring_vertices = [exterior]
- ring_codes = [_create_ring_codes(len(exterior))]
- for hole in interiors:
- reversed_hole = hole[::-1]
- ring_vertices.append(reversed_hole)
- ring_codes.append(_create_ring_codes(len(reversed_hole)))
-
- vertices = np.concatenate(ring_vertices)
- all_codes = np.concatenate(ring_codes)
- patches.append(mpatches.PathPatch(mpath.Path(vertices, all_codes)))
+ # Build a compound path: exterior + all interior rings
+ compound_path = mpath.Path.make_compound_path(
+ mpath.Path(exterior, closed=True),
+ *[mpath.Path(ring, closed=True) for ring in interiors],
+ )
+ patches.append(mpatches.PathPatch(compound_path))
 
  return patches
 

tests/pl/test_render_shapes.py

@@ -130,6 +130,81 @@ def test_plot_can_render_multipolygons_that_say_they_are_polygons(self):
 
  fig.tight_layout()
 
+ def test_plot_can_render_polygon_with_inverted_inner_ring(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ polygon = Polygon(ext, [interior])
+ geo_df = gpd.GeoDataFrame(geometry=[polygon])
+ sdata = SpatialData(shapes={"inverted_ring": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring").pl.show(ax=ax)
+ ax.set_xlim(0, 250)
+ ax.set_ylim(0, 250)
+
+ fig.tight_layout()
+
+ def test_plot_can_render_multipolygon_with_inverted_inner_ring_and_disjoint_part(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ # Part with a hole and non-standard orientation, plus a disjoint simple part
+ poly_with_hole = Polygon(ext, [interior])
+ disjoint_poly = Polygon(
+ [
+ (300.0, 300.0),
+ (320.0, 300.0),
+ (320.0, 320.0),
+ (300.0, 320.0),
+ (300.0, 300.0),
+ ]
+ )
+ multipoly = MultiPolygon([poly_with_hole, disjoint_poly])
+ geo_df = gpd.GeoDataFrame(geometry=[multipoly])
+ sdata = SpatialData(shapes={"inverted_ring_multipoly": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring_multipoly").pl.show(ax=ax)
+ ax.set_xlim(0, 350)
+ ax.set_ylim(0, 350)
+
+ fig.tight_layout()
+
  def test_plot_can_color_multipolygons_with_multiple_holes(self):
  square = [(0.0, 0.0), (5.0, 0.0), (5.0, 5.0), (0.0, 5.0), (0.0, 0.0)]
  first_hole = [(1.0, 1.0), (2.0, 1.0), (2.0, 2.0), (1.0, 2.0), (1.0, 1.0)]

src/spatialdata_plot/pl/utils.py

@@ -52,6 +52,7 @@
 from scanpy.plotting._utils import add_colors_for_categorical_sample_annotation
 from scanpy.plotting.palettes import default_20, default_28, default_102
 from scipy.spatial import ConvexHull
+from shapely.errors import GEOSException
 from skimage.color import label2rgb
 from skimage.morphology import erosion, square
 from skimage.segmentation import find_boundaries
@@ -445,8 +446,35 @@ def _as_rgba_array(x: Any) -> np.ndarray:
  else:
  outline_c = [None] * fill_c.shape[0]
 
- # Build DataFrame of valid geometries
- shapes_df = pd.DataFrame(shapes, copy=True)
+ if isinstance(shapes, GeoDataFrame):
+ shapes_df: GeoDataFrame | pd.DataFrame = shapes.copy()
+ else:
+ shapes_df = pd.DataFrame(shapes, copy=True)
+
+ # Robustly normalise geometries to a canonical representation.
+ # This ensures consistent exterior/interior ring orientation so that
+ # matplotlib's fill rules handle holes correctly regardless of user input.
+ if "geometry" in shapes_df.columns:
+
+ def _normalize_geom(geom: Any) -> Any:
+ if geom is None or getattr(geom, "is_empty", False):
+ return geom
+ # shapely.normalize is available in shapely>=2; fall back to geom.normalize()
+ normalize_func = getattr(shapely, "normalize", None)
+ if callable(normalize_func):
+ try:
+ return normalize_func(geom)
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ if hasattr(geom, "normalize"):
+ try:
+ return geom.normalize()
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ return geom
+
+ shapes_df["geometry"] = shapes_df["geometry"].apply(_normalize_geom)
+
  shapes_df = shapes_df[shapes_df["geometry"].apply(lambda geom: not geom.is_empty)]
  shapes_df = shapes_df.reset_index(drop=True)
 
@@ -1672,52 +1700,36 @@ def _validate_polygons(shapes: GeoDataFrame) -> GeoDataFrame:
  return shapes
 
 
-def _collect_polygon_rings(
- geom: shapely.Polygon | shapely.MultiPolygon,
-) -> list[tuple[np.ndarray, list[np.ndarray]]]:
- """Collect exterior/interior coordinate rings from (Multi)Polygons."""
- polygons: list[tuple[np.ndarray, list[np.ndarray]]] = []
-
- def _collect(part: shapely.Polygon | shapely.MultiPolygon) -> None:
- if part.geom_type == "Polygon":
- exterior = np.asarray(part.exterior.coords)
- interiors = [np.asarray(interior.coords) for interior in part.interiors]
- polygons.append((exterior, interiors))
- elif part.geom_type == "MultiPolygon":
- for child in part.geoms:
- _collect(child)
- else:
- raise ValueError(f"Unhandled geometry type: {repr(part.geom_type)}")
-
- _collect(geom)
- return polygons
-
+def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> list[mpatches.PathPatch]:
+ """
+ Create PathPatches from a MultiPolygon, preserving holes robustly.
 
-def _create_ring_codes(length: int) -> npt.NDArray[np.uint8]:
- codes = np.full(length, mpath.Path.LINETO, dtype=mpath.Path.code_type)
- codes[0] = mpath.Path.MOVETO
- return codes
+ This follows the same strategy as GeoPandas' internal Polygon plotting:
+ each (multi)polygon part becomes a compound Path composed of the exterior
+ ring and all interior rings. Orientation is handled by prior geometry
+ normalization rather than manual ring reversal.
+ """
+ patches: list[mpatches.PathPatch] = []
 
+ for poly in mp.geoms:
+ if poly.is_empty:
+ continue
 
-def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> mpatches.PathPatch:
- # https://matplotlib.org/stable/gallery/shapes_and_collections/donut.html
+ # Ensure 2D vertices in case geometries carry Z
+ exterior = np.asarray(poly.exterior.coords)[..., :2]
+ interiors = [np.asarray(ring.coords)[..., :2] for ring in poly.interiors]
 
- patches = []
- for exterior, interiors in _collect_polygon_rings(mp):
  if len(interiors) == 0:
+ # Simple polygon without holes
  patches.append(mpatches.Polygon(exterior, closed=True))
  continue
 
- ring_vertices = [exterior]
- ring_codes = [_create_ring_codes(len(exterior))]
- for hole in interiors:
- reversed_hole = hole[::-1]
- ring_vertices.append(reversed_hole)
- ring_codes.append(_create_ring_codes(len(reversed_hole)))
-
- vertices = np.concatenate(ring_vertices)
- all_codes = np.concatenate(ring_codes)
- patches.append(mpatches.PathPatch(mpath.Path(vertices, all_codes)))
+ # Build a compound path: exterior + all interior rings
+ compound_path = mpath.Path.make_compound_path(
+ mpath.Path(exterior, closed=True),
+ *[mpath.Path(ring, closed=True) for ring in interiors],
+ )
+ patches.append(mpatches.PathPatch(compound_path))
 
  return patches
 

tests/pl/test_render_shapes.py

@@ -130,6 +130,81 @@ def test_plot_can_render_multipolygons_that_say_they_are_polygons(self):
 
  fig.tight_layout()
 
+ def test_plot_can_render_polygon_with_inverted_inner_ring(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ polygon = Polygon(ext, [interior])
+ geo_df = gpd.GeoDataFrame(geometry=[polygon])
+ sdata = SpatialData(shapes={"inverted_ring": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring").pl.show(ax=ax)
+ ax.set_xlim(0, 250)
+ ax.set_ylim(0, 250)
+
+ fig.tight_layout()
+
+ def test_plot_can_render_multipolygon_with_inverted_inner_ring_and_disjoint_part(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ # Part with a hole and non-standard orientation, plus a disjoint simple part
+ poly_with_hole = Polygon(ext, [interior])
+ disjoint_poly = Polygon(
+ [
+ (300.0, 300.0),
+ (320.0, 300.0),
+ (320.0, 320.0),
+ (300.0, 320.0),
+ (300.0, 300.0),
+ ]
+ )
+ multipoly = MultiPolygon([poly_with_hole, disjoint_poly])
+ geo_df = gpd.GeoDataFrame(geometry=[multipoly])
+ sdata = SpatialData(shapes={"inverted_ring_multipoly": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring_multipoly").pl.show(ax=ax)
+ ax.set_xlim(0, 350)
+ ax.set_ylim(0, 350)
+
+ fig.tight_layout()
+
  def test_plot_can_color_multipolygons_with_multiple_holes(self):
  square = [(0.0, 0.0), (5.0, 0.0), (5.0, 5.0), (0.0, 5.0), (0.0, 0.0)]
  first_hole = [(1.0, 1.0), (2.0, 1.0), (2.0, 2.0), (1.0, 2.0), (1.0, 1.0)]

src/spatialdata_plot/pl/utils.py

@@ -52,6 +52,7 @@
 from scanpy.plotting._utils import add_colors_for_categorical_sample_annotation
 from scanpy.plotting.palettes import default_20, default_28, default_102
 from scipy.spatial import ConvexHull
+from shapely.errors import GEOSException
 from skimage.color import label2rgb
 from skimage.morphology import erosion, square
 from skimage.segmentation import find_boundaries
@@ -445,8 +446,35 @@ def _as_rgba_array(x: Any) -> np.ndarray:
  else:
  outline_c = [None] * fill_c.shape[0]
 
- # Build DataFrame of valid geometries
- shapes_df = pd.DataFrame(shapes, copy=True)
+ if isinstance(shapes, GeoDataFrame):
+ shapes_df: GeoDataFrame | pd.DataFrame = shapes.copy()
+ else:
+ shapes_df = pd.DataFrame(shapes, copy=True)
+
+ # Robustly normalise geometries to a canonical representation.
+ # This ensures consistent exterior/interior ring orientation so that
+ # matplotlib's fill rules handle holes correctly regardless of user input.
+ if "geometry" in shapes_df.columns:
+
+ def _normalize_geom(geom: Any) -> Any:
+ if geom is None or getattr(geom, "is_empty", False):
+ return geom
+ # shapely.normalize is available in shapely>=2; fall back to geom.normalize()
+ normalize_func = getattr(shapely, "normalize", None)
+ if callable(normalize_func):
+ try:
+ return normalize_func(geom)
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ if hasattr(geom, "normalize"):
+ try:
+ return geom.normalize()
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ return geom
+
+ shapes_df["geometry"] = shapes_df["geometry"].apply(_normalize_geom)
+
  shapes_df = shapes_df[shapes_df["geometry"].apply(lambda geom: not geom.is_empty)]
  shapes_df = shapes_df.reset_index(drop=True)
 
@@ -1672,52 +1700,36 @@ def _validate_polygons(shapes: GeoDataFrame) -> GeoDataFrame:
  return shapes
 
 
-def _collect_polygon_rings(
- geom: shapely.Polygon | shapely.MultiPolygon,
-) -> list[tuple[np.ndarray, list[np.ndarray]]]:
- """Collect exterior/interior coordinate rings from (Multi)Polygons."""
- polygons: list[tuple[np.ndarray, list[np.ndarray]]] = []
-
- def _collect(part: shapely.Polygon | shapely.MultiPolygon) -> None:
- if part.geom_type == "Polygon":
- exterior = np.asarray(part.exterior.coords)
- interiors = [np.asarray(interior.coords) for interior in part.interiors]
- polygons.append((exterior, interiors))
- elif part.geom_type == "MultiPolygon":
- for child in part.geoms:
- _collect(child)
- else:
- raise ValueError(f"Unhandled geometry type: {repr(part.geom_type)}")
-
- _collect(geom)
- return polygons
-
+def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> list[mpatches.PathPatch]:
+ """
+ Create PathPatches from a MultiPolygon, preserving holes robustly.
 
-def _create_ring_codes(length: int) -> npt.NDArray[np.uint8]:
- codes = np.full(length, mpath.Path.LINETO, dtype=mpath.Path.code_type)
- codes[0] = mpath.Path.MOVETO
- return codes
+ This follows the same strategy as GeoPandas' internal Polygon plotting:
+ each (multi)polygon part becomes a compound Path composed of the exterior
+ ring and all interior rings. Orientation is handled by prior geometry
+ normalization rather than manual ring reversal.
+ """
+ patches: list[mpatches.PathPatch] = []
 
+ for poly in mp.geoms:
+ if poly.is_empty:
+ continue
 
-def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> mpatches.PathPatch:
- # https://matplotlib.org/stable/gallery/shapes_and_collections/donut.html
+ # Ensure 2D vertices in case geometries carry Z
+ exterior = np.asarray(poly.exterior.coords)[..., :2]
+ interiors = [np.asarray(ring.coords)[..., :2] for ring in poly.interiors]
 
- patches = []
- for exterior, interiors in _collect_polygon_rings(mp):
  if len(interiors) == 0:
+ # Simple polygon without holes
  patches.append(mpatches.Polygon(exterior, closed=True))
  continue
 
- ring_vertices = [exterior]
- ring_codes = [_create_ring_codes(len(exterior))]
- for hole in interiors:
- reversed_hole = hole[::-1]
- ring_vertices.append(reversed_hole)
- ring_codes.append(_create_ring_codes(len(reversed_hole)))
-
- vertices = np.concatenate(ring_vertices)
- all_codes = np.concatenate(ring_codes)
- patches.append(mpatches.PathPatch(mpath.Path(vertices, all_codes)))
+ # Build a compound path: exterior + all interior rings
+ compound_path = mpath.Path.make_compound_path(
+ mpath.Path(exterior, closed=True),
+ *[mpath.Path(ring, closed=True) for ring in interiors],
+ )
+ patches.append(mpatches.PathPatch(compound_path))
 
  return patches
 

tests/pl/test_render_shapes.py

@@ -130,6 +130,81 @@ def test_plot_can_render_multipolygons_that_say_they_are_polygons(self):
 
  fig.tight_layout()
 
+ def test_plot_can_render_polygon_with_inverted_inner_ring(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ polygon = Polygon(ext, [interior])
+ geo_df = gpd.GeoDataFrame(geometry=[polygon])
+ sdata = SpatialData(shapes={"inverted_ring": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring").pl.show(ax=ax)
+ ax.set_xlim(0, 250)
+ ax.set_ylim(0, 250)
+
+ fig.tight_layout()
+
+ def test_plot_can_render_multipolygon_with_inverted_inner_ring_and_disjoint_part(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ # Part with a hole and non-standard orientation, plus a disjoint simple part
+ poly_with_hole = Polygon(ext, [interior])
+ disjoint_poly = Polygon(
+ [
+ (300.0, 300.0),
+ (320.0, 300.0),
+ (320.0, 320.0),
+ (300.0, 320.0),
+ (300.0, 300.0),
+ ]
+ )
+ multipoly = MultiPolygon([poly_with_hole, disjoint_poly])
+ geo_df = gpd.GeoDataFrame(geometry=[multipoly])
+ sdata = SpatialData(shapes={"inverted_ring_multipoly": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring_multipoly").pl.show(ax=ax)
+ ax.set_xlim(0, 350)
+ ax.set_ylim(0, 350)
+
+ fig.tight_layout()
+
  def test_plot_can_color_multipolygons_with_multiple_holes(self):
  square = [(0.0, 0.0), (5.0, 0.0), (5.0, 5.0), (0.0, 5.0), (0.0, 0.0)]
  first_hole = [(1.0, 1.0), (2.0, 1.0), (2.0, 2.0), (1.0, 2.0), (1.0, 1.0)]

src/spatialdata_plot/pl/utils.py

@@ -52,6 +52,7 @@
 from scanpy.plotting._utils import add_colors_for_categorical_sample_annotation
 from scanpy.plotting.palettes import default_20, default_28, default_102
 from scipy.spatial import ConvexHull
+from shapely.errors import GEOSException
 from skimage.color import label2rgb
 from skimage.morphology import erosion, square
 from skimage.segmentation import find_boundaries
@@ -445,8 +446,35 @@ def _as_rgba_array(x: Any) -> np.ndarray:
  else:
  outline_c = [None] * fill_c.shape[0]
 
- # Build DataFrame of valid geometries
- shapes_df = pd.DataFrame(shapes, copy=True)
+ if isinstance(shapes, GeoDataFrame):
+ shapes_df: GeoDataFrame | pd.DataFrame = shapes.copy()
+ else:
+ shapes_df = pd.DataFrame(shapes, copy=True)
+
+ # Robustly normalise geometries to a canonical representation.
+ # This ensures consistent exterior/interior ring orientation so that
+ # matplotlib's fill rules handle holes correctly regardless of user input.
+ if "geometry" in shapes_df.columns:
+
+ def _normalize_geom(geom: Any) -> Any:
+ if geom is None or getattr(geom, "is_empty", False):
+ return geom
+ # shapely.normalize is available in shapely>=2; fall back to geom.normalize()
+ normalize_func = getattr(shapely, "normalize", None)
+ if callable(normalize_func):
+ try:
+ return normalize_func(geom)
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ if hasattr(geom, "normalize"):
+ try:
+ return geom.normalize()
+ except (GEOSException, TypeError, ValueError):
+ return geom
+ return geom
+
+ shapes_df["geometry"] = shapes_df["geometry"].apply(_normalize_geom)
+
  shapes_df = shapes_df[shapes_df["geometry"].apply(lambda geom: not geom.is_empty)]
  shapes_df = shapes_df.reset_index(drop=True)
 
@@ -1672,52 +1700,36 @@ def _validate_polygons(shapes: GeoDataFrame) -> GeoDataFrame:
  return shapes
 
 
-def _collect_polygon_rings(
- geom: shapely.Polygon | shapely.MultiPolygon,
-) -> list[tuple[np.ndarray, list[np.ndarray]]]:
- """Collect exterior/interior coordinate rings from (Multi)Polygons."""
- polygons: list[tuple[np.ndarray, list[np.ndarray]]] = []
-
- def _collect(part: shapely.Polygon | shapely.MultiPolygon) -> None:
- if part.geom_type == "Polygon":
- exterior = np.asarray(part.exterior.coords)
- interiors = [np.asarray(interior.coords) for interior in part.interiors]
- polygons.append((exterior, interiors))
- elif part.geom_type == "MultiPolygon":
- for child in part.geoms:
- _collect(child)
- else:
- raise ValueError(f"Unhandled geometry type: {repr(part.geom_type)}")
-
- _collect(geom)
- return polygons
-
+def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> list[mpatches.PathPatch]:
+ """
+ Create PathPatches from a MultiPolygon, preserving holes robustly.
 
-def _create_ring_codes(length: int) -> npt.NDArray[np.uint8]:
- codes = np.full(length, mpath.Path.LINETO, dtype=mpath.Path.code_type)
- codes[0] = mpath.Path.MOVETO
- return codes
+ This follows the same strategy as GeoPandas' internal Polygon plotting:
+ each (multi)polygon part becomes a compound Path composed of the exterior
+ ring and all interior rings. Orientation is handled by prior geometry
+ normalization rather than manual ring reversal.
+ """
+ patches: list[mpatches.PathPatch] = []
 
+ for poly in mp.geoms:
+ if poly.is_empty:
+ continue
 
-def _make_patch_from_multipolygon(mp: shapely.MultiPolygon) -> mpatches.PathPatch:
- # https://matplotlib.org/stable/gallery/shapes_and_collections/donut.html
+ # Ensure 2D vertices in case geometries carry Z
+ exterior = np.asarray(poly.exterior.coords)[..., :2]
+ interiors = [np.asarray(ring.coords)[..., :2] for ring in poly.interiors]
 
- patches = []
- for exterior, interiors in _collect_polygon_rings(mp):
  if len(interiors) == 0:
+ # Simple polygon without holes
  patches.append(mpatches.Polygon(exterior, closed=True))
  continue
 
- ring_vertices = [exterior]
- ring_codes = [_create_ring_codes(len(exterior))]
- for hole in interiors:
- reversed_hole = hole[::-1]
- ring_vertices.append(reversed_hole)
- ring_codes.append(_create_ring_codes(len(reversed_hole)))
-
- vertices = np.concatenate(ring_vertices)
- all_codes = np.concatenate(ring_codes)
- patches.append(mpatches.PathPatch(mpath.Path(vertices, all_codes)))
+ # Build a compound path: exterior + all interior rings
+ compound_path = mpath.Path.make_compound_path(
+ mpath.Path(exterior, closed=True),
+ *[mpath.Path(ring, closed=True) for ring in interiors],
+ )
+ patches.append(mpatches.PathPatch(compound_path))
 
  return patches
 

tests/pl/test_render_shapes.py

@@ -130,6 +130,81 @@ def test_plot_can_render_multipolygons_that_say_they_are_polygons(self):
 
  fig.tight_layout()
 
+ def test_plot_can_render_polygon_with_inverted_inner_ring(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ polygon = Polygon(ext, [interior])
+ geo_df = gpd.GeoDataFrame(geometry=[polygon])
+ sdata = SpatialData(shapes={"inverted_ring": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring").pl.show(ax=ax)
+ ax.set_xlim(0, 250)
+ ax.set_ylim(0, 250)
+
+ fig.tight_layout()
+
+ def test_plot_can_render_multipolygon_with_inverted_inner_ring_and_disjoint_part(self):
+ ext = [
+ (7.866043666934409, 32.80184055229537),
+ (19.016191271980425, 203.48380872801957),
+ (75.90086964475744, 236.02570144190528),
+ (229.48380872801957, 235.98380872801957),
+ (235.98380872801957, 5.516191271980426),
+ (197.42585593903195, 6.144892860751103),
+ (116.5, 96.4575926540027),
+ (55.65582863082729, 12.531294107459374),
+ (7.866043666934409, 32.80184055229537),
+ ]
+
+ interior = [
+ (160.12353079731844, 173.21221665537414),
+ (181.80184055229537, 159.13395633306558),
+ (198.86604366693442, 179.80184055229537),
+ (178.19815944770465, 198.86604366693442),
+ (160.12353079731844, 173.21221665537414),
+ ]
+
+ # Part with a hole and non-standard orientation, plus a disjoint simple part
+ poly_with_hole = Polygon(ext, [interior])
+ disjoint_poly = Polygon(
+ [
+ (300.0, 300.0),
+ (320.0, 300.0),
+ (320.0, 320.0),
+ (300.0, 320.0),
+ (300.0, 300.0),
+ ]
+ )
+ multipoly = MultiPolygon([poly_with_hole, disjoint_poly])
+ geo_df = gpd.GeoDataFrame(geometry=[multipoly])
+ sdata = SpatialData(shapes={"inverted_ring_multipoly": ShapesModel.parse(geo_df)})
+
+ fig, ax = plt.subplots()
+ sdata.pl.render_shapes(element="inverted_ring_multipoly").pl.show(ax=ax)
+ ax.set_xlim(0, 350)
+ ax.set_ylim(0, 350)
+
+ fig.tight_layout()
+
  def test_plot_can_color_multipolygons_with_multiple_holes(self):
  square = [(0.0, 0.0), (5.0, 0.0), (5.0, 5.0), (0.0, 5.0), (0.0, 0.0)]
  first_hole = [(1.0, 1.0), (2.0, 1.0), (2.0, 2.0), (1.0, 2.0), (1.0, 1.0)]