iplotx 0.10.0__py3-none-any.whl → 0.11.1__py3-none-any.whl

iplotx/art3d/edge/__init__.py

@@ -0,0 +1,147 @@
+"""
+Module containing code to manipulate edge visualisations in 3D, especially the Edge3DCollection class.
+"""
+
+from mpl_toolkits.mplot3d import Axes3D
+from mpl_toolkits.mplot3d.art3d import (
+    Line3DCollection,
+)
+
+from ...utils.matplotlib import (
+    _forwarder,
+)
+from ...edge import (
+    EdgeCollection,
+)
+from .arrow import (
+    arrow_collection_2d_to_3d,
+)
+from .geometry import (
+    _compute_edge_segments as _compute_single_edge_segments,
+)
+
+
+@_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."""
+
+    def get_children(self) -> tuple:
+        children = []
+        if hasattr(self, "_subedges"):
+            children.append(self._subedges)
+        if hasattr(self, "_arrows"):
+            children.append(self._arrows)
+        if hasattr(self, "_label_collection"):
+            children.append(self._label_collection)
+        return tuple(children)
+
+    def set_figure(self, fig) -> None:
+        super().set_figure(fig)
+        for child in self.get_children():
+            child.set_figure(fig)
+
+    @property
+    def axes(self):
+        return Line3DCollection.axes.__get__(self)
+
+    @axes.setter
+    def axes(self, new_axes):
+        Line3DCollection.axes.__set__(self, new_axes)
+        for child in self.get_children():
+            child.axes = new_axes
+
+    _get_adjacent_vertices_info = EdgeCollection._get_adjacent_vertices_info
+
+    def _compute_edge_segments(self):
+        """Compute the edge segments for all edges."""
+        vinfo = self._get_adjacent_vertices_info()
+
+        segments3d = []
+        for vcoord_data in vinfo["offsets"]:
+            segment = _compute_single_edge_segments(
+                vcoord_data,
+            )
+            segments3d.append(segment)
+        self.set_segments(segments3d)
+
+    def _update_before_draw(self) -> None:
+        """Update the collection before drawing."""
+        if isinstance(self.axes, Axes3D) and hasattr(self, "do_3d_projection"):
+            self.do_3d_projection()
+
+        # TODO: Here's where we would shorten the edges to fit the vertex
+        # projections from 3D onto 2D, if we wanted to do that. Because edges
+        # in 3D are chains of segments rathen than splines, the shortening
+        # needs to be done in a different way to how it's done in 2D.
+
+    def draw(self, renderer) -> None:
+        """Draw the collection of vertices in 3D.
+
+        Parameters:
+            renderer: The renderer to use for drawing.
+        """
+        # Prepare the collection for drawing
+        self._update_before_draw()
+
+        # Render the Line3DCollection
+        # NOTE: we are NOT calling EdgeCollection.draw here
+        super().draw(renderer)
+
+        # This sets the labels offsets
+        # TODO: implement labels in 3D (one could copy the function from 2D,
+        # but would also need to promote the 2D labels into 3D labels similarly to
+        # how it's done for 3D vertices).
+        # self._update_labels()
+
+        # Now attempt to draw the arrows
+        for child in self.get_children():
+            child.draw(renderer)
+
+
+def edge_collection_2d_to_3d(
+    col: EdgeCollection,
+    zdir: str = "z",
+    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")
+
+    # NOTE: after this line, none of the EdgeCollection methods will work
+    # It's become a static drawer now. It uses segments instead of paths.
+    col.__class__ = Edge3DCollection
+    col._compute_edge_segments()
+
+    col._axlim_clip = axlim_clip
+
+    # Convert the arrow collection if present
+    if hasattr(col, "_arrows"):
+        segments3d = col._segments3d
+
+        # Fix the x and y to the center of the target vertex (for now)
+        col._arrows._offsets[:] = [segment[-1][:2] for segment in segments3d]
+        zs = [segment[-1][2] for segment in segments3d]
+        arrow_collection_2d_to_3d(
+            col._arrows,
+            zs=zs,
+            zdir=zdir,
+            depthshade=False,
+            axlim_clip=axlim_clip,
+        )

iplotx/art3d/edge/arrow.py

@@ -0,0 +1,115 @@
+"""
+Module containing code to manipulate arrow visualisations in 3D, especially the EdgeArrow3DCollection class.
+"""
+
+from typing import (
+    Sequence,
+)
+from math import atan2, cos, sin
+import numpy as np
+from matplotlib import (
+    cbook,
+)
+from mpl_toolkits.mplot3d import Axes3D
+from mpl_toolkits.mplot3d.art3d import (
+    Path3DCollection,
+)
+
+from ...utils.matplotlib import (
+    _forwarder,
+)
+from ...edge.arrow import (
+    EdgeArrowCollection,
+)
+
+
+@_forwarder(
+    (
+        "set_clip_path",
+        "set_clip_box",
+        "set_snap",
+        "set_sketch_params",
+        "set_animated",
+        "set_picker",
+    )
+)
+class EdgeArrow3DCollection(EdgeArrowCollection, Path3DCollection):
+    """Collection of vertex patches for plotting."""
+
+    def _update_before_draw(self) -> None:
+        """Update the collection before drawing."""
+        if (
+            isinstance(self.axes, Axes3D)
+            and hasattr(self, "do_3d_projection")
+            and (self.axes.M is not None)
+        ):
+            self.do_3d_projection()
+
+        # The original EdgeArrowCollection method for
+        # _update_before_draw cannot be used because it
+        # relies on paths, whereas edges are now a
+        # Line3DCollection which uses segments.
+        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
+
+        if (not hasattr(self, "_z_markers_idx")) or (
+            not isinstance(self._z_markers_idx, np.ndarray)
+        ):
+            return
+
+        trans = self.get_offset_transform().transform
+
+        # The do_3d_projection method above reorders the
+        # arrow offsets in some way, so we might have to figure out
+        # what edge index corres
+        for i, ie in enumerate(self._z_markers_idx):
+            segments_2d = self._edge_collection.get_segments()[ie]
+
+            # We could reset the 3d projection here, might be a way to
+            # skip the function call above.
+            v2 = trans(segments_2d[-1])
+            v1 = trans(segments_2d[-2])
+            dv = v2 - v1
+            theta = atan2(*(dv[::-1]))
+            theta_old = self._angles[i]
+            dtheta = theta - theta_old
+            mrot = np.array([[cos(dtheta), sin(dtheta)], [-sin(dtheta), cos(dtheta)]])
+
+            apath = self._paths[i]
+            apath.vertices = apath.vertices @ mrot
+            self._angles[i] = theta
+
+    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):
+                EdgeArrowCollection.draw(self, renderer)
+
+
+def arrow_collection_2d_to_3d(
+    col: EdgeArrowCollection,
+    zs: np.ndarray | float | Sequence[float] = 0,
+    zdir: str = "z",
+    depthshade: bool = True,
+    axlim_clip: bool = False,
+):
+    """Convert a 2D EdgeArrowCollection to a 3D EdgeArrow3DCollection.
+
+    Parameters:
+        col: The 2D EdgeArrowCollection 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, EdgeArrowCollection):
+        raise TypeError("vertices must be a EdgeArrowCollection")
+
+    col.__class__ = EdgeArrow3DCollection
+    col._offset_zordered = None
+    col._depthshade = depthshade
+    col._in_draw = False
+    col.set_3d_properties(zs, zdir, axlim_clip)

