iplotx 0.3.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

iplotx/tree.py

@@ -1,6 +1,7 @@
 from typing import (
     Optional,
     Sequence,
+    Any,
 )
 from collections.abc import Hashable
 from collections import defaultdict
@@ -13,6 +14,7 @@ from .style import (
     context,
     get_style,
     rotate_style,
+    merge_styles,
 )
 from .utils.matplotlib import (
     _stale_wrapper,
@@ -30,6 +32,9 @@ from .edge import (
     EdgeCollection,
     make_stub_patch as make_undirected_edge_patch,
 )
+from .edge.leaf import (
+    LeafEdgeCollection,
+)
 from .label import (
     LabelCollection,
 )
@@ -58,24 +63,19 @@ class TreeArtist(mpl.artist.Artist):
         self,
         tree,
         layout: Optional[str] = "horizontal",
-        orientation: Optional[str] = None,
         directed: bool | str = False,
-        vertex_labels: Optional[
-            bool | list[str] | dict[Hashable, str] | pd.Series
-        ] = None,
+        vertex_labels: Optional[bool | list[str] | dict[Hashable, str] | pd.Series] = None,
         edge_labels: Optional[Sequence | dict[Hashable, str] | pd.Series] = None,
         leaf_labels: Optional[Sequence | dict[Hashable, str]] | pd.Series = None,
         transform: mpl.transforms.Transform = mpl.transforms.IdentityTransform(),
         offset_transform: Optional[mpl.transforms.Transform] = None,
+        show_support: bool = False,
     ):
         """Initialize the TreeArtist.
 
         Parameters:
             tree: The tree to plot.
             layout: The layout to use for the tree. Can be "horizontal", "vertical", or "radial".
-            orientation: The orientation of the tree layout. Can be "right" or "left" (for
-                horizontal and radial layouts) and "descending" or "ascending" (for vertical
-                layouts).
             directed: Whether the tree is directed. Can be a boolean or a string with the
                 following choices: "parent" or "child".
             vertex_labels: Labels for the vertices. Can be a list, dictionary, or pandas Series.
@@ -88,13 +88,14 @@ class TreeArtist(mpl.artist.Artist):
             transform: The transform to apply to the tree artist. This is usually the identity.
             offset_transform: The offset transform to apply to the tree artist. This is
                 usually `ax.transData`.
+            show_support: Whether to show support values on the nodes. If both show_support and
+                vertex_labels are set, this parameters takes precedence.
         """
 
         self.tree = tree
         self._ipx_internal_data = ingest_tree_data(
             tree,
             layout,
-            orientation=orientation,
             directed=directed,
             layout_style=get_style(".layout", {}),
             vertex_labels=vertex_labels,
@@ -102,6 +103,10 @@ class TreeArtist(mpl.artist.Artist):
             leaf_labels=leaf_labels,
         )
 
+        if show_support:
+            support = self._ipx_internal_data["vertex_df"]["support"]
+            self._ipx_internal_data["vertex_df"]["label"] = support
+
         super().__init__()
 
         # This is usually the identity (which scales poorly with dpi)
@@ -116,10 +121,11 @@ class TreeArtist(mpl.artist.Artist):
         self._add_vertices()
         self._add_edges()
         self._add_leaf_vertices()
+        self._add_leaf_edges()
 
         # NOTE: cascades need to be created after leaf vertices in case
         # they are requested to wrap around them.
-        if "cascade" in self.get_vertices().get_style():
+        if get_style(".cascade") != {}:
             self._add_cascades()
 
     def get_children(self) -> tuple[mpl.artist.Artist]:
@@ -131,6 +137,8 @@ class TreeArtist(mpl.artist.Artist):
         children = [self._vertices, self._edges]
         if hasattr(self, "_leaf_vertices"):
             children.append(self._leaf_vertices)
+        if hasattr(self, "_leaf_edges"):
+            children.append(self._leaf_edges)
         if hasattr(self, "_cascades"):
             children.append(self._cascades)
         return tuple(children)
@@ -141,12 +149,24 @@ class TreeArtist(mpl.artist.Artist):
         Parameters:
             fig: the figure to set for this artist and its children.
         """
-        super().set_figure(fig)
-        for child in self.get_children():
-            child.set_figure(fig)
-
         # At the end, if there are cadcades with extent depending on
         # leaf edges, we should update them
+        super().set_figure(fig)
+
+        # The next two are vanilla NetworkArtist
+        self._vertices.set_figure(fig)
+        self._edges.set_figure(fig)
+
+        # For trees, there are a few more elements to coordinate,
+        # including possibly text at the fringes (leaf labels)
+        # which might require a redraw (without rendering) to compute
+        # its actual scren real estate.
+        if hasattr(self, "_leaf_vertices"):
+            self._leaf_vertices.set_figure(fig)
+        if hasattr(self, "_leaf_edges"):
+            self._leaf_edges.set_figure(fig)
+        if hasattr(self, "_cascades"):
+            self._cascades.set_figure(fig)
         self._update_cascades_extent()
 
     def _update_cascades_extent(self) -> None:
@@ -154,7 +174,7 @@ class TreeArtist(mpl.artist.Artist):
         if not hasattr(self, "_cascades"):
             return
 
-        style_cascade = self.get_vertices().get_style()["cascade"]
+        style_cascade = get_style(".cascade")
         extend_to_labels = style_cascade.get("extend", False) == "leaf_labels"
         if not extend_to_labels:
             return
@@ -172,9 +192,7 @@ class TreeArtist(mpl.artist.Artist):
 
     def get_layout(self, kind="vertex"):
         """Get vertex or edge layout."""
-        layout_columns = [
-            f"_ipx_layout_{i}" for i in range(self._ipx_internal_data["ndim"])
-        ]
+        layout_columns = [f"_ipx_layout_{i}" for i in range(self._ipx_internal_data["ndim"])]
 
         if kind == "vertex":
             layout = self._ipx_internal_data["vertex_df"][layout_columns]
@@ -213,13 +231,16 @@ class TreeArtist(mpl.artist.Artist):
         edge_bbox = self._edges.get_datalim(transData)
         bbox = mpl.transforms.Bbox.union([bbox, edge_bbox])
 
+        if hasattr(self, "_leaf_vertices"):
+            leaf_labels_bbox = self._leaf_vertices.get_datalim(transData)
+            bbox = mpl.transforms.Bbox.union([bbox, leaf_labels_bbox])
+
         if hasattr(self, "_cascades"):
             cascades_bbox = self._cascades.get_datalim(transData)
             bbox = mpl.transforms.Bbox.union([bbox, cascades_bbox])
 
-        if hasattr(self, "_leaf_vertices"):
-            leaf_labels_bbox = self._leaf_vertices.get_datalim(transData)
-            bbox = mpl.transforms.Bbox.union([bbox, leaf_labels_bbox])
+        # NOTE: We do not need to check leaf edges for bbox, because they are
+        # guaranteed within the convex hull of leaf vertices.
 
         bbox = bbox.expanded(sw=(1.0 + pad), sh=(1.0 + pad))
         return bbox
@@ -240,8 +261,12 @@ class TreeArtist(mpl.artist.Artist):
 
     def get_leaf_vertices(self) -> Optional[VertexCollection]:
         """Get leaf VertexCollection artist."""
-        if hasattr(self, "_leaf_vertices"):
-            return self._leaf_vertices
+        return self._leaf_vertices
+
+    def get_leaf_edges(self) -> Optional[LeafEdgeCollection]:
+        """Get LeafEdgeCollection artist if present."""
+        if hasattr(self, "_leaf_edges"):
+            return self._leaf_edges
         return None
 
     def get_vertex_labels(self) -> LabelCollection:
@@ -253,8 +278,14 @@ class TreeArtist(mpl.artist.Artist):
         return self._edges.get_labels()
 
     def get_leaf_labels(self) -> Optional[LabelCollection]:
-        if hasattr(self, "_leaf_vertices"):
-            return self._leaf_vertices.get_labels()
+        """Get the leaf label artist if present."""
+        return self._leaf_vertices.get_labels()
+
+    def get_leaf_edge_labels(self) -> Optional[LabelCollection]:
+        """Get the leaf edge label artist if present."""
+        # TODO: leaf edge labels are basically unsupported as of now
+        if hasattr(self, "_leaf_edges"):
+            return self._leaf_edges.get_labels()
         return None
 
     def _add_vertices(self) -> None:
@@ -271,36 +302,149 @@ class TreeArtist(mpl.artist.Artist):
             offset_transform=self.get_offset_transform(),
         )
 
+    def _add_leaf_edges(self) -> None:
+        """Add edges from the leaf to the max leaf depth."""
+        # If there are no leaves, no leaf labels, or leaves are not deep,
+        # skip leaf edges
+        leaf_style = get_style(".leaf", {})
+        if ("deep" not in leaf_style) and self.get_leaf_labels() is None:
+            return
+        if not leaf_style.get("deep", True):
+            return
+
+        edge_style = get_style(
+            ".leafedge",
+        )
+        default_style = {
+            "linestyle": "--",
+            "linewidth": 1,
+            "edgecolor": "#111",
+        }
+        for key, value in default_style.items():
+            if key not in edge_style:
+                edge_style[key] = value
+
+        labels = None
+        # TODO: implement leaf edge labels
+        # self._get_label_series("leafedge")
+
+        if "cmap" in edge_style:
+            cmap_fun = _build_cmap_fun(
+                edge_style["color"],
+                edge_style["cmap"],
+            )
+        else:
+            cmap_fun = None
+
+        leaf_shallow_layout = self.get_layout("leaf")
+
+        if "cmap" in edge_style:
+            colorarray = []
+        edgepatches = []
+        adjacent_vertex_ids = []
+        for i, vid in enumerate(leaf_shallow_layout.index):
+            edge_stylei = rotate_style(edge_style, index=i, key=vid)
+
+            if cmap_fun is not None:
+                colorarray.append(edge_stylei["color"])
+                edge_stylei["color"] = cmap_fun(edge_stylei["color"])
+
+            # These are not the actual edges drawn, only stubs to establish
+            # the styles which are then fed into the dynamic, optimised
+            # factory (the collection) below
+            patch = make_undirected_edge_patch(
+                **edge_stylei,
+            )
+            edgepatches.append(patch)
+            adjacent_vertex_ids.append(vid)
+
+        if "cmap" in edge_style:
+            vmin = np.min(colorarray)
+            vmax = np.max(colorarray)
+            norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
+            edge_style["norm"] = norm
+
+        self._leaf_edges = LeafEdgeCollection(
+            edgepatches,
+            vertex_leaf_ids=adjacent_vertex_ids,
+            vertex_collection=self._vertices,
+            leaf_collection=self._leaf_vertices,
+            labels=labels,
+            transform=self.get_offset_transform(),
+            style=edge_style,
+            directed=False,
+        )
+        if "cmap" in edge_style:
+            self._leaf_edges.set_array(colorarray)
+
     def _add_leaf_vertices(self) -> None:
         """Add invisible deep vertices as leaf label anchors."""
+        layout_name = self._ipx_internal_data["layout_name"]
+        orientation = self._ipx_internal_data["orientation"]
+        user_leaf_style = get_style(".leaf", {})
+
         leaf_layout = self.get_layout("leaf").copy()
+
         # Set all to max depth
-        depth_idx = int(self._ipx_internal_data["layout_name"] == "vertical")
-        leaf_layout.iloc[:, depth_idx] = leaf_layout.iloc[:, depth_idx].max()
+        if user_leaf_style.get("deep", True):
+            if layout_name == "radial":
+                leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].max()
+            elif (layout_name, orientation) == ("horizontal", "right"):
+                leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].max()
+            elif (layout_name, orientation) == ("horizontal", "left"):
+                leaf_layout.iloc[:, 0] = leaf_layout.iloc[:, 0].min()
+            elif (layout_name, orientation) == ("vertical", "descending"):
+                leaf_layout.iloc[:, 1] = leaf_layout.iloc[:, 1].min()
+            elif (layout_name, orientation) == ("vertical", "ascending"):
+                leaf_layout.iloc[:, 1] = leaf_layout.iloc[:, 1].max()
+            else:
+                raise ValueError(
+                    f"Layout and orientation not supported: {layout_name}, {orientation}."
+                )
 
         # Set invisible vertices with visible labels
-        layout_name = self._ipx_internal_data["layout_name"]
-        orientation = self._ipx_internal_data["orientation"]
         if layout_name == "radial":
             ha = "auto"
-        elif orientation in ("left", "ascending"):
+            rotation = 0
+        elif orientation == "right":
+            ha = "left"
+            rotation = 0
+        elif orientation == "left":
             ha = "right"
+            rotation = 0
+        elif orientation == "ascending":
+            ha = "left"
+            rotation = 90
         else:
             ha = "left"
+            rotation = -90
 
-        leaf_vertex_style = {
+        default_leaf_style = {
             "size": 0,
             "label": {
-                "verticalalignment": "center",
+                "verticalalignment": "center_baseline",
                 "horizontalalignment": ha,
+                "rotation": rotation,
                 "hmargin": 5,
+                "vmargin": 0,
                 "bbox": {
                     "facecolor": (1, 1, 1, 0),
                 },
             },
         }
-        with context({"vertex": leaf_vertex_style}):
+        with context([{"vertex": default_leaf_style}, {"vertex": user_leaf_style}]):
             leaf_vertex_style = get_style(".vertex")
+            # Left horizontal layout has no rotation of the labels but we need to
+            # reverse hmargin
+            if (
+                layout_name == "horizontal"
+                and orientation == "left"
+                and "label" in leaf_vertex_style
+                and "hmargin" in leaf_vertex_style["label"]
+            ):
+                # Reverse the horizontal margin
+                leaf_vertex_style["label"]["hmargin"] *= -1
+
             self._leaf_vertices = VertexCollection(
                 layout=leaf_layout,
                 layout_coordinate_system=self._ipx_internal_data.get(
@@ -317,8 +461,25 @@ class TreeArtist(mpl.artist.Artist):
         """Add cascade patches."""
         # NOTE: If leaf labels are present and the cascades are requested to wrap around them,
         # we have to compute the max extend of the cascades from the leaf labels.
-        maxdepth = None
-        style_cascade = self.get_vertices().get_style()["cascade"]
+        layout = self.get_layout()
+        layout_name = self._ipx_internal_data["layout_name"]
+        orientation = self._ipx_internal_data["orientation"]
+        maxdepth = 1e-10
+        if layout_name == "horizontal":
+            if orientation == "right":
+                maxdepth = layout.values[:, 0].max()
+            else:
+                maxdepth = layout.values[:, 0].min()
+        elif layout_name == "vertical":
+            if orientation == "descending":
+                maxdepth = layout.values[:, 1].min()
+            else:
+                maxdepth = layout.values[:, 1].max()
+        elif layout_name == "radial":
+            # layout values are: r, theta
+            maxdepth = layout.values[:, 0].max()
+
+        style_cascade = get_style(".cascade")
         extend_to_labels = style_cascade.get("extend", False) == "leaf_labels"
         has_leaf_labels = self.get_leaf_labels() is not None
         if extend_to_labels and not has_leaf_labels:
@@ -329,9 +490,9 @@ class TreeArtist(mpl.artist.Artist):
 
         self._cascades = CascadeCollection(
             tree=self.tree,
-            layout=self.get_layout(),
-            layout_name=self._ipx_internal_data["layout_name"],
-            orientation=self._ipx_internal_data["orientation"],
+            layout=layout,
+            layout_name=layout_name,
+            orientation=orientation,
             style=style_cascade,
             provider=data_providers["tree"][self._ipx_internal_data["tree_library"]],
             transform=self.get_offset_transform(),
@@ -342,10 +503,7 @@ class TreeArtist(mpl.artist.Artist):
         layout_name = self.get_layout_name()
         if layout_name == "radial":
             maxdepth = 0
-            # These are the text boxes, they must all be included
-            bboxes = self.get_leaf_labels().get_datalims_children(
-                self.get_offset_transform()
-            )
+            bboxes = self.get_leaf_labels().get_datalims_children(self.get_offset_transform())
             for bbox in bboxes:
                 r1 = np.linalg.norm([bbox.xmax, bbox.ymax])
                 r2 = np.linalg.norm([bbox.xmax, bbox.ymin])
@@ -388,9 +546,7 @@ class TreeArtist(mpl.artist.Artist):
         else:
             cmap_fun = None
 
-        edge_df = self._ipx_internal_data["edge_df"].set_index(
-            ["_ipx_source", "_ipx_target"]
-        )
+        edge_df = self._ipx_internal_data["edge_df"].set_index(["_ipx_source", "_ipx_target"])
 
         if "cmap" in edge_style:
             colorarray = []
@@ -398,7 +554,7 @@ class TreeArtist(mpl.artist.Artist):
         adjacent_vertex_ids = []
         waypoints = []
         for i, (vid1, vid2) in enumerate(edge_df.index):
-            edge_stylei = rotate_style(edge_style, index=i, key=(vid1, vid2))
+            edge_stylei = rotate_style(edge_style, index=i, key=vid2)
 
             # FIXME:: Improve this logic. We have three layers of priority:
             # 1. Explicitely set in the style of "plot"
@@ -420,6 +576,8 @@ class TreeArtist(mpl.artist.Artist):
 
             # Tree layout determines waypoints
             waypointsi = edge_stylei.pop("waypoints", None)
+            if isinstance(waypointsi, (bool, np.bool)):
+                waypointsi = ["none", None][int(waypointsi)]
             if waypointsi is None:
                 layout_name = self._ipx_internal_data["layout_name"]
                 if layout_name == "horizontal":
@@ -429,7 +587,9 @@ class TreeArtist(mpl.artist.Artist):
                 elif layout_name == "radial":
                     waypointsi = "r0a1"
                 else:
-                    waypointsi = "none"
+                    raise ValueError(
+                        f"Layout not supported: {layout_name}. ",
+                    )
             waypoints.append(waypointsi)
 
             # These are not the actual edges drawn, only stubs to establish
@@ -447,7 +607,10 @@ class TreeArtist(mpl.artist.Artist):
             norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
             edge_style["norm"] = norm
 
-        edge_style["waypoints"] = waypoints
+        if get_style(".layout", {}).get("angular", False):
+            edge_style.pop("waypoints", None)
+        else:
+            edge_style["waypoints"] = waypoints
 
         # NOTE: Trees are directed is their "directed" property is True, "child", or "parent"
         self._edges = EdgeCollection(
@@ -470,24 +633,89 @@ class TreeArtist(mpl.artist.Artist):
         """Get the orientation of the tree layout."""
         return self._ipx_internal_data.get("orientation", None)
 
+    def style_subtree(
+        self,
+        nodes: Sequence[Hashable],
+        style: Optional[dict[str, Any] | Sequence[str | dict[str, Any]]] = None,
+        **kwargs,
+    ) -> None:
+        """Style a subtree of the tree.
+
+        Parameters:
+            nodes: Sequence of nodes that span the subtree. All elements below including
+                the most recent common ancestor of these leaves will be styled.
+            style: Style or sequence of styles to apply to the subtree. Each style can
+                be either a string, referring to an internal `iplotx` style, or a dictionary
+                with custom styling elements.
+            kwargs: Additional flat style elements. If both style and kwargs are provided,
+                kwargs is applied last.
+        """
+        styles = []
+        if isinstance(style, (str, dict)):
+            styles = [style]
+        elif style is not None:
+            styles = list(style)
+        style = merge_styles(styles + [kwargs])
+
+        provider = data_providers["tree"][self._ipx_internal_data["tree_library"]]
+
+        # Get last (deepest) common ancestor of the requested nodes
+        root = provider(self.tree).get_lca(nodes)
+
+        # Populate a DataFrame with the array of properties to update
+        vertex_idx = {node: i for i, node in enumerate(self._ipx_internal_data["vertex_df"].index)}
+        edge_idx = {
+            node: i
+            for i, node in enumerate(self._ipx_internal_data["edge_df"]["_ipx_target"].values)
+        }
+        vertex_props = {}
+        edge_props = {}
+        vertex_style = style.get("vertex", {})
+        edge_style = style.get("edge", {})
+        for inode, node in enumerate(provider(root).preorder()):
+            for attr, value in vertex_style.items():
+                if attr not in vertex_props:
+                    vertex_props[attr] = list(getattr(self._vertices, f"get_{attr}")())
+                vertex_props[attr][vertex_idx[node]] = value
+
+            # Ignore branch coming into the root node
+            if inode == 0:
+                continue
+
+            for attr, value in edge_style.items():
+                # Edge color is actually edgecolor
+                if attr == "color":
+                    attr = "edgecolor"
+                if attr not in edge_props:
+                    edge_props[attr] = list(getattr(self._edges, f"get_{attr}")())
+                edge_props[attr][edge_idx[node]] = value
+
+        # Update the properties from the DataFrames
+        for attr in vertex_props:
+            getattr(self._vertices, f"set_{attr}")(vertex_props[attr])
+        for attr in edge_props:
+            getattr(self._edges, f"set_{attr}")(edge_props[attr])
+
     @_stale_wrapper
     def draw(self, renderer) -> None:
         """Draw each of the children, with some buffering mechanism."""
         if not self.get_visible():
             return
 
-        # At the end, if there are cadcades with extent depending on
-        # leaf edges, we should update them
-        self._update_cascades_extent()
-
         # NOTE: looks like we have to manage the zorder ourselves
         # this is kind of funny actually. Btw we need to ensure
         # that cascades are drawn behind (earlier than) vertices
         # and edges at equal zorder because it looks better that way.
         z_suborder = defaultdict(int)
+        if hasattr(self, "_leaf_vertices"):
+            z_suborder[self._leaf_vertices] = -2
+        if hasattr(self, "_leaf_edges"):
+            z_suborder[self._leaf_edges] = -2
         if hasattr(self, "_cascades"):
             z_suborder[self._cascades] = -1
         children = list(self.get_children())
         children.sort(key=lambda x: (x.zorder, z_suborder[x]))
         for art in children:
+            if isinstance(art, CascadeCollection):
+                self._update_cascades_extent()
             art.draw(renderer)

iplotx/typing.py

@@ -32,12 +32,14 @@ LayoutType = Union[
     Sequence[Sequence[float]],
     np.ndarray,
     pd.DataFrame,
+    dict[Hashable, Sequence[float] | tuple[float, float]],
     # igraph.Layout,
 ]
 GroupingType = Union[
     Sequence[set],
     Sequence[int],
     Sequence[str],
+    dict[str, set],
     # igraph.clustering.Clustering,
     # igraph.clustering.VertexClustering,
     # igraph.clustering.Cover,

iplotx/utils/geometry.py

@@ -1,5 +1,9 @@
+from typing import (
+    Sequence,
+)
 from math import atan2
 import numpy as np
+import matplotlib as mpl
 
 
 # See also this link for the general answer (using scipy to compute coefficients):
@@ -13,28 +17,7 @@ def _evaluate_squared_bezier(points, t):
 def _evaluate_cubic_bezier(points, t):
     """Evaluate a cubic Bezier curve at t."""
     p0, p1, p2, p3 = points
-    return (
-        (1 - t) ** 3 * p0
-        + 3 * (1 - t) ** 2 * t * p1
-        + 3 * (1 - t) * t**2 * p2
-        + t**3 * p3
-    )
-
-
-def _evaluate_cubic_bezier_derivative(points, t):
-    """Evaluate the derivative of a cubic Bezier curve at t."""
-    p0, p1, p2, p3 = points
-    # (dx / dt, dy / dt) is the parametric gradient
-    # to get the angle from this, one can just atanh(dy/dt, dx/dt)
-    # This is equivalent to computing the actual bezier curve
-    # at low t, of course, which is the geometric interpretation
-    # (obviously, division by t is irrelenant)
-    return (
-        3 * p0 * (1 - t) ** 2
-        + 3 * p1 * (1 - t) * (-3 * t + 1)
-        + 3 * p2 * t * (2 - 3 * t)
-        + 3 * p3 * t**2
-    )
+    return (1 - t) ** 3 * p0 + 3 * (1 - t) ** 2 * t * p1 + 3 * (1 - t) * t**2 * p2 + t**3 * p3
 
 
 def convex_hull(points):
@@ -90,9 +73,7 @@ def _convex_hull_Graham_scan(points):
     pivot_idx = miny_idx[points[miny_idx, 0].argmin()]
 
     # Compute angles against that pivot, ensuring the pivot itself last
-    angles = np.arctan2(
-        points[:, 1] - points[pivot_idx, 1], points[:, 0] - points[pivot_idx, 0]
-    )
+    angles = np.arctan2(points[:, 1] - points[pivot_idx, 1], points[:, 0] - points[pivot_idx, 0])
     angles[pivot_idx] = np.inf
 
     # Sort points by angle
@@ -169,22 +150,36 @@ def _convex_hull_Graham_scan(points):
 
 
 def _compute_group_path_with_vertex_padding(
-    hull,
-    points,
-    transform,
-    vertexpadding=10,
-    points_per_curve=30,
+    hull: np.ndarray | Sequence[int],
+    points: np.ndarray,
+    transform: mpl.transforms.Transform,
+    vertexpadding: int = 10,
     # TODO: check how dpi affects this
-    dpi=72.0,
-):
+    dpi: float = 72.0,
+) -> np.ndarray:
     """Offset path for a group based on vertex padding.
 
