iplotx 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

iplotx/edge/arrow.py

@@ -1,16 +1,171 @@
+from typing import (
+    Never,
+)
 import numpy as np
 import matplotlib as mpl
 from matplotlib.patches import PathPatch
 
+from ..style import (
+    get_style,
+    rotate_style,
+)
+
+
+class EdgeArrowCollection(mpl.collections.PatchCollection):
+    """Collection of arrow patches for plotting directed edgs."""
+
+    _factor = 1.0
+
+    def __init__(
+        self,
+        edge_collection,
+        transform: mpl.transforms.Transform = mpl.transforms.IdentityTransform(),
+        *args,
+        **kwargs,
+    ):
+
+        self._edge_collection = edge_collection
+        self._style = get_style(".edge.arrow")
+
+        patches, sizes = self._create_artists()
+
+        if "cmap" in self._edge_collection._style:
+            kwargs["cmap"] = self._edge_collection._style["cmap"]
+            kwargs["norm"] = self._edge_collection._style["norm"]
+
+        super().__init__(
+            patches,
+            offsets=np.zeros((len(patches), 2)),
+            offset_transform=self.get_offset_transform(),
+            transform=transform,
+            match_original=True,
+            *args,
+            **kwargs,
+        )
+        self._angles = np.zeros(len(self._paths))
+
+        # Compute _transforms like in _CollectionWithScales for dpi issues
+        self.set_sizes(sizes)
+
+    def get_sizes(self):
+        """Get vertex sizes (max of width and height), not scaled by dpi."""
+        return self._sizes
+
+    def get_sizes_dpi(self):
+        return self._transforms[:, 0, 0]
+
+    def set_sizes(self, sizes, dpi=72.0):
+        """Set vertex sizes.
+
+        This rescales the current vertex symbol/path linearly, using this
+        value as the largest of width and height.
+
+        @param sizes: A sequence of vertex sizes or a single size.
+        """
+        if sizes is None:
+            self._sizes = np.array([])
+            self._transforms = np.empty((0, 3, 3))
+        else:
+            self._sizes = np.asarray(sizes)
+            self._transforms = np.zeros((len(self._sizes), 3, 3))
+            scale = self._sizes * dpi / 72.0 * self._factor
+            self._transforms[:, 0, 0] = scale
+            self._transforms[:, 1, 1] = scale
+            self._transforms[:, 2, 2] = 1.0
+        self.stale = True
+
+    get_size = get_sizes
+    set_size = set_sizes
+
+    def set_figure(self, fig) -> Never:
+        """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)
+
+    def get_offset_transform(self):
+        return self._edge_collection.get_transform()
+
+    get_size = get_sizes
+    set_size = set_sizes
+
+    def _create_artists(self):
+        style = self._style if self._style is not None else {}
+
+        patches = []
+        sizes = []
+        for i, (vid1, vid2) in enumerate(self._edge_collection._vertex_ids):
+            stylei = rotate_style(style, index=i)
+            if ("facecolor" not in stylei) and ("color" not in stylei):
+                stylei["facecolor"] = self._edge_collection.get_edgecolors()[i][:3]
+            if ("edgecolor" not in stylei) and ("color" not in stylei):
+                stylei["edgecolor"] = self._edge_collection.get_edgecolors()[i][:3]
+            if "alpha" not in stylei:
+                stylei["alpha"] = self._edge_collection.get_edgecolors()[i][3]
+            if "linewidth" not in stylei:
+                stylei["linewidth"] = self._edge_collection.get_linewidths()[i]
+
+            patch, size = make_arrow_patch(
+                **stylei,
+            )
+            patches.append(patch)
+            sizes.append(size)
+
+        return patches, sizes
+
+    def set_array(self, array):
+        """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.")
+
+    def set_colors(self, colors):
+        """Set arrow colors (edge and/or face) based on a colormap."""
+        # NOTE: facecolors is always an array because we come from patches
+        # It can have zero alpha (i.e. if we choose "none", or a hollow marker)
+        self.set_edgecolors(colors)
+        has_facecolor = self._facecolors[:, 3] > 0
+        self._facecolors[has_facecolor] = colors[has_facecolor]
+
+    @property
+    def stale(self):
+        return super().stale
+
+    @stale.setter
+    def stale(self, val):
+        mpl.collections.PatchCollection.stale.fset(self, val)
+        if val and hasattr(self, "stale_callback_post"):
+            self.stale_callback_post(self)
+
+    @mpl.artist.allow_rasterization
+    def draw(self, renderer):
+        self.set_sizes(self._sizes, self.get_figure(root=True).dpi)
+        super().draw(renderer)
+
 
 def make_arrow_patch(marker: str = "|>", width: float = 8, **kwargs):
     """Make a patch of the given marker shape and size."""
     height = kwargs.pop("height", width * 1.3)
 
+    # Normalise by the max size, this is taken care of in _transforms
+    # subsequently in a way that is nice to dpi scaling
+    size_max = max(width, height)
+    if size_max > 0:
+        height /= size_max
+        width /= size_max
+
     if marker == "|>":
-        codes = ["MOVETO", "LINETO", "LINETO"]
+        codes = ["MOVETO", "LINETO", "LINETO", "CLOSEPOLY"]
+        if "color" in kwargs:
+            kwargs["facecolor"] = kwargs["edgecolor"] = kwargs.pop("color")
         path = mpl.path.Path(
-            np.array([[-height, width * 0.5], [-height, -width * 0.5], [0, 0]]),
+            np.array(
+                [
+                    [-height, width * 0.5],
+                    [-height, -width * 0.5],
+                    [0, 0],
+                    [-height, width * 0.5],
+                ]
+            ),
             codes=[getattr(mpl.path.Path, x) for x in codes],
             closed=True,
         )
@@ -25,8 +180,10 @@ def make_arrow_patch(marker: str = "|>", width: float = 8, **kwargs):
             closed=False,
         )
     elif marker == ">>":
+        if "color" in kwargs:
+            kwargs["facecolor"] = kwargs["edgecolor"] = kwargs.pop("color")
         overhang = kwargs.pop("overhang", 0.25)
-        codes = ["MOVETO", "LINETO", "LINETO", "LINETO"]
+        codes = ["MOVETO", "LINETO", "LINETO", "LINETO", "CLOSEPOLY"]
         path = mpl.path.Path(
             np.array(
                 [
@@ -34,14 +191,17 @@ def make_arrow_patch(marker: str = "|>", width: float = 8, **kwargs):
                     [-height, -width * 0.5],
                     [-height * (1.0 - overhang), 0],
                     [-height, width * 0.5],
+                    [0, 0],
                 ]
             ),
             codes=[getattr(mpl.path.Path, x) for x in codes],
             closed=True,
         )
     elif marker == ")>":
+        if "color" in kwargs:
+            kwargs["facecolor"] = kwargs["edgecolor"] = kwargs.pop("color")
         overhang = kwargs.pop("overhang", 0.25)
-        codes = ["MOVETO", "LINETO", "CURVE3", "CURVE3"]
+        codes = ["MOVETO", "LINETO", "CURVE3", "CURVE3", "CLOSEPOLY"]
         path = mpl.path.Path(
             np.array(
                 [
@@ -49,6 +209,7 @@ def make_arrow_patch(marker: str = "|>", width: float = 8, **kwargs):
                     [-height, -width * 0.5],
                     [-height * (1.0 - overhang), 0],
                     [-height, width * 0.5],
+                    [0, 0],
                 ]
             ),
             codes=[getattr(mpl.path.Path, x) for x in codes],
@@ -70,8 +231,37 @@ def make_arrow_patch(marker: str = "|>", width: float = 8, **kwargs):
             codes=[getattr(mpl.path.Path, x) for x in codes],
             closed=False,
         )
