iplotx 0.5.1__tar.gz → 0.6.1__tar.gz

{iplotx-0.5.1 → iplotx-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iplotx
-Version: 0.5.1
+Version: 0.6.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.5.1 → iplotx-0.6.1}/docs/source/api/complete_style_specification.md

@@ -69,6 +69,13 @@
         # unless the "norm" option is used.
         "color": str | float | Any,
 
+        # How to cap the edge line. Should be "butt" (default), "round", or "projecting".
+        "capstyle": str,
+
+        # Whether to leave any space between edge cap and vertex border. This is
+        # in figure points and autoscales correctly with dpi.
+        "padding": float,
+
         # Matplotlib color map used to map floating numbers into RGBA colors. Only
         # used when the previous option "color" is set to floats.
         "cmap": str | matplotlib.colors.Colormap,
@@ -138,10 +145,15 @@
             # |/
             # |\\ (double slash needed to avoid character escaping)
             # >
+            # <
             # >>
             # )>
             # )
+            # (
+            # ]
+            # [
             # |
+            # x (or X)
             # s
             # d
             # p
@@ -180,6 +192,17 @@
             "bbox": dict,  # Bounding box properties for the label (see vertex labels)
 
         },
+
+        ############################################################################
+        # The following edge properties are only valid for trees via `iplotx.tree`
+        "split": {
+            # NOTE: This takes any properties of "edge" except for itself (i.e. no
+            # "nested" split) and applies it to the last segment of split edges.
+            "color": str | Any,  # Color of the split edge
+
+            # ...
+        },
+
     },
 
     # The following entry is used by networks ONLY (not trees as plotted by `iplotx.tree`)

{iplotx-0.5.1 → iplotx-0.6.1}/docs/source/sg_execution_times.rst

@@ -6,7 +6,7 @@
 
 Computation times
 =================
-**00:01.263** total execution time for 51 files **from all galleries**:
+**00:00.045** total execution time for 59 files **from all galleries**:
 
 .. container::
 
@@ -32,12 +32,15 @@ Computation times
    * - Example
      - Time
      - Mem (MB)
