iplotx 0.9.0__tar.gz → 0.10.0__tar.gz

{iplotx-0.9.0 → iplotx-0.10.0}/.github/workflows/test.yml

@@ -4,10 +4,7 @@
 name: Python package
 
 on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
+  [push, pull_request]
 
 jobs:
   build:

{iplotx-0.9.0 → iplotx-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 0.9.0
+Version: 0.10.0
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx
@@ -29,7 +29,6 @@ Requires-Python: >=3.11
 Requires-Dist: matplotlib>=2.0.0
 Requires-Dist: numpy>=2.0.0
 Requires-Dist: pandas>=2.0.0
-Requires-Dist: pylint>=3.3.7
 Provides-Extra: igraph
 Requires-Dist: igraph>=0.11.0; extra == 'igraph'
 Provides-Extra: networkx

{iplotx-0.9.0 → iplotx-0.10.0}/docs/source/sg_execution_times.rst

@@ -6,7 +6,7 @@
 
 Computation times
 =================
-**00:00.798** total execution time for 72 files **from all galleries**:
+**00:00.060** total execution time for 73 files **from all galleries**:
 
 .. container::
 
@@ -32,23 +32,8 @@ Computation times
    * - Example
      - Time
      - Mem (MB)
-   * - :ref:`sphx_glr_gallery_biology_plot_animal_phylogeny.py` (``../../gallery/biology/plot_animal_phylogeny.py``)
-     - 00:00.614
-     - 0.0
-   * - :ref:`sphx_glr_gallery_network_science_plot_social_network_circles.py` (``../../gallery/network_science/plot_social_network_circles.py``)
-     - 00:00.051
-     - 0.0
-   * - :ref:`sphx_glr_gallery_basic_plot_house.py` (``../../gallery/basic/plot_house.py``)
-     - 00:00.049
-     - 0.0
-   * - :ref:`sphx_glr_gallery_style_plot_arrows.py` (``../../gallery/style/plot_arrows.py``)
-     - 00:00.037
-     - 0.0
-   * - :ref:`sphx_glr_gallery_other_plot_feedbacks.py` (``../../gallery/other/plot_feedbacks.py``)
-     - 00:00.025
-     - 0.0
-   * - :ref:`sphx_glr_gallery_style_plot_edgepadding.py` (``../../gallery/style/plot_edgepadding.py``)
-     - 00:00.021
+   * - :ref:`sphx_glr_gallery_basic_plot_3d.py` (``../../gallery/basic/plot_3d.py``)
+     - 00:00.060
      - 0.0
    * - :ref:`sphx_glr_gallery_basic_plot_basic.py` (``../../gallery/basic/plot_basic.py``)
      - 00:00.000
@@ -65,12 +50,18 @@ Computation times
    * - :ref:`sphx_glr_gallery_basic_plot_grouping.py` (``../../gallery/basic/plot_grouping.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_basic_plot_house.py` (``../../gallery/basic/plot_house.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_basic_plot_loops.py` (``../../gallery/basic/plot_loops.py``)
      - 00:00.000
      - 0.0
    * - :ref:`sphx_glr_gallery_basic_plot_simple_path.py` (``../../gallery/basic/plot_simple_path.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_biology_plot_animal_phylogeny.py` (``../../gallery/biology/plot_animal_phylogeny.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_biology_plot_antibody_clone.py` (``../../gallery/biology/plot_antibody_clone.py``)
      - 00:00.000
      - 0.0
@@ -143,6 +134,9 @@ Computation times
    * - :ref:`sphx_glr_gallery_network_science_plot_simple_networkx.py` (``../../gallery/network_science/plot_simple_networkx.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_network_science_plot_social_network_circles.py` (``../../gallery/network_science/plot_social_network_circles.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_network_science_plot_traveling_salesman.py` (``../../gallery/network_science/plot_traveling_salesman.py``)
      - 00:00.000
      - 0.0
@@ -155,6 +149,9 @@ Computation times
    * - :ref:`sphx_glr_gallery_other_plot_edit_artists.py` (``../../gallery/other/plot_edit_artists.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_other_plot_feedbacks.py` (``../../gallery/other/plot_feedbacks.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_other_plot_graph.py` (``../../gallery/other/plot_graph.py``)
      - 00:00.000
      - 0.0
@@ -164,6 +161,12 @@ Computation times
    * - :ref:`sphx_glr_gallery_other_plot_train.py` (``../../gallery/other/plot_train.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_style_plot_arrows.py` (``../../gallery/style/plot_arrows.py``)
+     - 00:00.000
+     - 0.0
+   * - :ref:`sphx_glr_gallery_style_plot_edgepadding.py` (``../../gallery/style/plot_edgepadding.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_style_plot_elements.py` (``../../gallery/style/plot_elements.py``)
      - 00:00.000
      - 0.0

iplotx-0.10.0/gallery/basic/plot_3d.py

@@ -0,0 +1,29 @@
+"""
+3D layouts
+==========
+
+This example shows how to visualise graphs or networks in 3D using `iplotx`. Of course, a 3D layout is needed
+for this. Here, we use the Fruchterman-Reingold layout algorithm from ``igraph`` to generate a 3D layout.
+
+.. warning::
+    3D visualisation does not support all features of 2D visualisation yet. Curved edges, waypoints, and labels
+    are currently unsupported. PRs are welcome!
+"""
+
+import igraph as ig
+import iplotx as ipx
+
+# Make the graph
+g = ig.Graph.Erdos_Renyi(30, m=50)
+
+# Make a 3D layout
+layout = g.layout_fruchterman_reingold_3d()
+
+# Visualise the graph in 3D
+ipx.network(
+    g,
+    layout,
+    vertex_alpha=0.7,
+    edge_alpha=0.4,
+    figsize=(8, 8),
+)

iplotx-0.10.0/iplotx/art3d/edge.py

@@ -0,0 +1,65 @@
+"""
+Module containing code to manipulate edge visualisations in 3D, especially the Edge3DCollection class.
+"""
+
+from mpl_toolkits.mplot3d.art3d import (
+    Line3DCollection,
+)
+
+from ..utils.matplotlib import (
+    _forwarder,
+)
+from ..edge import (
+    EdgeCollection,
+)
+
+
+@_forwarder(
+    (
+        "set_clip_path",
+        "set_clip_box",
+        "set_snap",
+        "set_sketch_params",
+        "set_animated",
+        "set_picker",
+    )
+)
+class Edge3DCollection(Line3DCollection):
+    """Collection of vertex patches for plotting."""
+
+    pass
+
+
+def edge_collection_2d_to_3d(
+    col: EdgeCollection,
+    zdir: str = "z",
+    depthshade: bool = True,
+    axlim_clip: bool = False,
+):
+    """Convert a 2D EdgeCollection to a 3D Edge3DCollection.
+
+    Parameters:
+        col: The 2D EdgeCollection to convert.
+        zs: The z coordinate(s) to use for the 3D vertices.
+        zdir: The axis to use as the z axis (default is "z").
+        depthshade: Whether to apply depth shading (default is True).
+        axlim_clip: Whether to clip the vertices to the axes limits (default is False).
+    """
+    if not isinstance(col, EdgeCollection):
+        raise TypeError("vertices must be a VertexCollection")
+
+    # TODO: if we make Edge3DCollection a dynamic drawer, this will need to change
+    # fundamentally. Also, this currently does not handle labels properly.
+    vinfo = col._get_adjacent_vertices_info()
+
+    segments3d = []
+    for offset1, offset2 in vinfo["offsets"]:
+        segment = [tuple(offset1), tuple(offset2)]
+        segments3d.append(segment)
+
+    # NOTE: after this line, none of the EdgeCollection methods will work
+    # It's become a static drawer now
+    col.__class__ = Edge3DCollection
+
+    col.set_segments(segments3d)
+    col._axlim_clip = axlim_clip

iplotx-0.10.0/iplotx/art3d/vertex.py

@@ -0,0 +1,69 @@
+"""
+Module containing code to manipulate vertex visualisations in 3D, especially the Vertex3DCollection class.
+"""
+
+from typing import (
+    Sequence,
+)
+import numpy as np
+from matplotlib import (
+    cbook,
+)
+from mpl_toolkits.mplot3d.art3d import Path3DCollection
+
+from ..utils.matplotlib import (
+    _forwarder,
+)
+from ..vertex import (
+    VertexCollection,
+)
+
+
+@_forwarder(
+    (
+        "set_clip_path",
+        "set_clip_box",
+        "set_snap",
+        "set_sketch_params",
+        "set_animated",
+        "set_picker",
+    )
+)
+class Vertex3DCollection(VertexCollection, Path3DCollection):
+    """Collection of vertex patches for plotting."""
+
+    def draw(self, renderer) -> None:
+        """Draw the collection of vertices in 3D.
+
+        Parameters:
+            renderer: The renderer to use for drawing.
+        """
+        with self._use_zordered_offset():
+            with cbook._setattr_cm(self, _in_draw=True):
+                VertexCollection.draw(self, renderer)
+
+
+def vertex_collection_2d_to_3d(
+    col: VertexCollection,
+    zs: np.ndarray | float | Sequence[float] = 0,
+    zdir: str = "z",
+    depthshade: bool = True,
+    axlim_clip: bool = False,
+):
+    """Convert a 2D VertexCollection to a 3D Vertex3DCollection.
+
+    Parameters:
+        col: The 2D VertexCollection to convert.
+        zs: The z coordinate(s) to use for the 3D vertices.
+        zdir: The axis to use as the z axis (default is "z").
+        depthshade: Whether to apply depth shading (default is True).
+        axlim_clip: Whether to clip the vertices to the axes limits (default is False).
+    """
+    if not isinstance(col, VertexCollection):
+        raise TypeError("vertices must be a VertexCollection")
+
+    col.__class__ = Vertex3DCollection
+    col._offset_zordered = None
+    col._depthshade = depthshade
+    col._in_draw = False
+    col.set_3d_properties(zs, zdir, axlim_clip)

{iplotx-0.9.0 → iplotx-0.10.0}/iplotx/artists.py

@@ -10,6 +10,8 @@ from .label import LabelCollection
 from .edge.arrow import EdgeArrowCollection
 from .edge.leaf import LeafEdgeCollection
 from .cascades import CascadeCollection
+from .art3d.vertex import Vertex3DCollection
+from .art3d.edge import Edge3DCollection
 
 
 ___all__ = (
@@ -21,4 +23,6 @@ ___all__ = (
     LabelCollection,
     EdgeArrowCollection,
     CascadeCollection,
+    Vertex3DCollection,
+    Edge3DCollection,
 )

{iplotx-0.9.0 → iplotx-0.10.0}/iplotx/edge/__init__.py

@@ -193,6 +193,16 @@ class EdgeCollection(mpl.collections.PatchCollection):
         self._update_arrows()
         self._update_labels()
 
+    def set_transform(self, transform: mpl.transforms.Transform) -> None:
+        """Set the transform for the edges and their children."""
+        super().set_transform(transform)
+        if hasattr(self, "_subedges"):
+            self._subedges.set_transform(transform)
+        if hasattr(self, "_arrows"):
+            self._arrows.set_offset_transform(transform)
+        if hasattr(self, "_label_collection"):
+            self._label_collection.set_transform(transform)
+
     @property
     def directed(self) -> bool:
         """Whether the network is directed."""

{iplotx-0.9.0 → iplotx-0.10.0}/iplotx/edge/geometry.py

@@ -1,5 +1,7 @@
 """
 Support module with geometry- and path-related functions for edges.
+
+3D geometry is in its separate module :mod:`.geometry3d`.
 """
 
 from typing import (
@@ -14,6 +16,7 @@ from ..typing import (
     Pair,
 )
 from .ports import _get_port_unit_vector
+from .geometry3d import _compute_edge_path_3d
 
 
 def _compute_loops_per_angle(nloops, angles):
@@ -65,6 +68,14 @@ def _compute_loops_per_angle(nloops, angles):
 
 
 def _get_shorter_edge_coords(vpath, vsize, theta, shrink=0):
+    """Get the coordinates of an edge tip such that it touches the vertex border.
+
+    Parameters:
+        vpath: The vertex path, in figure coordinates (so scaled by dpi).
+        vsize: The vertex max size, in figure coordinates (so scaled by dpi).
+        theta: The angle of the edge inpinging into the vertex, in radians, in figure coordinates.
+        shrink: Additional shrinking of the edge, in figure coordinates (so scaled by dpi).
+    """
     # Bound theta from -pi to pi (why is that not guaranteed?)
     theta = (theta + pi) % (2 * pi) - pi
 
@@ -468,7 +479,7 @@ def _compute_edge_path_curved(
     return path, tuple(thetas)
 
 
-def _compute_edge_path(
+def _compute_edge_path_2d(
     *args,
     tension: float = 0,
     waypoints: str | tuple[float, float] | Sequence[tuple[float, float]] | np.ndarray = "none",
@@ -502,3 +513,25 @@ def _compute_edge_path(
         ports=ports,
         **kwargs,
     )
+
+
+def _compute_edge_path(
+    vcoord_data,
+    *args,
+    **kwargs,
+):
+    """Compute the edge path in either 2D or 3D.
+
+    Parameters:
+        vcoord_data: The vertex coordinates in data coordinates. This is used to
+            determine the dimensionality of the layout.
+        *args: Additional arguments passed to the internal functions.
+        **kwargs: Additional keyword arguments passed to the internal functions.
+
+    Returns:
+        The computed edge path and the angles at the start and end of the edge.
+    """
+    ndim = len(vcoord_data[0])
+    if ndim == 2:
+        return _compute_edge_path_2d(vcoord_data, *args, **kwargs)
+    return _compute_edge_path_3d(vcoord_data, *args, **kwargs)

iplotx-0.10.0/iplotx/edge/geometry3d.py

@@ -0,0 +1,113 @@
+"""
+Support for computing edge paths in 3D.
+"""
+
+from typing import (
+    Optional,
+    Sequence,
+)
+import numpy as np
+import matplotlib as mpl
+
+from ..typing import (
+    Pair,
+)
+
+
+def _compute_edge_path_straight(
+    vcoord_data,
+    vpath_fig,
+    vsize_fig,
+    trans,
+    trans_inv,
+    layout_coordinate_system: str = "cartesian",
+    shrink: float = 0,
+    **kwargs,
+):
+    """Compute straight edge path between two vertices, in 3D.
+
+    Parameters:
+        vcoord_data: Vertex coordinates in data coordinates, shape (2, 3).
+        vpath_fig: Vertex path in figure coordinates.
+        vsize_fig: Vertex size in figure coordinates.
+        trans: Transformation from data to figure coordinates.
+        trans_inv: Inverse transformation from figure to data coordinates.
+        layout_coordinate_system: The coordinate system of the layout.
+        shrink: Amount to shorten the edge at each end, in figure coordinates.
+        **kwargs: Additional keyword arguments (not used).
+    Returns:
+        A pair with the path and a tuple of angles of exit and entry, in radians.
+
+    """
+
+    if layout_coordinate_system not in ("cartesian"):
+        raise ValueError(
+            f"Layout coordinate system not supported for straight edges in 3D: {layout_coordinate_system}.",
+        )
+
+    vcoord_data_cart = vcoord_data
+
+    # Coordinates in figure (default) coords
+    vcoord_fig = trans(vcoord_data_cart)
+
+    points = []
+
+    # Angles of the straight line
+    # FIXME: In 2D, this is only used to make space for loops
+    # let's ignore for now
+    # theta = atan2(*((vcoord_fig[1] - vcoord_fig[0])[::-1]))
+    theta = 0
+
+    # TODO: Shorten at starting vertex (?)
+    vs = vcoord_fig[0]
+    points.append(vs)
+
+    # TODO: Shorten at end vertex (?)
+    ve = vcoord_fig[1]
+    points.append(ve)
+
+    codes = ["MOVETO", "LINETO"]
+    path = mpl.path.Path(
+        points,
+        codes=[getattr(mpl.path.Path, x) for x in codes],
+    )
+    path.vertices = trans_inv(path.vertices)
+    return path, (theta, theta + np.pi)
+
+
+def _compute_edge_path_3d(
+    *args,
+    tension: float = 0,
+    waypoints: str | tuple[float, float] | Sequence[tuple[float, float]] | np.ndarray = "none",
+    ports: Pair[Optional[str]] = (None, None),
+    layout_coordinate_system: str = "cartesian",
+    **kwargs,
+):
+    """Compute the edge path in a few different ways."""
+    if (waypoints != "none") and (tension != 0):
+        raise ValueError("Waypoints not supported for curved edges.")
+
+    if waypoints != "none":
+        raise NotImplementedError("Waypoints not implemented for 3D edges.")
+        # return _compute_edge_path_waypoints(
+        #    waypoints,
+        #    *args,
+        #    layout_coordinate_system=layout_coordinate_system,
+        #    ports=ports,
+        #    **kwargs,
+        # )
+
+    if np.isscalar(tension) and (tension == 0):
+        return _compute_edge_path_straight(
+            *args,
+            layout_coordinate_system=layout_coordinate_system,
+            **kwargs,
+        )
+
+    raise NotImplementedError("Curved edges not implemented for 3D edges.")
+    # return _compute_edge_path_curved(
+    #    tension,
+    #    *args,
+    #    ports=ports,
+    #    **kwargs,
+    # )

{iplotx-0.9.0 → iplotx-0.10.0}/iplotx/groups.py

@@ -4,6 +4,7 @@ Module for vertex groupings code, especially the GroupingArtist class.
 
 from typing import Union
 import numpy as np
+import pandas as pd
 import matplotlib as mpl
 from matplotlib.collections import PatchCollection
 
@@ -64,6 +65,9 @@ class GroupingArtist(PatchCollection):
         self._points_per_curve = points_per_curve
 
         network = kwargs.pop("network", None)
+        self.layout = normalise_layout(layout, network=network)
+        self.ndim = layout.shape[1]
+
         patches, grouping, coords_hulls = self._create_patches(
             grouping,
             layout,
@@ -89,6 +93,21 @@ class GroupingArtist(PatchCollection):
         self._compute_paths(self.get_figure(root=True).dpi)
         return ret
 
+    @property
+    def axes(self):
+        return PatchCollection.axes.__get__(self)
+
+    @axes.setter
+    def axes(self, new_axes):
+        PatchCollection.axes.__set__(self, new_axes)
+        for child in self.get_children():
+            child.axes = new_axes
+        self.set_figure(new_axes.figure)
+
+    def get_layout(self) -> pd.DataFrame:
+        """Get the layout used for this grouping."""
+        return self.layout
+
     def get_vertexpadding(self) -> float:
         """Get the vertex padding of each group."""
         return self._vertexpadding
@@ -98,7 +117,6 @@ class GroupingArtist(PatchCollection):
         return self.get_vertexpadding() * dpi / 72.0 * self._factor
 
     def _create_patches(self, grouping, layout, network, **kwargs):
-        layout = normalise_layout(layout, network=network)
         grouping = normalise_grouping(grouping, layout)
         style = get_style(".grouping")
         style.pop("vertexpadding", None)

{iplotx-0.9.0 → iplotx-0.10.0}/iplotx/ingest/providers/network/igraph.py

@@ -30,23 +30,22 @@ class IGraphDataProvider(NetworkDataProvider):
         edge_labels: Optional[Sequence[str] | dict[str]] = None,
     ) -> NetworkData:
         """Create network data object for iplotx from an igraph object."""
-        network = self.network
-        directed = self.is_directed()
 
-        # Recast vertex_labels=False as vertex_labels=None
-        if np.isscalar(vertex_labels) and (not vertex_labels):
-            vertex_labels = None
-
-        # Vertices are ordered integers, no gaps
+        # Get layout
         vertex_df = normalise_layout(
             layout,
-            network=network,
+            network=self.network,
             nvertices=self.number_of_vertices(),
         )
         ndim = vertex_df.shape[1]
         vertex_df.columns = _make_layout_columns(ndim)
 
+        # Vertices are ordered integers, no gaps
+
         # Vertex labels
+        # Recast vertex_labels=False as vertex_labels=None
+        if np.isscalar(vertex_labels) and (not vertex_labels):
+            vertex_labels = None
         if vertex_labels is not None:
             if np.isscalar(vertex_labels):
                 vertex_df["label"] = vertex_df.index.astype(str)
@@ -57,7 +56,7 @@ class IGraphDataProvider(NetworkDataProvider):
 
         # Edges are a list of tuples, because of multiedges
         tmp = []
-        for edge in network.es:
+        for edge in self.network.es:
             row = {"_ipx_source": edge.source, "_ipx_target": edge.target}
             row.update(edge.attributes())
             tmp.append(row)
@@ -76,7 +75,7 @@ class IGraphDataProvider(NetworkDataProvider):
         network_data = {
             "vertex_df": vertex_df,
             "edge_df": edge_df,
-            "directed": directed,
+            "directed": self.is_directed(),
             "ndim": ndim,
         }
         return network_data

{iplotx-0.9.0 → iplotx-0.10.0}/iplotx/ingest/providers/network/networkx.py

@@ -33,25 +33,20 @@ class NetworkXDataProvider(NetworkDataProvider):
 
         import networkx as nx
 
-        network = self.network
-
-        directed = self.is_directed()
-
-        # Recast vertex_labels=False as vertex_labels=None
-        if np.isscalar(vertex_labels) and (not vertex_labels):
-            vertex_labels = None
-
-        # Vertices are indexed by node ID
+        # Get layout
         vertex_df = normalise_layout(
             layout,
-            network=network,
+            network=self.network,
             nvertices=self.number_of_vertices(),
-        ).loc[pd.Index(network.nodes)]
+        )
         ndim = vertex_df.shape[1]
         vertex_df.columns = _make_layout_columns(ndim)
 
+        # Vertices are indexed by node ID
+        vertex_df = vertex_df.loc[pd.Index(self.network.nodes)]
+
         # Vertex internal properties
-        tmp = pd.DataFrame(dict(network.nodes.data())).T
+        tmp = pd.DataFrame(dict(self.network.nodes.data())).T
         # Arrays become a single column, which we have already anyway
         if isinstance(layout, str) and (layout in tmp.columns):
             del tmp[layout]
@@ -60,6 +55,9 @@ class NetworkXDataProvider(NetworkDataProvider):
         del tmp
 
         # Vertex labels
+        # Recast vertex_labels=False as vertex_labels=None
+        if np.isscalar(vertex_labels) and (not vertex_labels):
+            vertex_labels = None
         if vertex_labels is None:
             if "label" in vertex_df:
                 del vertex_df["label"]
@@ -78,7 +76,7 @@ class NetworkXDataProvider(NetworkDataProvider):
 
         # Edges are a list of tuples, because of multiedges
         tmp = []
-        for u, v, d in network.edges.data():
+        for u, v, d in self.network.edges.data():
             row = {"_ipx_source": u, "_ipx_target": v}
             row.update(d)
             tmp.append(row)
@@ -112,7 +110,7 @@ class NetworkXDataProvider(NetworkDataProvider):
         network_data = {
             "vertex_df": vertex_df,
             "edge_df": edge_df,
-            "directed": directed,
+            "directed": self.is_directed(),
             "ndim": ndim,
         }
         return network_data

{iplotx-0.9.0 → iplotx-0.10.0}/iplotx/label.py

@@ -77,6 +77,17 @@ class LabelCollection(mpl.artist.Artist):
             child.set_figure(fig)
         self._update_offsets(dpi=fig.dpi)
 
+    def set_transform(self, transform: mpl.transforms.Transform) -> None:
+        """Set the transform for this artist and children.
+
+        Parameters:
+            transform: The transform to set.
+        """
+        super().set_transform(transform)
+        if hasattr(self, "_labelartists"):
+            for art in self._labelartists:
+                art.set_transform(transform)
+
     def get_texts(self):
         """Get the texts of the labels."""
         return [child.get_text() for child in self.get_children()]