+    elif marker == "|":
+        kwargs["facecolor"] = "none"
+        if "color" in kwargs:
+            kwargs["edgecolor"] = kwargs.pop("color")
+        codes = ["MOVETO", "LINETO"]
+        path = mpl.path.Path(
+            np.array([[-height, width * 0.5], [-height, -width * 0.5]]),
+            codes=[getattr(mpl.path.Path, x) for x in codes],
+            closed=False,
+        )
+    elif marker == "s":
+        if "color" in kwargs:
+            kwargs["facecolor"] = kwargs["edgecolor"] = kwargs.pop("color")
+        codes = ["MOVETO", "LINETO", "LINETO", "LINETO", "CLOSEPOLY"]
+        path = mpl.path.Path(
+            np.array(
+                [
+                    [-height, width * 0.5],
+                    [-height, -width * 0.5],
+                    [0, -width * 0.5],
+                    [0, width * 0.5],
+                    [-height, width * 0.5],
+                ]
+            ),
+            codes=[getattr(mpl.path.Path, x) for x in codes],
+            closed=True,
+        )
     elif marker == "d":
-        codes = ["MOVETO", "LINETO", "LINETO", "LINETO"]
+        if "color" in kwargs:
+            kwargs["facecolor"] = kwargs["edgecolor"] = kwargs.pop("color")
+        codes = ["MOVETO", "LINETO", "LINETO", "LINETO", "CLOSEPOLY"]
         path = mpl.path.Path(
             np.array(
                 [
@@ -79,13 +269,16 @@ def make_arrow_patch(marker: str = "|>", width: float = 8, **kwargs):
                     [-height, 0],
                     [-height * 0.5, -width * 0.5],
                     [0, 0],
+                    [-height * 0.5, width * 0.5],
                 ]
             ),
             codes=[getattr(mpl.path.Path, x) for x in codes],
             closed=True,
         )
     elif marker == "p":
-        codes = ["MOVETO", "LINETO", "LINETO", "LINETO"]
+        if "color" in kwargs:
+            kwargs["facecolor"] = kwargs["edgecolor"] = kwargs.pop("color")
+        codes = ["MOVETO", "LINETO", "LINETO", "LINETO", "CLOSEPOLY"]
         path = mpl.path.Path(
             np.array(
                 [
@@ -93,13 +286,16 @@ def make_arrow_patch(marker: str = "|>", width: float = 8, **kwargs):
                     [0, 0],
                     [0, -width],
                     [-height, -width],
+                    [-height, 0],
                 ]
             ),
             codes=[getattr(mpl.path.Path, x) for x in codes],
             closed=True,
         )
     elif marker == "q":
-        codes = ["MOVETO", "LINETO", "LINETO", "LINETO"]
+        if "color" in kwargs:
+            kwargs["facecolor"] = kwargs["edgecolor"] = kwargs.pop("color")
+        codes = ["MOVETO", "LINETO", "LINETO", "LINETO", "CLOSEPOLY"]
         path = mpl.path.Path(
             np.array(
                 [
@@ -107,16 +303,30 @@ def make_arrow_patch(marker: str = "|>", width: float = 8, **kwargs):
                     [0, 0],
                     [0, width],
                     [-height, width],
+                    [-height, 0],
+                ]
+            ),
+            codes=[getattr(mpl.path.Path, x) for x in codes],
+            closed=True,
+        )
+    elif marker == "none":
+        if "color" in kwargs:
+            kwargs["facecolor"] = kwargs["edgecolor"] = kwargs.pop("color")
+        codes = ["MOVETO"]
+        path = mpl.path.Path(
+            np.array(
+                [
+                    [0, 0],
                 ]
             ),
             codes=[getattr(mpl.path.Path, x) for x in codes],
             closed=True,
         )
+    else:
+        raise ValueError(f"Arrow marker not found: {marker}.")
 
     patch = PathPatch(
         path,
         **kwargs,
     )
-    return patch
-
-    raise KeyError(f"Unknown marker: {marker}")
+    return patch, size_max

iplotx/edge/ports.py