iplotx/{edge/geometry3d.py → art3d/edge/geometry.py}

@@ -7,19 +7,14 @@ from typing import (
     Sequence,
 )
 import numpy as np
-import matplotlib as mpl
 
-from ..typing import (
+from ...typing import (
     Pair,
 )
 
 
-def _compute_edge_path_straight(
+def _compute_edge_segments_straight(
     vcoord_data,
-    vpath_fig,
-    vsize_fig,
-    trans,
-    trans_inv,
     layout_coordinate_system: str = "cartesian",
     shrink: float = 0,
     **kwargs,
@@ -45,37 +40,11 @@ def _compute_edge_path_straight(
             f"Layout coordinate system not supported for straight edges in 3D: {layout_coordinate_system}.",
         )
 
-    vcoord_data_cart = vcoord_data
+    segments = [vcoord_data[0], vcoord_data[1]]
+    return segments
 
-    # 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(
+def _compute_edge_segments(
     *args,
     tension: float = 0,
     waypoints: str | tuple[float, float] | Sequence[tuple[float, float]] | np.ndarray = "none",
@@ -98,7 +67,7 @@ def _compute_edge_path_3d(
         # )
 
     if np.isscalar(tension) and (tension == 0):
-        return _compute_edge_path_straight(
+        return _compute_edge_segments_straight(
             *args,
             layout_coordinate_system=layout_coordinate_system,
             **kwargs,

iplotx/art3d/vertex.py

@@ -9,7 +9,11 @@ import numpy as np
 from matplotlib import (
     cbook,
 )
-from mpl_toolkits.mplot3d.art3d import Path3DCollection
+from mpl_toolkits.mplot3d import Axes3D
+from mpl_toolkits.mplot3d.art3d import (
+    Path3DCollection,
+    text_2d_to_3d,
+)
 
 from ..utils.matplotlib import (
     _forwarder,
@@ -32,6 +36,14 @@ from ..vertex import (
 class Vertex3DCollection(VertexCollection, Path3DCollection):
     """Collection of vertex patches for plotting."""
 
+    def _update_before_draw(self) -> None:
+        """Update the collection before drawing."""
+        # Set the sizes according to the current figure dpi
+        VertexCollection._update_before_draw(self)
+
+        if isinstance(self.axes, Axes3D) and hasattr(self, "do_3d_projection"):
+            self.do_3d_projection()
+
     def draw(self, renderer) -> None:
         """Draw the collection of vertices in 3D.
 
@@ -56,7 +68,7 @@ def vertex_collection_2d_to_3d(
         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).
+        depthshade: Whether to aply depth shading (default is True).
         axlim_clip: Whether to clip the vertices to the axes limits (default is False).
     """
     if not isinstance(col, VertexCollection):
@@ -67,3 +79,9 @@ def vertex_collection_2d_to_3d(
     col._depthshade = depthshade
     col._in_draw = False
     col.set_3d_properties(zs, zdir, axlim_clip)
+
+    # Labels if present
+    if col.get_labels() is not None:
+        for z, art in zip(zs, col.get_labels()._labelartists):
+            # zdir=None means the text is always horizontal facing the camera
+            text_2d_to_3d(art, z, zdir=None, axlim_clip=axlim_clip)

iplotx/edge/__init__.py

@@ -9,7 +9,7 @@ from typing import (
     Optional,
     Any,
 )
-from math import atan2, cos, pi, sin
+from math import pi
 from collections import defaultdict
 import numpy as np
 import pandas as pd
@@ -181,17 +181,23 @@ class EdgeCollection(mpl.collections.PatchCollection):
 
     def set_figure(self, fig) -> None:
         super().set_figure(fig)
-        self._update_paths()
+        self._update_before_draw()
         # NOTE: This sets the correct offsets in the arrows,
         # but not the correct sizes (see below)
-        self._update_children()
+        self._update_labels()
         for child in self.get_children():
             # NOTE: This sets the sizes with correct dpi scaling in the arrows
             child.set_figure(fig)
 
-    def _update_children(self):
-        self._update_arrows()
-        self._update_labels()
+    @property
+    def axes(self):
+        return mpl.artist.Artist.axes.__get__(self)
+
+    @axes.setter
+    def axes(self, new_axes):
+        mpl.artist.Artist.axes.__set__(self, new_axes)
+        for child in self.get_children():
+            child.axes = new_axes
 
     def set_transform(self, transform: mpl.transforms.Transform) -> None:
         """Set the transform for the edges and their children."""
@@ -303,7 +309,7 @@ class EdgeCollection(mpl.collections.PatchCollection):
             "sizes": vsizes,
         }
 
-    def _update_paths(self, transform=None):
+    def _update_before_draw(self, transform=None):
         """Compute paths for the edges.
 
         Loops split the largest wedge left open by other
@@ -512,42 +518,6 @@ class EdgeCollection(mpl.collections.PatchCollection):
         if not style.get("rotate", True):
             self._label_collection.set_rotations(rotations)
 
-    def _update_arrows(
-        self,
-    ) -> None:
-        """Extract the start and/or end angles of the paths to compute arrows.
-
-        Parameters:
-            which: Which end of the edge to put an arrow on. Currently only "end" is accepted.
-
-        NOTE: This function does *not* update the arrow sizes/_transforms to the correct dpi
-        scaling. That's ok since the correct dpi scaling is set whenever there is a different
-        figure (before first draw) and whenever a draw is called.
-        """
-        if not hasattr(self, "_arrows"):
-            return
-
-        transform = self.get_transform()
-        trans = transform.transform
-
-        for i, epath in enumerate(self.get_paths()):
-            # Offset the arrow to point to the end of the edge
-            self._arrows._offsets[i] = epath.vertices[-1]
-
-            # Rotate the arrow to point in the direction of the edge
-            apath = self._arrows._paths[i]
-            # NOTE: because the tip of the arrow is at (0, 0) in patch space,
-            # in theory it will rotate around that point already
-            v2 = trans(epath.vertices[-1])
-            v1 = trans(epath.vertices[-2])
-            dv = v2 - v1
-            theta = atan2(*(dv[::-1]))
-            theta_old = self._arrows._angles[i]
-            dtheta = theta - theta_old
-            mrot = np.array([[cos(dtheta), sin(dtheta)], [-sin(dtheta), cos(dtheta)]])
-            apath.vertices = apath.vertices @ mrot
-            self._arrows._angles[i] = theta
-
     @_stale_wrapper
     def draw(self, renderer):
         # Visibility affects the children too
@@ -555,11 +525,15 @@ class EdgeCollection(mpl.collections.PatchCollection):
             return
 
         # This includes the subedges if present
-        self._update_paths()
-        # This sets the arrow offsets
-        self._update_children()
+        self._update_before_draw()
 
+        # Now you can draw the edges
         super().draw(renderer)
+
+        # This sets the labels offsets
+        self._update_labels()
+
+        # Now you can draw arrows and labels
         for child in self.get_children():
             child.draw(renderer)
 

iplotx/edge/arrow.py

@@ -4,6 +4,7 @@ Module for edge arrows in iplotx.
 
 from typing import Never, Optional
 
+from math import atan2, cos, sin
 import numpy as np
 import matplotlib as mpl
 from matplotlib.patches import PathPatch
@@ -91,9 +92,7 @@ class EdgeArrowCollection(mpl.collections.PatchCollection):
     def set_figure(self, fig) -> None:
         """Set the figure for this artist and all children."""
         super().set_figure(fig)
-        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
-        for child in self.get_children():
-            child.set_figure(fig)
+        self._update_before_draw()
 
     def get_offset_transform(self):
         """Get offset transform for the edge arrows. This sets the tip of each arrow."""
@@ -126,6 +125,30 @@ class EdgeArrowCollection(mpl.collections.PatchCollection):
 
         return patches, sizes
 
+    def _update_before_draw(self) -> None:
+        """Update the arrow paths and directions before drawing, based on the edge collection."""
+        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
+
+        trans = self.get_offset_transform().transform
+
+        for i, epath in enumerate(self._edge_collection.get_paths()):
+            # Offset the arrow to point to the end of the edge
+            self._offsets[i] = epath.vertices[-1]
+
+            # Rotate the arrow to point in the direction of the edge
+            apath = self._paths[i]
+            # NOTE: because the tip of the arrow is at (0, 0) in patch space,
+            # in theory it will rotate around that point already
+            v2 = trans(epath.vertices[-1])
+            v1 = trans(epath.vertices[-2])
+            dv = v2 - v1
+            theta = atan2(*(dv[::-1]))
+            theta_old = self._angles[i]
+            dtheta = theta - theta_old
+            mrot = np.array([[cos(dtheta), sin(dtheta)], [-sin(dtheta), cos(dtheta)]])
+            apath.vertices = apath.vertices @ mrot
+            self._angles[i] = theta
+
     def set_array(self, A: np.ndarray) -> Never:
         """Set the array for cmap/norm coloring, but keep the facecolors as set (usually 'none')."""
         raise ValueError("Setting an array for arrows directly is not supported.")
@@ -145,7 +168,7 @@ class EdgeArrowCollection(mpl.collections.PatchCollection):
 
     @mpl.artist.allow_rasterization
     def draw(self, renderer):
-        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
+        self._update_before_draw()
         super().draw(renderer)
 
 

iplotx/edge/geometry.py

@@ -1,7 +1,7 @@
 """
 Support module with geometry- and path-related functions for edges.
 
-3D geometry is in its separate module :mod:`.geometry3d`.
+3D geometry is in a separate module.
 """
 
 from typing import (
@@ -16,7 +16,6 @@ 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):
@@ -71,10 +70,10 @@ 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).
+        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
@@ -479,7 +478,7 @@ def _compute_edge_path_curved(
     return path, tuple(thetas)
 
 
-def _compute_edge_path_2d(
+def _compute_edge_path(
     *args,
     tension: float = 0,
     waypoints: str | tuple[float, float] | Sequence[tuple[float, float]] | np.ndarray = "none",
@@ -513,25 +512,3 @@ def _compute_edge_path_2d(
         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/groups.py

@@ -65,7 +65,7 @@ class GroupingArtist(PatchCollection):
         self._points_per_curve = points_per_curve
 
         network = kwargs.pop("network", None)
-        self.layout = normalise_layout(layout, network=network)
+        self.layout = layout = normalise_layout(layout, network=network)
         self.ndim = layout.shape[1]
 
         patches, grouping, coords_hulls = self._create_patches(

iplotx/label.py

@@ -77,6 +77,16 @@ class LabelCollection(mpl.artist.Artist):
             child.set_figure(fig)
         self._update_offsets(dpi=fig.dpi)
 
+    @property
+    def axes(self):
+        return mpl.artist.Artist.axes.__get__(self)
+
+    @axes.setter
+    def axes(self, new_axes):
+        mpl.artist.Artist.axes.__set__(self, new_axes)
+        for child in self.get_children():
+            child.axes = new_axes
+
     def set_transform(self, transform: mpl.transforms.Transform) -> None:
         """Set the transform for this artist and children.
 

iplotx/network.py

@@ -384,10 +384,8 @@ class NetworkArtist(mpl.artist.Artist):
         # Handle zorder manually, just like in AxesBase in mpl
         children = list(self.get_children())
         children.sort(key=lambda x: x.zorder)
-        for art in children:
-            if (self.get_ndim() == 3) and (art.axes is not None):
-                art.do_3d_projection()
-            art.draw(renderer)
+        for child in children:
+            child.draw(renderer)
 
 
 def _update_from_internal(style, row, kind):

iplotx/version.py

@@ -2,4 +2,4 @@
 iplotx version information module.
 """
 
-__version__ = "0.10.0"
+__version__ = "0.11.1"

iplotx/vertex.py

@@ -315,6 +315,10 @@ class VertexCollection(PatchCollection):
             transform=transform,
         )
 
+    def get_ndim(self):
+        """Get the number of dimensions of the layout."""
+        return self._layout.shape[1]
+
     def get_labels(self):
         """Get the vertex labels.
 
@@ -361,6 +365,10 @@ class VertexCollection(PatchCollection):
         rotations = np.arctan2(doffsets_fig[:, 1], doffsets_fig[:, 0])
         self.get_labels().set_rotations(rotations)
 
+    def _update_before_draw(self) -> None:
+        """Update the collection before drawing."""
+        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
+
     @mpl.artist.allow_rasterization
     def draw(self, renderer):
         if not self.get_visible():
@@ -371,7 +379,8 @@ class VertexCollection(PatchCollection):
         if len(self.get_paths()) == 0:
             return
 
-        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
+        self._update_before_draw()
+        super().draw(renderer)
 
         # Set the label rotations already, hopefully this is not too early
         self._update_children()
@@ -379,7 +388,6 @@ class VertexCollection(PatchCollection):
         # NOTE: This draws the vertices first, then the labels.
         # The correct order would be vertex1->label1->vertex2->label2, etc.
         # We might fix if we manage to find a way to do it.
-        super().draw(renderer)
         for child in self.get_children():
             child.draw(renderer)
 

{iplotx-0.10.0.dist-info → iplotx-0.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 0.10.0
+Version: 0.11.1
 Summary: Plot networkx from igraph and networkx.
 Project-URL: Homepage, https://github.com/fabilab/iplotx
 Project-URL: Documentation, https://readthedocs.org/iplotx

{iplotx-0.10.0.dist-info → iplotx-0.11.1.dist-info}/RECORD

@@ -1,21 +1,22 @@
 iplotx/__init__.py,sha256=RzSct91jO8abrxOIn33rKEnDUgYpu1oj4olbObgX_hs,489
 iplotx/artists.py,sha256=XNtRwuvQdKkZCAejILydLD3J5B87sg5xPXuZFv_Gkk8,654
 iplotx/cascades.py,sha256=OPqF7Huls-HFmDA5MCF6DEZlUeRVaXsbQcHBoKAgNJs,8182
-iplotx/groups.py,sha256=X0G-EULkd7WBn1j82r-cBgpzZRd7gQ1cfqFoYNweLns,6775
-iplotx/label.py,sha256=76vSaH9zPv8drpzFaWNwuEIMQPEgKmilwfBnA8I_BJ4,9307
+iplotx/groups.py,sha256=g6ahm61BSBmd2weIjr40MvPi_GcNRgvNb9YklQsiza4,6784
+iplotx/label.py,sha256=7eS8ByadrhdIFOZz19U4VrS-oXY_ndFYNB-D4RZbFqI,9573
 iplotx/layout.py,sha256=KxmRLqjo8AYCBAmXez8rIiLU2sM34qhb6ox9AHYwRyE,4839
-iplotx/network.py,sha256=_yEArzsqnzm5MefVKKM96q_Od47ZIwjkJb2wuVFnfD8,13486
+iplotx/network.py,sha256=ae5rZwzWxmcBQXx1Y0q24jaXcM1hT1kip-JKsyk11QY,13385
 iplotx/plotting.py,sha256=icEefWJnS2lEGLp4t1LhDSP40JuvNKgOie3FDLOnTMk,13195
 iplotx/tree.py,sha256=TxbNoBHS0CfswrcMIWCNtnOl_3e4-PwCrVo0goywC0U,28807
 iplotx/typing.py,sha256=QLdzV358IiD1CFe88MVp0D77FSx5sSAVUmM_2WPPE8I,1463
-iplotx/version.py,sha256=YEqH52lnz6XyxsG7HXlFaHzcWyc3-VsDrQeE7vZtRQQ,67
-iplotx/vertex.py,sha256=rIg1gdxv7ZW8HjqmwJaynm098HqTmlC9XQgB81wjzgk,15775
-iplotx/art3d/edge.py,sha256=cZzI0nPTglU1xA_TsySrdE5GwxVx7smc32mxCE_EP48,1785
-iplotx/art3d/vertex.py,sha256=KhwR60ekPLL1CDYn9jeQFo5kfdCS5Naz7u1kM-_eq7U,1883
-iplotx/edge/__init__.py,sha256=P96eXHECrqHtVeIxdBA0SxJvTMeHlXPP_bqEOi5MsVQ,27589
-iplotx/edge/arrow.py,sha256=ZKt3UNZ7XRa2S3KxpoQfd4q_6eSUHOS476BZNqlf2pw,16462
-iplotx/edge/geometry.py,sha256=G0hze1SQGUiiLMdc8QVO7zr1C9UUIQt-IN17KBk6lkM,16317
-iplotx/edge/geometry3d.py,sha256=HnL1TvMXFegvco6oaiUqDXRKbx9GW3FsT4DUX_Ol94k,3207
+iplotx/version.py,sha256=BVfqBj50ae0jogJGXsQXi_fML0WjuC4GLFRHZQWawYY,67
+iplotx/vertex.py,sha256=bjvAy9UciPWkA1J-SroWF9ZaTXRzNKtDZXBlZ80VM60,16026
+iplotx/art3d/vertex.py,sha256=Xf8Um30X2doCd8KdNN7332F6BxC4k72Mb_GeRAuzQfQ,2545
+iplotx/art3d/edge/__init__.py,sha256=EzzW06YEeyIu52gXormkGIobae-etwKevZ_PDBr-S9c,4624
+iplotx/art3d/edge/arrow.py,sha256=14BFXY9kDOUGPZl2fMD9gRVGyaaN5kyd-l6ikBg6WHU,3601
+iplotx/art3d/edge/geometry.py,sha256=76VUmpPG-4Mls7x_994dMwdDPrWWnjT7nHJsHfwK_hA,2467
+iplotx/edge/__init__.py,sha256=wMKXD1h5SBaUv6HmebIc5wc9k8AuukaXzAOBu7epaqA,26341
+iplotx/edge/arrow.py,sha256=U7vvBo7IMwo1qiyU9cyUEwraOaBcJLgdu9oU2OyoHL4,17453
+iplotx/edge/geometry.py,sha256=jkTMvQC5425GjB_fmGLIPJeSDAr_7NZF8zZDLTrSj34,15541
 iplotx/edge/leaf.py,sha256=SyGMv2PIOoH0pey8-aMVaZheK3hNe1Qz_okcyWbc4E4,4268
 iplotx/edge/ports.py,sha256=BpkbiEhX4mPBBAhOv4jcKFG4Y8hxXz5GRtVLCC0jbtI,1235
 iplotx/ingest/__init__.py,sha256=S0YfnXcFKseB7ZBQc4yRt0cNDsLlhqdom0TmSY3OY2E,4756
@@ -36,6 +37,6 @@ iplotx/utils/geometry.py,sha256=6RrC6qaB0-1vIk1LhGA4CfsiMd-9JNniSPyL_l9mshE,9245
 iplotx/utils/internal.py,sha256=WWfcZDGK8Ut1y_tOHRGg9wSqY1bwSeLQO7dHM_8Tvwo,107
 iplotx/utils/matplotlib.py,sha256=wELE73quQv10-1w9uA5eDTgkZkylJvjg7pd3K5tZPOo,6294
 iplotx/utils/style.py,sha256=vyNP80nDYVinqm6_9ltCJCtjK35ZcGlHvOskNv3eQBc,4225
-iplotx-0.10.0.dist-info/METADATA,sha256=BY0tMOjP84ydubHd9ocmpn9LaqdmoqX3VcBEX_6tTWA,4880
-iplotx-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-iplotx-0.10.0.dist-info/RECORD,,
+iplotx-0.11.1.dist-info/METADATA,sha256=1F0wH64PAw1_Bx-Qv7RSTgz6nwoQfcbRDJjmlR3KYfc,4880
+iplotx-0.11.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+iplotx-0.11.1.dist-info/RECORD,,

iplotx/art3d/edge.py

@@ -1,65 +0,0 @@
-"""
-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