How to increase node spacing for networkx.spring_layout

I used the optimal distance parameter of the Kamada Kawai layout, and set the distance between non-connected components to the maximum distance in the graph. There is probably a better way of munging the dictionaries, but this is pretty easy:

df = pd.DataFrame(index=G.nodes(), columns=G.nodes())
for row, data in nx.shortest_path_length(G):
    for col, dist in data.items():
        df.loc[row,col] = dist

df = df.fillna(df.max().max())

layout = nx.kamada_kawai_layout(G, dist=df.to_dict())

The solution to this problem lies in the NetworkX version 1.8 which is yet to be released, but is available via git hub.

Do the following to increase the distance between nodes:

pos = nx.spring_layout(G, k=0.15, iterations=20)
# k controls the distance between the nodes and varies between 0 and 1
# iterations is the number of times simulated annealing is run
# default k=0.1 and iterations=50

Tweak with these parameters to see how it works. But despite this there is no guarantee that all nodes are non-overlapping

The real answer to your question is that your original graph is not a single, fully-connected component. It is three separate graphs.

What is happening is the three pieces are flying away to infinity, which upon re-scaling makes each component look like a tiny blob.

The algorithm spring_layout specifies a repulsive force between all nodes (anti-gravity), and an attractive force between only connected nodes (the "springs").

Thus, if the graph isn't connected, the individual pieces will fly away from the repulsive force since there is nothing connecting them. There are two options: Change the force law (edit the networkx code), or graph the components separately.

Here's how to add a force that attracts all nodes to the center of the chart. Add the last line of this code snippet to def _fruchterman_reingold in layouts.py:

# displacement "force"
displacement = np.einsum('ijk,ij->ik',
                         delta,
                         (k * k / distance**2 - A * distance / k))
# ADD THIS LINE - prevent things from flying off into infinity if not connected
displacement = displacement - pos / ( k * np.sqrt(nnodes))

This single line of code allows you to make charts like: rather than However the "best" way to deal with this is to chart the components seperately.

You can iterate over the components, charting them in seperate plots, with the functions described here.

See this github issue for more discussion.