@@ -0,0 +1,42 @@
+import numpy as np
+
+sq2 = np.sqrt(2) / 2
+
+port_dict = {
+    "s": (0, -1),
+    "w": (-1, 0),
+    "n": (0, 1),
+    "e": (1, 0),
+    "sw": (-sq2, -sq2),
+    "nw": (-sq2, sq2),
+    "ne": (sq2, sq2),
+    "se": (sq2, -sq2),
+}
+
+
+def _get_port_unit_vector(
+    portstring,
+    trans_inv,
+):
+    """Get the tangent unit vector from a port string."""
+    # The only tricky bit is if the port says e.g. north but the y axis is inverted, in which case the port should go south.
+    # We can figure it out by checking the sign of the monotonic trans_inv from figure to data coordinates.
+    v12 = trans_inv(
+        np.array(
+            [
+                [0, 0],
+                [1, 1],
+            ]
+        )
+    )
+    invertx = v12[1, 0] - v12[0, 0] < 0
+    inverty = v12[1, 1] - v12[0, 1] < 0
+
+    if invertx:
+        portstring = portstring.replace("w", "x").replace("e", "w").replace("x", "e")
+    if inverty:
+        portstring = portstring.replace("n", "x").replace("s", "n").replace("x", "s")
+
+    if portstring not in port_dict:
+        raise KeyError(f"Port not found: {portstring}")
+    return np.array(port_dict[portstring])

iplotx/groups.py

@@ -1,19 +1,22 @@
-from typing import Union, Sequence
-from copy import deepcopy
-from collections import defaultdict
+"""
+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
 
 
-from .importing import igraph
 from .typing import (
     GroupingType,
     LayoutType,
 )
-from .heuristics import normalise_layout, normalise_grouping
-from .styles import get_style, rotate_style
+from .ingest.heuristics import (
+    normalise_layout,
+    normalise_grouping,
+)
+from .style import get_style, rotate_style
 from .utils.geometry import (
     convex_hull,
     _compute_group_path_with_vertex_padding,
@@ -21,11 +24,20 @@ from .utils.geometry import (
 
 
 class GroupingArtist(PatchCollection):
+    """Matplotlib artist for a vertex grouping (clustering/cover).
+
+    This class is used to plot patches surrounding groups of vertices in a network.
+    """
+
+    _factor = 1.0
+
     def __init__(
         self,
         grouping: GroupingType,
         layout: LayoutType,
         vertexpadding: Union[None, int] = None,
+        points_per_curve: int = 30,
+        transform: mpl.transforms.Transform = mpl.transforms.IdentityTransform(),
         *args,
         **kwargs,
     ):
@@ -38,21 +50,52 @@ class GroupingArtist(PatchCollection):
             layout: The layout of the vertices. If this object has no keys/index, the
                 vertices are assumed to have IDs corresponding to integers starting from
                 zero.
+            vertexpadding: How may points of padding to leave around each vertex centre.
+            points_per_curve: How many points to use to approximate a round envelope around
+                each convex hull vertex.
+            transform: The matplotlib transform to use for the patches (typically transData).
         """
         if vertexpadding is not None:
             self._vertexpadding = vertexpadding
         else:
             style = get_style(".grouping")
             self._vertexpadding = style.get("vertexpadding", 10)
-        patches, grouping, layout = self._create_patches(grouping, layout, **kwargs)
+
+        self._points_per_curve = points_per_curve
+
+        network = kwargs.pop("network", None)
+        patches, grouping, coords_hulls = self._create_patches(
+            grouping, layout, network, **kwargs
+        )
+        if "network" in kwargs:
+            del kwargs["network"]
         self._grouping = grouping
-        self._layout = layout
+        self._coords_hulls = coords_hulls
         kwargs["match_original"] = True
 
         super().__init__(patches, *args, **kwargs)
 
-    def _create_patches(self, grouping, layout, **kwargs):
-        layout = normalise_layout(layout)
+        zorder = get_style(".grouping").get("zorder", 1)
+        self.set_zorder(zorder)
+
+        self.set_transform(transform)
+
+    def set_figure(self, figure):
+        """Set the figure for the grouping, recomputing the paths depending on the figure's dpi."""
+        ret = super().set_figure(figure)
+        self._compute_paths(self.get_figure(root=True).dpi)
+        return ret
+
+    def get_vertexpadding(self):
+        """Get the vertex padding of each group."""
+        return self._vertexpadding
+
+    def get_vertexpadding_dpi(self, dpi=72.0):
+        """Get vertex padding of each group, scaled by dpi of the figure."""
+        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)
@@ -60,6 +103,7 @@ class GroupingArtist(PatchCollection):
         style.update(kwargs)
 
         patches = []
+        coords_hulls = []
         for i, (name, vids) in enumerate(grouping.items()):
             if len(vids) == 0:
                 continue
@@ -67,6 +111,7 @@ class GroupingArtist(PatchCollection):
             coords = layout.loc[vids].values
             idx_hull = convex_hull(coords)
             coords_hull = coords[idx_hull]
+            coords_hulls.append(coords_hull)
 
             stylei = rotate_style(style, i)
 
@@ -79,23 +124,30 @@ class GroupingArtist(PatchCollection):
             )
 
             patches.append(patch)
-        return patches, grouping, layout
-
-    def _compute_paths(self):
-        if self._vertexpadding > 0:
-            for i, path in enumerate(self._paths):
-                self._paths[i].vertices = _compute_group_path_with_vertex_padding(
-                    path.vertices,
-                    self.get_transform(),
-                    vertexpadding=self._vertexpadding,
-                )
+        return patches, grouping, coords_hulls
+
+    def _compute_paths(self, dpi=72.0):
+        ppc = self._points_per_curve
+        for i, hull in enumerate(self._coords_hulls):
+            self._paths[i].vertices = _compute_group_path_with_vertex_padding(
+                hull,
+                self._paths[i].vertices,
+                self.get_transform(),
+                vertexpadding=self.get_vertexpadding_dpi(dpi),
+                points_per_curve=ppc,
+            )
 
     def _process(self):
-        self.set_transform(self.axes.transData)
         self._compute_paths()
 
     def draw(self, renderer):
-        self._compute_paths()
+        # FIXME: this kind of breaks everything since the vertices' magical "_transforms" does not really
+        # scale from 72 pixels but rather from the screen's or something. Conclusion: using this keeps
+        # consistency across dpis but breaks proportionality of vertexpadding and vertex_size (for now).
+        # NOTE: this might be less bad than initially thought in the sense that even perfect scaling
+        # does not seem to align the center of the perimeter of the group with the center of the perimeter
+        # of the vertex when of the same exact size. So we are probably ok winging it as users will adapt.
+        self._compute_paths(self.get_figure(root=True).dpi)
         super().draw(renderer)
 
 
@@ -111,24 +163,10 @@ def _compute_group_patch_stub(
         )
 
     # NOTE: Closing point: mpl is a bit quirky here
-    vertices = []
-    codes = []
-    if len(points) == 0:
-        vertices = np.zeros((0, 2))
-    elif len(points) == 1:
-        vertices = [points[0]] * 9
-        codes = ["MOVETO"] + ["CURVE3"] * 8
-    elif len(points) == 2:
-        vertices = [points[0]] * 5 + [points[1]] * 5 + [points[0]]
-        codes = ["MOVETO"] + ["CURVE3"] * 4 + ["LINETO"] + ["CURVE3"] * 4 + ["LINETO"]
-    else:
-        for point in points:
-            vertices.extend([point] * 3)
-            codes.extend(["LINETO", "CURVE3", "CURVE3"])
-        vertices.append(vertices[0])
-        codes.append("LINETO")
-        codes[0] = "MOVETO"
-
+    vertices = np.zeros(
+        (1 + 30 * len(points), 2),
+    )
+    codes = ["MOVETO"] + ["LINETO"] * (len(vertices) - 2) + ["CLOSEPOLY"]
     codes = [getattr(mpl.path.Path, x) for x in codes]
     patch = mpl.patches.PathPatch(
         mpl.path.Path(