Edge labels

Author: iosonofabio

iplotx/edge/label.py

@@ -8,37 +8,26 @@
 )
 
 
-@_forwarder(
-    (
-        "set_clip_path",
-        "set_clip_box",
-        "set_transform",
-        "set_snap",
-        "set_sketch_params",
-        "set_figure",
-        "set_animated",
-        "set_picker",
-    )
-)
 class LabelCollection(mpl.artist.Artist):
-    def __init__(self, labels, offsets=None, style=None):
-        self._create_labels(labels, offsets, style)
+    def __init__(self, labels, style=None):
+        self._labels = labels
+        self._style = style
+        super().__init__()
 
-    def _create_labels(self, labels, offsets, style):
-        if offsets is None:
-            offsets = np.zeros((len(labels), 2))
-        if style is None:
-            style = {}
+    def _create_labels(self):
+        style = self._style if self._style is not None else {}
 
         arts = []
-        for label, offset in zip(labels, offsets):
+        for label in self._labels:
             art = mpl.text.Text(
-                offset[0],
-                offset[1],
+                0,
+                0,
                 label,
                 transform=self.axes.transData,
                 **style,
             )
+            art.set_figure(self.figure)
+            art.axes = self.axes
             arts.append(art)
         self._labels = arts
 
@@ -49,10 +38,6 @@ def set_offsets(self, offsets):
         for art, offset in zip(self._labels, offsets):
             art.set_position((offset[0], offset[1]))
 
-    @property
-    def stale(self):
-        return super().stale
-
     @_stale_wrapper
     def draw(self, renderer, *args, **kwds):
         """Draw each of the children, with some buffering mechanism."""
@@ -62,4 +47,4 @@ def draw(self, renderer, *args, **kwds):
         # We should manage zorder ourselves, but we need to compute
         # the new offsets and angles of arrows from the edges before drawing them
         for art in self.get_children():
-            art.draw(renderer, *args, **kwargs)
+            art.draw(renderer, *args, **kwds)

iplotx/edge/undirected.py

@@ -4,6 +4,11 @@
 import matplotlib as mpl
 
 from .common import _compute_loops_per_angle
+from .label import LabelCollection
+from ..tools.matplotlib import (
+    _compute_mid_coord,
+    _stale_wrapper,
+)
 
 
 class UndirectedEdgeCollection(mpl.collections.PatchCollection):