-    At the input, the structure is [v1, v1, v1, ..., vn, vn, vn, v1]
-
-    # NOTE: this would look better as a cubic Bezier, but ok for now.
+    Parameters:
+        hull: The coordinates (not indices!) of the convex hull.
+        points: This is the np.ndarray where the coordinates will be written to (output).
+            The length is some integer ppc * len(hull) + 1 because for each vertex, this
+            function wraps around it using a certain fixed ppc number of points, plus the
+            final point for CLOSEPOLY.
+        transform: The transform of the hull points.
+        vertexpadding: The padding to apply to the vertices, in figure coordinates.
+        dpi (WIP): The dpi of the figure renderer.
+
+    Returns:
+        None. The output is written to the `points` array in place. This ensures that the
+        length of this array is unchanged, which is important to ensure that the vertices
+        and SVG codes are in sync.
     """
-    # Short form
-    ppc = points_per_curve
+    if len(hull) == 0:
+        return
+
+    # Short form for point per curve
+    ppc = (len(points) - 1) // len(hull)
+    assert len(points) % ppc == 1
 
     # No padding, set degenerate path
     if vertexpadding == 0:
@@ -196,11 +191,9 @@ def _compute_group_path_with_vertex_padding(
     # Transform into figure coordinates
     trans = transform.transform
     trans_inv = transform.inverted().transform
-    points = trans(points)
 
     # Singleton: draw a circle around it
     if len(hull) == 1:
-
         # NOTE: linspace is double inclusive, which covers CLOSEPOLY
         thetas = np.linspace(
             -np.pi,
@@ -213,7 +206,6 @@ def _compute_group_path_with_vertex_padding(
 
     # Doublet: draw two semicircles
     if len(hull) == 2:
-
         # Unit vector connecting the two points
         dv = trans(hull[0]) - trans(hull[1])
         dv = dv / np.sqrt((dv**2).sum())