Drawing a clique graph with
import networkx as nx .... nx.draw(G, layout=nx.spring_layout(G))
produces the following picture:
Obviously, the spacing between the nodes (e.g., the edge length) needs to be increased. I've googled this and found this suggestion here:
For some of the layout algorithms there is a
scaleparameter that might help. e.g.
import networkx as nx G = nx.path_graph(4) pos = nx.spring_layout(G) # default to scale=1 nx.draw(G, pos) pos = nx.spring_layout(G, scale=2) # double distance between all nodes nx.draw(G, pos)
scale parameter does not seem to have any effect.
What is the right method to get a better drawing?
Alright, my answer is too late for this question. But 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.
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))
You can iterate over the components, charting them in seperate plots, with the functions described here.
See this github issue for more discussion.
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())