@@ -325,28 +330,50 @@ def _shorten_path_undirected_curved(
         return path
 
     def _compute_labels(self):
+        style = self._style.get("label", None) if self._style is not None else None
         offsets = []
         for path in self._paths:
             offset = _compute_mid_coord(path)
             offsets.append(offset)
 
         if not hasattr(self, "_label_collection"):
-            self._label_collection = LabelCollection(self._labels, offsets=offsets)
-        else:
-            self._label_collection.set_offsets(offsets)
+            self._label_collection = LabelCollection(
+                self._labels,
+                style=style,
+            )
+
+            # Forward a bunch of mpl settings that are needed
+            self._label_collection.set_figure(self.figure)
+            self._label_collection.axes = self.axes
+            # forward the clippath/box to the children need this logic
+            # because mpl exposes some fast-path logic
+            clip_path = self.get_clip_path()
+            if clip_path is None:
+                clip_box = self.get_clip_box()
+                self._label_collection.set_clip_box(clip_box)
+            else:
+                self._label_collection.set_clip_path(clip_path)
+
+            # Finally make the patches
+            self._label_collection._create_labels()
+        self._label_collection.set_offsets(offsets)
 
     def get_children(self):
         children = []
         if hasattr(self, "_label_collection"):
             children.append(self._label_collection)
         return children
 
-    def draw(self, renderer):
+    @_stale_wrapper
+    def draw(self, renderer, *args, **kwds):
         if self._vertex_paths is not None:
             self._paths = self._compute_paths()
             if self._labels is not None:
                 self._compute_labels()
-        return super().draw(renderer)
+        super().draw(renderer)
+
+        for child in self.get_children():
+            child.draw(renderer, *args, **kwds)
 
     @property
     def stale(self):

iplotx/matplotlib.py

@@ -0,0 +1,84 @@
+from functools import wraps, partial
+import matplotlib as mpl
+
+
+# NOTE: https://github.com/networkx/grave/blob/main/grave/grave.py
+def _stale_wrapper(func):
+    """Decorator to manage artist state."""
+
+    @wraps(func)
+    def inner(self, *args, **kwargs):
+        try:
+            func(self, *args, **kwargs)
+        finally:
+            self.stale = False
+
+    return inner
+
+
+def _forwarder(forwards, cls=None):
+    """Decorator to forward specific methods to Artist children."""
+    if cls is None:
+        return partial(_forwarder, forwards)
+
+    def make_forward(name):
+        def method(self, *args, **kwargs):
+            ret = getattr(cls.mro()[1], name)(self, *args, **kwargs)
+            for c in self.get_children():
+                getattr(c, name)(*args, **kwargs)
+            return ret
+
+        return method
+
+    for f in forwards:
+        method = make_forward(f)
+        method.__name__ = f
+        method.__doc__ = "broadcasts {} to children".format(f)
+        setattr(cls, f, method)
+
+    return cls
+
+
+def _additional_set_methods(attributes, cls=None):
+    """Decorator to add specific set methods for children properties."""
+    if cls is None:
+        return partial(_additional_set_methods, attributes)
+
+    def make_setter(name):
+        def method(self, value):
+            self.set(**{name: value})
+
+        return method
+
+    for attr in attributes:
+        desc = attr.replace("_", " ")
+        method = make_setter(attr)
+        method.__name__ = f"set_{attr}"
+        method.__doc__ = f"Set {desc}."
+        setattr(cls, f"set_{attr}", method)
+
+    return cls
+
+
+# FIXME: this method appears quite inconsistent, would be better to improve.
+# The issue is that to really know the size of a label on screen, we need to
+# render it first. Therefore, we should render the labels, then render the
+# vertices. Leaving for now, since this can be styled manually which covers
+# many use cases.
+def _get_label_width_height(text, hpadding=18, vpadding=12, **kwargs):
+    """Get the bounding box size for a text with certain properties."""
+    forbidden_props = ["horizontalalignment", "verticalalignment", "ha", "va"]
+    for prop in forbidden_props:
+        if prop in kwargs:
+            del kwargs[prop]
+
+    path = mpl.textpath.TextPath((0, 0), text, **kwargs)
+    boundingbox = path.get_extents()
+    width = boundingbox.width + hpadding
+    height = boundingbox.height + vpadding
+    return (width, height)
+
+
+def _compute_mid_coord(path):
+            if (path.codes[-1] in (mpl.path.CURVE4, mpl.CURVE3)):
+

iplotx/network.py

@@ -1,4 +1,4 @@
-from typing import Union
+from typing import Union, Sequence
 import numpy as np
 import pandas as pd
 import matplotlib as mpl
@@ -55,6 +55,7 @@ def __init__(
         network: GraphType,
         layout: LayoutType = None,
         vertex_labels: Union[None, list, dict, pd.Series] = None,
+        edge_labels: Union[None, Sequence] = None,
     ):
         """Network container artist that groups all plotting elements.
 
@@ -66,12 +67,16 @@ def __init__(
             vertex_labels (list, dict, or pandas.Series): The labels for the vertices. If None, no vertex labels
                 will be drawn. If a list, the labels are taken from the list. If a dict, the keys
                 should be the vertex IDs and the values should be the labels.
+            elge_labels (sequence): The labels for the edges. If None, no edge labels will be drawn.
         """
         super().__init__()
 
         self.network = network
         self._ipx_internal_data = _create_internal_data(
-            network, layout, vertex_labels=vertex_labels
+            network,
+            layout,
+            vertex_labels=vertex_labels,
+            edge_labels=edge_labels,
         )
         self._clear_state()
 
@@ -410,7 +415,12 @@ def draw(self, renderer, *args, **kwds):
 
 
 # INTERNAL ROUTINES
-def _create_internal_data(network, layout=None, vertex_labels=None):
+def _create_internal_data(
+    network,
+    layout=None,
+    vertex_labels=None,
+    edge_labels=None,
+):
     """Create internal data for the network."""
     nl = network_library(network)
     directed = detect_directedness(network)
@@ -427,6 +437,10 @@ def _create_internal_data(network, layout=None, vertex_labels=None):
 
         # Vertex labels
         if vertex_labels is not None:
+            if len(vertex_labels) != len(vertex_df):
+                raise ValueError(
+                    "Vertex labels must be the same length as the number of vertices."
+                )
             vertex_df["label"] = vertex_labels
 
         # Edges are a list of tuples, because of multiedges
@@ -438,6 +452,14 @@ def _create_internal_data(network, layout=None, vertex_labels=None):
         edge_df = pd.DataFrame(tmp)
         del tmp
 
+        # Edge labels
+        if edge_labels is not None:
+            if len(edge_labels) != len(edge_df):
+                raise ValueError(
+                    "Edge labels must be the same length as the number of edges."
+                )
+            edge_df["labels"] = edge_labels
+
     else:
         # Vertices are ordered integers, no gaps
         layout = normalise_layout(layout)
@@ -450,6 +472,10 @@ def _create_internal_data(network, layout=None, vertex_labels=None):
 
         # Vertex labels
         if vertex_labels is not None:
+            if len(vertex_labels) != len(vertex_df):
+                raise ValueError(
+                    "Vertex labels must be the same length as the number of vertices."
+                )
             vertex_df["label"] = vertex_labels
 
         # Edges are a list of tuples, because of multiedges
@@ -461,6 +487,14 @@ def _create_internal_data(network, layout=None, vertex_labels=None):
         edge_df = pd.DataFrame(tmp)
         del tmp
 
+        # Edge labels
+        if edge_labels is not None:
+            if len(edge_labels) != len(edge_df):
+                raise ValueError(
+                    "Edge labels must be the same length as the number of edges."
+                )
+            edge_df["labels"] = edge_labels
+
     internal_data = {
         "vertex_df": vertex_df,
         "edge_df": edge_df,

iplotx/plotting.py

@@ -1,4 +1,4 @@
-from typing import Union
+from typing import Union, Sequence
 import pandas as pd
 import matplotlib.pyplot as plt
 
@@ -13,6 +13,7 @@ def plot(
     network: GraphType,
     layout: Union[LayoutType, None] = None,
     vertex_labels: Union[None, list, dict, pd.Series] = None,
+    edge_labels: Union[None, Sequence] = None,
     ax: Union[None, object] = None,
 ):
     """Plot this network using the specified layout.
@@ -31,7 +32,12 @@ def plot(
     if ax is None:
         fig, ax = plt.subplots()
 
-    nwkart = NetworkArtist(network, layout, vertex_labels=vertex_labels)
+    nwkart = NetworkArtist(
+        network,
+        layout,
+        vertex_labels=vertex_labels,
+        edge_labels=edge_labels,
+    )
 
     ax.add_artist(nwkart)
 

iplotx/styles.py

@@ -19,6 +19,10 @@
         "color": "black",
         "curved": True,
         "tension": +1.5,
+        "label": {
+            "horizontalalignment": "center",
+            "verticalalignment": "center",
+        },
     },
     "arrow": {
         "marker": "|>",
@@ -83,6 +87,7 @@ def use(style: Union[str, dict, Sequence]):
             "default" resets the style to the default one. If this is a sequence,
             each style is applied in order.
     """
+    global current
 
     def _update(style: dict, current: dict):
         for key, value in style.items():
@@ -107,8 +112,9 @@ def _update(style: dict, current: dict):
             reset()
         else:
             if isinstance(style, str):
-                style = get_style(style)
-            _update(style, current)
+                current = get_style(style)
+            else:
+                _update(style, current)
 
 
 def reset():

iplotx/tools/geometry.py

@@ -0,0 +1,17 @@
+# See also this link for the general answer (using scipy to compute coefficients):
+# https://stackoverflow.com/questions/12643079/b%C3%A9zier-curve-fitting-with-scipy
+def _evaluate_squared_bezier(points, t):
+    """Evaluate a squared Bezier curve at t."""
+    p0, p1, p2 = points
+    return (1 - t) ** 2 * p0 + 2 * (1 - t) * t * p1 + t**2 * p2
+
+
+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
+    )