5 Best Ways to Create Curved Edges with NetworkX in Python3 Matplotlib

💡 Problem Formulation: When visualizing graphs using NetworkX and Matplotlib in Python, straight edges between nodes may not adequately represent complex relationships or parallel connections. Curved edges can offer a clearer, more visually distinct way to display such relationships. This article provides methods to achieve curved edges in graph visualizations using NetworkX with Matplotlib. An example input would be a NetworkX graph while the desired output is a visualization of the graph with curved edges.

Method 1: Using FancyArrowPatch to Draw Curved Edges

NetworkX and Matplotlib can be integrated to draw curves instead of straight lines using Matplotlib’s FancyArrowPatch. This method involves calculating control points for Bezier curves that represent the edges. FancyArrowPatch allows for a high degree of customization, including arrow styles and connection types.

Here’s an example:

import networkx as nx
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrowPatch

def draw_network(G, pos, ax, **kwargs):
    for (u, v) in G.edges():
        arrow = FancyArrowPatch(posA=pos[u], posB=pos[v], arrowstyle='-|>',
                                connectionstyle='arc3,rad=0.2', **kwargs)
        ax.add_patch(arrow)

G = nx.Graph()
G.add_edges_from([(1, 2), (2, 3), (3, 1)])
pos = nx.spring_layout(G)
fig, ax = plt.subplots()
draw_network(G, pos, ax)
nx.draw_networkx_nodes(G, pos)
plt.show()

The output will be a plot that shows a simple graph with three curved edges.

This code snippet defines a custom function draw_network() to add FancyArrowPatch objects for each edge in the graph. It uses a radial style to curve the edges, and the node positions are calculated using NetworkX’s spring_layout. Finally, it draws the nodes with draw_networkx_nodes and displays the result.

Method 2: Bezier Curve Edges with Adjustable Curvature

Bezier curves are ideal for creating smooth, visually appealing curved edges. By adjusting the curvature parameter, the user gains control over how pronounced the curves should be, making it suitable for various graph complexities.

Here’s an example:

import networkx as nx
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrowPatch

def draw_curved_edges(G, pos, ax):
    for edge in G.edges():
        src = pos[edge[0]]
        dst = pos[edge[1]]
        rad = 0.1
        arrow = FancyArrowPatch(src, dst, arrowstyle='-',
                                connectionstyle='arc3,rad={}'.format(rad), shrinkA=5, shrinkB=5)
        ax.add_patch(arrow)

G = nx.cycle_graph(4)
pos = nx.circular_layout(G)
fig, ax = plt.subplots()
draw_curved_edges(G, pos, ax)
nx.draw_networkx_nodes(G, pos)
plt.show()

The output will be a plot that shows a cycle graph with four curved edges.

This function plots a cycle graph with curved edges between nodes. The degree of curve for each edge is controlled by the rad variable. FancyArrowPatch is used to create Bezier curves that bend according to the level specified in the ‘rad’ parameter.

Method 3: Adding Arcs Between Parallel Edges

When dealing with multigraphs where parallel edges may exist between nodes, representing these edges as arcs can help distinguish them visually. This method involves specifically targeting and curving such parallel edges to avoid visual confusion.

Here’s an example:

import networkx as nx
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrowPatch

def draw_arc_edges(G, pos, ax):
    for edge in G.edges():
        if G.number_of_edges(edge[0], edge[1]) > 1: 
            arc_radius = 0.2
        else:
            arc_radius = 0
        arrow = FancyArrowPatch(pos[edge[0]], pos[edge[1]], arrowstyle='-',
                                connectionstyle='arc3,rad={}'.format(arc_radius))
        ax.add_patch(arrow)

G = nx.MultiGraph([(1, 2), (1, 2)])
pos = nx.spring_layout(G)
fig, ax = plt.subplots()
draw_arc_edges(G, pos, ax)
nx.draw_networkx_nodes(G, pos)
plt.show()

The output will show two nodes connected by parallel curved edges.

This code determines if multiple edges exist between two nodes and assigns a curvature radius for the corresponding edge(s). The FancyArrowPatch function draws the arcs with a curvature defined by the arc_radius variable.

Method 4: Curving Edges Based on Edge Weight

Curving edges based on their weight can provide additional insights into the significance of the relationship they represent. This method dynamically adjusts the curvature of each edge according to its assigned weight in the graph.

Here’s an example:

import networkx as nx
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrowPatch

def draw_weighted_curved_edges(G, pos, ax):
    for (u, v, d) in G.edges(data=True): 
        weight = d['weight']
        arc_radius = weight / 10.0
        arrow = FancyArrowPatch(pos[u], pos[v], arrowstyle='-',
                                connectionstyle='arc3,rad={}'.format(arc_radius))
        ax.add_patch(arrow)

G = nx.Graph()
G.add_weighted_edges_from([(1, 2, 5), (2, 3, 3), (3, 1, 1)])
pos = nx.spring_layout(G)
fig, ax = plt.subplots()
draw_weighted_curved_edges(G, pos, ax)
nx.draw_networkx_nodes(G, pos)
plt.show()

The output will be a graph with edges curved proportionally to their weights.

This function reads the weight data from each edge and adjusts the value of arc_radius accordingly. This is used in FancyArrowPatch to draw edges with a curvature that reflects the weight of the edge, providing a quick visual cue for the edge significance.

Bonus One-Liner Method 5: Utilizing NetworkX’s Curved Edges Feature

NetworkX provides native support for drawing curved edges with its recent versions, via the connectionstyle argument in the drawing function, offering a very concise way to achieve curved edges without additional coding complexity.

Here’s an example:

import networkx as nx
import matplotlib.pyplot as plt

G = nx.Graph([(1, 2), (2, 3), (3, 1)])
pos = nx.circular_layout(G)
nx.draw(G, pos, connectionstyle='arc3,rad=0.1')
plt.show()

The output will be a simple graph with curved edges.

By modifying the draw() function provided by NetworkX, this one-liner adjusts the connectionstyle parameter to introduce curvature to the edges with very minimal code.

Summary/Discussion

Method 1:

Method 2:

Method 3:

Method 4:

Bonus Method 5: