Drawing multiple edges between two nodes with networkx

Question

I need to draw a directed graph with more than one edge (with different weights) between two nodes. That is, I have nodes A and B and edges (A,B) with length=2 and (B,A) with length=3. I have tried both using G=nx.Digraph and G=nx.Multidigraph. When I draw it, I only get to view one edge and only one of the labels. Is there any way to do it?

Accepted Answer

Here is how to get an outcome similar to the following:

Some properties of this are:

- When there is a single edge between two nodes, it is straight.

- Labels are positioned perfectly in the middle of the edges.

- The current solution works for DiGraphs only. MultiGraphs, MultiDiGraphs, and self loops are not supported.

Setting it up

The following lines are initial code to start the example

```
import matplotlib.pyplot as plt
import networkx as nx

G = nx.DiGraph()
edge_list = [(1,2,{'w':'A1'}),(2,1,{'w':'A2'}),(2,3,{'w':'B'}),(3,1,{'w':'C'}),
             (3,4,{'w':'D1'}),(4,3,{'w':'D2'}),(1,5,{'w':'E1'}),(5,1,{'w':'E2'}),
             (3,5,{'w':'F'}),(5,4,{'w':'G'})]
G.add_edges_from(edge_list)
pos=nx.spring_layout(G,seed=5)
fig, ax = plt.subplots()
nx.draw_networkx_nodes(G, pos, ax=ax)
nx.draw_networkx_labels(G, pos, ax=ax)
fig.savefig("1.png", bbox_inches='tight',pad_inches=0)
```

Which results in:

Drawing edges

The `draw_networkx_edges` function of NetworkX is able to draw only a subset of the edges with the `edgelist` parameter. To use this, we group the edges into two lists and draw them separately. Thanks to AMangipinto's answer for `connectionstyle='arc3, rad = 0.1'`.

```
curved_edges = [edge for edge in G.edges() if reversed(edge) in G.edges()]
straight_edges = list(set(G.edges()) - set(curved_edges))
nx.draw_networkx_edges(G, pos, ax=ax, edgelist=straight_edges)
arc_rad = 0.25
nx.draw_networkx_edges(G, pos, ax=ax, edgelist=curved_edges, connectionstyle=f'arc3, rad = {arc_rad}')
fig.savefig("2.png", bbox_inches='tight',pad_inches=0)
```

Which results in:

Drawing edge labels

The `draw_networkx_edge_labels` function of NetworkX assumes the edges to be straight and there is no parameter to change this. Since NetworkX is open-souce, I copied the function and created a modified `my_draw_networkx_edge_labels`. This function is down at the appendix.

Assuming you save this function to a file called my_networkx.py, you can draw edge labels as:

```
import my_networkx as my_nx
edge_weights = nx.get_edge_attributes(G,'w')
curved_edge_labels = {edge: edge_weights[edge] for edge in curved_edges}
straight_edge_labels = {edge: edge_weights[edge] for edge in straight_edges}
my_nx.my_draw_networkx_edge_labels(G, pos, ax=ax, edge_labels=curved_edge_labels,rotate=False,rad = arc_rad)
nx.draw_networkx_edge_labels(G, pos, ax=ax, edge_labels=straight_edge_labels,rotate=False)
fig.savefig("3.png", bbox_inches='tight',pad_inches=0)
```

Where we once again seperated curved from straight. The result is the first figure in this answer.

Appendix

The function `draw_networkx_edge_labels` of NetworkX finds the positions of the labels assuming straight lines:

```
(x, y) = (
    x1 * label_pos + x2 * (1.0 - label_pos),
    y1 * label_pos + y2 * (1.0 - label_pos),
)
```

To find the middle point of a quadratic Bezier curve we can use the following code. First we find the middle control point (`ctrl_1` in the code) of the Bezier curve according to the definition in matplotlib:

The curve is created so that the middle control point (C1) is located at the same distance from the start (C0) and end points(C2) and the distance of the C1 to the line connecting C0-C2 is rad times the distance of C0-C2.

Due to this definition, the function `my_draw_networkx_edge_labels` requires an extra parameter called `rad`.

```
pos_1 = ax.transData.transform(np.array(pos[n1]))
pos_2 = ax.transData.transform(np.array(pos[n2]))
linear_mid = 0.5*pos_1 + 0.5*pos_2
d_pos = pos_2 - pos_1
rotation_matrix = np.array([(0,1), (-1,0)])
ctrl_1 = linear_mid + rad*rotation_matrix@d_pos
```

The functions starting with "ax.transData" are necessary since 90 degree angles in the axis domain do not correspond to 90 degrees in the display. So we had to transform coordinates to and from the display coordinate system.

`bezier_mid` can be calculated with Bezier curve rules:

```
ctrl_mid_1 = 0.5*pos_1 + 0.5*ctrl_1
ctrl_mid_2 = 0.5*pos_2 + 0.5*ctrl_1
bezier_mid = 0.5*ctrl_mid_1 + 0.5*ctrl_mid_2
(x, y) = ax.transData.inverted().transform(bezier_mid)
```

Complete `my_draw_networkx_edge_labels`:

```
def my_draw_networkx_edge_labels(
    G,
    pos,
    edge_labels=None,
    label_pos=0.5,
    font_size=10,
    font_color="k",
    font_family="sans-serif",
    font_weight="normal",
    alpha=None,
    bbox=None,
    horizontalalignment="center",
    verticalalignment="center",
    ax=None,
    rotate=True,
    clip_on=True,
    rad=0
):
    """Draw edge labels.

Parameters
    ----------
    G : graph
        A networkx graph

pos : dictionary
        A dictionary with nodes as keys and positions as values.
        Positions should be sequences of length 2.

edge_labels : dictionary (default={})
        Edge labels in a dictionary of labels keyed by edge two-tuple.
        Only labels for the keys in the dictionary are drawn.

label_pos : float (default=0.5)
        Position of edge label along edge (0=head, 0.5=center, 1=tail)

font_…

Drawing multiple edges between two nodes with networkx

Solution

Problem

Related problems