-   * - :ref:`sphx_glr_gallery_tree_plot_split_edges.py` (``../../gallery/tree/plot_split_edges.py``)
-     - 00:01.263
+   * - :ref:`sphx_glr_gallery_plot_feedbacks.py` (``../../gallery/plot_feedbacks.py``)
+     - 00:00.045
      - 0.0
    * - :ref:`sphx_glr_gallery_plot_animation.py` (``../../gallery/plot_animation.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_plot_arrowlawn.py` (``../../gallery/plot_arrowlawn.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_plot_arrows.py` (``../../gallery/plot_arrows.py``)
      - 00:00.000
      - 0.0
@@ -68,9 +71,15 @@ Computation times
    * - :ref:`sphx_glr_gallery_plot_directed.py` (``../../gallery/plot_directed.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_plot_edgepadding.py` (``../../gallery/plot_edgepadding.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_plot_edit_artists.py` (``../../gallery/plot_edit_artists.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_plot_elements.py` (``../../gallery/plot_elements.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_plot_four_grids.py` (``../../gallery/plot_four_grids.py``)
      - 00:00.000
      - 0.0
@@ -113,6 +122,9 @@ Computation times
    * - :ref:`sphx_glr_gallery_plot_ports.py` (``../../gallery/plot_ports.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_plot_redblack.py` (``../../gallery/plot_redblack.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_plot_shortest_path.py` (``../../gallery/plot_shortest_path.py``)
      - 00:00.000
      - 0.0
@@ -140,6 +152,9 @@ Computation times
    * - :ref:`sphx_glr_gallery_plot_voronoi.py` (``../../gallery/plot_voronoi.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_plot_waypoints.py` (``../../gallery/plot_waypoints.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_plot_with_colorbar.py` (``../../gallery/plot_with_colorbar.py``)
      - 00:00.000
      - 0.0
@@ -158,6 +173,9 @@ Computation times
    * - :ref:`sphx_glr_gallery_tree_plot_cogent3_tree.py` (``../../gallery/tree/plot_cogent3_tree.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_tree_plot_elements_tree.py` (``../../gallery/tree/plot_elements_tree.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_tree_plot_ete4.py` (``../../gallery/tree/plot_ete4.py``)
      - 00:00.000
      - 0.0
@@ -173,6 +191,12 @@ Computation times
    * - :ref:`sphx_glr_gallery_tree_plot_skbio_tree.py` (``../../gallery/tree/plot_skbio_tree.py``)
      - 00:00.000
      - 0.0
+   * - :ref:`sphx_glr_gallery_tree_plot_split_edges.py` (``../../gallery/tree/plot_split_edges.py``)
+     - 00:00.000
+     - 0.0
+   * - :ref:`sphx_glr_gallery_tree_plot_style_tree.py` (``../../gallery/tree/plot_style_tree.py``)
+     - 00:00.000
+     - 0.0
    * - :ref:`sphx_glr_gallery_tree_plot_support.py` (``../../gallery/tree/plot_support.py``)
      - 00:00.000
      - 0.0

iplotx-0.6.1/gallery/plot_arrowlawn.py

@@ -0,0 +1,81 @@
+"""
+Arrow lawn
+==========
+
+This example demonstrates the visualisation of a network with 1,000 nodes and a few thousand
+edges, using a custom layout that resembles a lawn of arrows.
+"""
+
+import numpy as np
+import iplotx as ipx
+import matplotlib.pyplot as plt
+
+n = 1000  # Number of nodes
+k = 3
+layout = np.random.rand(n, 2)
+nodes = np.arange(n)
+edges = []
+for i, v1 in enumerate(layout):
+    found = 0
+    dv = layout - v1
+    for j in (dv**2).sum(axis=1).argsort()[1:]:
+        angle = 180 / np.pi * np.arctan2(dv[j, 1], dv[j, 0])
+        # Only make an edge for neighbors towards the north-east
+        if 10 < angle < 80:
+            edges.append((i, j))
+            found += 1
+            if found == k:
+                break
+
+# Plot the network using iplotx
+fig, ax = plt.subplots(figsize=(7, 7))
+ipx.network(
+    {'nodes': nodes, 'edges': edges, 'directed': True},
+    layout=layout,
+    ax=ax,
+    vertex_size=5,
+    vertex_alpha=0.8,
+    vertex_facecolor="seagreen",
+    vertex_edgecolor="none",
+    edge_arrow_width=3,
+    edge_alpha=0.5,
+)
+fig.tight_layout()
+
+
+# %%
+# If you want to start pushing the scalability of iplotx, you can try with 10,000 nodes and
+# ~30,000 edges. This takes ~14 seconds on a modern laptop, of which 5 are spent on building
+# the network and 9 are spent inside of ``iplotx`` visualising it:
+
+n = 10000  # Number of nodes
+k = 3
+layout = np.random.rand(n, 2)
+nodes = np.arange(n)
+edges = []
+for i, v1 in enumerate(layout):
+    found = 0
+    dv = layout - v1
+    for j in (dv**2).sum(axis=1).argsort()[1:]:
+        angle = 180 / np.pi * np.arctan2(dv[j, 1], dv[j, 0])
+        # Only make an edge for neighbors towards the north-east
+        if 10 < angle < 80:
+            edges.append((i, j))
+            found += 1
+            if found == k:
+                break
+
+# Plot the network using iplotx
+fig, ax = plt.subplots(figsize=(9, 9))
+ipx.network(
+    {'nodes': nodes, 'edges': edges, 'directed': True},
+    layout=layout,
+    ax=ax,
+    vertex_size=5,
+    vertex_alpha=0.8,
+    vertex_facecolor="seagreen",
+    vertex_edgecolor="none",
+    edge_arrow_width=3,
+    edge_alpha=0.5,
+)
+fig.tight_layout()

{iplotx-0.5.1 → iplotx-0.6.1}/gallery/plot_arrows.py

@@ -9,14 +9,15 @@ import networkx as nx
 import matplotlib.pyplot as plt
 import iplotx as ipx
 
-arrow_markers = ["|>", "|/", "|\\", ">", ">>", ")>", ")", "|", "s", "d", "p", "q"]
+arrow_markers = ["|>", "|/", "|\\", ">", "<", ">>", ")>", ")", "(", "]", "[", "|",
+                 "x", "s", "d", "p", "q"]
 n = len(arrow_markers)
 G = nx.DiGraph()
 G.add_edges_from([(f"l{i}", f"r{i}") for i in range(n)])
 layout = {f"l{i}": (0, -i) for i in range(n)}
 layout.update({f"r{i}": (1, -i) for i in range(n)})
 
-fig, ax = plt.subplots(figsize=(3, 7.5))
+fig, ax = plt.subplots(figsize=(3, 8.5))
 ipx.network(
     G,
     layout=layout,
@@ -24,8 +25,10 @@ ipx.network(
     vertex_size=12,
     edge_arrow_marker=arrow_markers,
     edge_arrow_height="width",
+    edge_padding=8,
     edge_color="steelblue",
     title="Arrow markers",
 )
 ax.set_yticks(list(range(-n + 1, 1))[::-1])
 ax.set_yticklabels(arrow_markers)
+ax.yaxis.set_tick_params(length=0)

iplotx-0.6.1/gallery/plot_edgepadding.py

@@ -0,0 +1,37 @@
+"""
+Edge padding
+============
+
+This example illustrates how to pad edges, i.e. leave a bit of empty space between
+edge cap (end) and the border of its source/target vertices.
+"""
+
+import iplotx as ipx
+
+graph = {
+    "edges": [
+        ("A", "B"),
+        ("B", "C"),
+        ("C", "D"),
+        ("C", "E"),
+        ("E", "Bingo"),
+    ],
+    "directed": True,
+}
+layout = {
+    "A": (0, 0),
+    "B": (1, 0),
+    "C": (1, 1),
+    "D": (-1, 1),
+    "E": (-0.5, 2),
+    "Bingo": (0, 3),
+}
+
+ipx.network(
+    graph,
+    layout,
+    style="rededge",
+    edge_padding=5,
+    vertex_labels=True,
+    vertex_size={"A": 20, "B": 20, "C": 20, "D": 20, "E": 20, "Bingo": 50},
+)

iplotx-0.6.1/gallery/plot_elements.py

@@ -0,0 +1,43 @@
+"""
+Network element showroom
+========================
+
+This example showcases various plot elements that can be styled in ``iplotx``.
+"""
+
+import matplotlib.pyplot as plt
+import iplotx as ipx
+
+network = {
+    "edges": [(0, 1), (1, 2), (2, 3), (3, 0), (2, 2)],
+    "directed": True,
+}
+layout = [(0, 0), (1, 0), (1, 1), (0, 1)]
+
+fig, ax = plt.subplots(figsize=(4.3, 4.3))
+ipx.network(
+    network,
+    layout,
+    ax=ax,
+    vertex_labels=["Vertex\nlabel"] + [""] * 3,
+    edge_labels=["", "", "Edge\nlabel", "", ""],
+    vertex_label_bbox_edgecolor="k",
+    vertex_label_bbox_linewidth=1.5,
+    vertex_label_bbox_facecolor="steelblue",
+    vertex_label_bbox_alpha=0.5,
+    edge_label_bbox_edgecolor="k",
+    edge_label_bbox_linewidth=1.5,
+    edge_label_bbox_facecolor="tomato",
+    edge_color=["k", "tomato", "k", "k", "k"],
+    edge_arrow_color=["k", "darkred", "k", "k", "k"],
+    edge_linewidth=[2, 4, 2, 2, 2],
+    vertex_facecolor=["w"] * 3 + ["steelblue"],
+    vertex_edgecolor="k",
+    vertex_linewidth=2,
+    vertex_size=[50, 25, 25, 50],
+    vertex_marker="o",
+    vertex_label_color="k",
+    edge_curved=True,
+    edge_tension=[0, 1.25, 0, 3.5],
+    margins=(0, 0.08),
+)

iplotx-0.6.1/gallery/plot_feedbacks.py

@@ -0,0 +1,54 @@
+"""
+Feedback loops
+==============
+
+Graphs with arrows and bars are commonly used to represent feedback loops in systems.
+This example shows how to obtain that effect in ``iplotx``.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import iplotx as ipx
+
+graph = {
+    "edges": [
+        ("A", "B"),
+        ("B", "C"),
+        ("C", "A"),
+    ],
+    "directed": True,
+}
+layout = {
+    "A": (0, 0),
+    "B": (1, 0),
+    "C": (0.5, 0.5 * 1.73),
+}
+
+fig, ax = plt.subplots()
+ipx.network(
+    graph,
+    layout,
+    ax=ax,
+    vertex_size=50,
+    edge_linewidth=5,
+    edge_arrow_width=30,
+    edge_arrow_height=40,
+    edge_arrow_marker=[")>", "|", "|"],
+    edge_padding=15,
+    edge_curved=True,
+    edge_tension=[2, 2, 2],
+    vertex_facecolor=["#26677FFF", "#635C72FF", "#89374FFF"],
+    vertex_edgecolor="black",
+    vertex_linewidth=5,
+    aspect=1.0,
+    margins=0.1,
+)
+
+# Add a parametric spiral
+t = np.linspace(0, 4 * np.pi, 400)
+ax.plot(
+    0.5 + np.cos(t + np.pi) * t / 40,
+    0.31 + np.sin(t + np.pi) * t / 40,
+    color="grey",
+    lw=4,
+)

iplotx-0.6.1/gallery/plot_redblack.py

@@ -0,0 +1,71 @@
+"""
+The red and the black
+=====================
+
+This example demonstrates how to overlay an ``iplotx`` artist with plain matplotlib patches.
+"""
+
+
+import numpy as np
+import iplotx as ipx
+import matplotlib.pyplot as plt
+
+# We will use a network laid out onto a square grid
+gsize = 5  # Grid size
+layout = [(i % gsize, i // gsize) for i in range(gsize**2)]
+
+# Two possible colors
+colorlist = np.array(["tomato", "#111"])
+
+# Assign node colors at random
+node_colors = colorlist[np.random.randint(2, size=gsize**2)]
+
+# Connect two neighboring nodes if they have the same color
+edges = []
+for inode in range(gsize**2):
+    i = inode // gsize
+    j = inode % gsize
+    # Four possible edges
+    cands = []
+    if i != 0:
+        cands.append(inode - gsize)
+    if j != 0:
+        cands.append(inode - 1)
+    if i != gsize - 1:
+        cands.append(inode + gsize)
+    if j != gsize - 1:
+        cands.append(inode + 1)
+    for inode2 in cands:
+        if node_colors[inode] == node_colors[inode2]:
+            if (inode2, inode) not in edges:
+                edges.append((inode, inode2))
+
+# Build the network using our zero-dependency data structure
+network = {
+    "edges": edges,
+    "nodes": list(range(gsize**2)),
+}
+
+# Visualise the network
+fig, ax = plt.subplots(figsize=(5, 5))
+ipx.network(
+    network,
+    layout=layout,
+    ax=ax,
+    vertex_size=8,
+    vertex_marker='d',
+)
+
+# Add square patches centered on each node
+for i in range(gsize):
+    for j in range(gsize):
+        inode = i * gsize + j
+        ax.add_patch(plt.Rectangle(
+            (j-0.5, i-0.5),
+            1,
+            1,
+            facecolor=node_colors[inode],
+            edgecolor="none",
+            alpha=0.4,
+            zorder=0,
+        ))

iplotx-0.6.1/gallery/plot_waypoints.py

@@ -0,0 +1,40 @@
+"""
+Edge waypoints
+==============
+
+This example demonstrates the use of edge waypoints.
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+import iplotx as ipx
+
+g = {
+    "edges": [
+        ("A", "B"),
+        ("B", "C"),
+        ("B", "D"),
+        ("A", "E"),
+    ],
+}
+layout = {
+    "A": (0, 0),
+    "B": (0, 1),
+    "C": (1, 2),
+    "D": (0, 2),
+    "E": (-1, 1),
+}
+
+fig, ax = plt.subplots()
+ipx.network(
+    g,
+    layout=layout,
+    ax=ax,
+    vertex_labels=True,
+    edge_waypoints=["none", [(1, 1), (0.5, 1.5), (1, 1.5)], "none", "none"],
+)
+plt.ion(); plt.show()
+
+# %%
+# .. note::
+#   Edge waypoints are not currently compatible with curved edges.

iplotx-0.6.1/gallery/tree/plot_elements_tree.py

@@ -0,0 +1,55 @@
+"""
+Tree element showroom
+=====================
+
+This example showcases plot elements for tree styling in ``iplotx``.
+"""
+
+import matplotlib.pyplot as plt
+import iplotx as ipx
+
+tree = {
+    "name": "Vertex\nlabel",
+    "children": [
+        {
+            "children": [
+                {},
+                {
+                    "children": [{}, {}]
+                },
+            ],
+        },
+        {},
+    ],
+}
+tree = ipx.ingest.providers.tree.simple.SimpleTree.from_dict(tree)
+
+fig, ax = plt.subplots(figsize=(3.9, 3.3))
+ipx.tree(
+    tree,
+    ax=ax,
+    vertex_size=[0] * 6 + [(45, 35)],
+    vertex_marker="r",
+    vertex_facecolor=["none"] * 6 + ["orange"],
+    vertex_alpha=0.5,
+    vertex_edgecolor="black",
+    vertex_linewidth=1.5,
+    vertex_labels=True,
+    vertex_label_hmargin=0,
+    leaf_labels={tree.children[0].children[0]: "Leaf\nlabel"},
+    leaf_label_bbox_facecolor="lightcoral",
+    leaf_label_bbox_edgecolor="black",
+    leaf_label_bbox_alpha=0.9,
+    leaf_deep=True,
+    cascade_facecolor={
+        tree.children[0].children[1]: "gold",
+    },
+    edge_linewidth=3,
+    edge_split_linewidth=3,
+    edge_split_linestyle=["-."] + ["-"] * 6,
+    edge_split_color=["tomato"] + ["black"] * 6,
+    edge_capstyle="round",
+    edge_split_capstyle="round",
+    margins=(0.21, 0.08),
+)
+plt.ion(); plt.show()

iplotx-0.6.1/gallery/tree/plot_style_tree.py

@@ -0,0 +1,42 @@
+"""
+Style hierarchy
+===============
+
+This example shows a few elements from  ``iplotx``'s style hierarchy.
+"""
+
+import matplotlib.pyplot as plt
+import iplotx as ipx
+
+tree = {
+    "name": "style",
+    "children": [
+        {
+            "name": "vertex",
+            "children": [
+                {
+                    "name": "size",
+                },
+                {"name": "..."},
+            ],
+        },
+        {"name": "..."},
+    ],
+}
+tree = ipx.ingest.providers.tree.simple.SimpleTree.from_dict(tree)
+
+fig, ax = plt.subplots(figsize=(4, 2.5))
+ipx.tree(
+    tree,
+    ax=ax,
+    vertex_labels=True,
+    vertex_size=[(50, 25)] * 5,
+    vertex_facecolor="none",
+    vertex_edgecolor="black",
+    vertex_linewidth=1.5,
+    vertex_marker="r",
+    vertex_label_horizontalalignment="center",
+    vertex_label_hmargin=0,
+    margins=(0.1, 0.1),
+)
+ax.invert_yaxis()

{iplotx-0.5.1 → iplotx-0.6.1}/iplotx/edge/__init__.py

@@ -105,6 +105,10 @@ class EdgeCollection(mpl.collections.PatchCollection):
         # NOTE: This should also set the transform
         super().__init__(patches, transform=transform, *args, **kwargs)
 
+        # Apparenyly capstyle is lost upon collection creation
+        if "capstyle" in self._style:
+            self.set_capstyle(self._style["capstyle"])
+
         # This is important because it prepares the right flags for scalarmappable
         self.set_facecolor("none")
 
@@ -158,6 +162,10 @@ class EdgeCollection(mpl.collections.PatchCollection):
             **kwargs,
         )
 
+        # Apparently capstyle is lost upon collection creation
+        if "capstyle" in style:
+            self._subedges.set_capstyle(style["capstyle"])
+
     def get_children(self) -> tuple:
         children = []
         if hasattr(self, "_subedges"):
@@ -188,7 +196,7 @@ class EdgeCollection(mpl.collections.PatchCollection):
         return self._directed
 
     @directed.setter
-    def directed(self, value) -> None:
+    def directed(self, value: bool) -> None:
         """Setter for the directed property.
 
         Changing this property triggers the addition/removal of arrows from the plot.
@@ -230,7 +238,11 @@ class EdgeCollection(mpl.collections.PatchCollection):
         # NOTE: The superclass also sets stale = True
         super().update_scalarmappable()
         # Now self._edgecolors has the correct colorspace values
-        if hasattr(self, "_arrows"):
+        # NOTE: The following line should include a condition on
+        # whether the arrows are allowing color matching to the
+        # edges. For now, we assume that if the edges are colormapped
+        # we would want the arrows to be as well.
+        if hasattr(self, "_arrows") and (self._A is not None):
             self._arrows.set_colors(self.get_edgecolor())
 
     def get_labels(self) -> Optional[LabelCollection]:
@@ -337,6 +349,10 @@ class EdgeCollection(mpl.collections.PatchCollection):
                 tension = 0
                 ports = None
 
+            # Scale padding by dpi
+            dpi = self.figure.dpi if hasattr(self, "figure") else 72.0
+            padding = dpi / 72.0 * edge_stylei.pop("padding", 0)
+
             # False is a synonym for "none"
             waypoints = edge_stylei.get("waypoints", "none")
             if waypoints is False or waypoints is np.False_:
@@ -348,9 +364,6 @@ class EdgeCollection(mpl.collections.PatchCollection):
             if waypoints != "none":
                 ports = edge_stylei.get("ports", (None, None))
 
-            if not isinstance(waypoints, str):
-                __import__("ipdb").set_trace()
-
             # Compute actual edge path
             path, angles = _compute_edge_path(
                 vcoord_data,
@@ -362,6 +375,7 @@ class EdgeCollection(mpl.collections.PatchCollection):
                 waypoints=waypoints,
                 ports=ports,
                 layout_coordinate_system=self._vertex_collection.get_layout_coordinate_system(),
+                padding=padding,
             )
 
             offset = edge_stylei.get("offset", 0)
@@ -375,7 +389,6 @@ class EdgeCollection(mpl.collections.PatchCollection):
                     offset = offset * vrot
             offset = np.asarray(offset, dtype=float)
             # Scale by dpi
-            dpi = self.figure.dpi if hasattr(self, "figure") else 72.0
             offset *= dpi / 72.0
             if (offset != 0).any():
                 path.vertices[:] = trans_inv(trans(path.vertices) + offset)
@@ -702,6 +715,7 @@ def make_stub_patch(**kwargs):
         "cmap",
         "norm",
         "split",
+        "padding",
     ]
     for prop in forbidden_props:
         if prop in kwargs: