Created
July 18, 2014 12:15
-
-
Save koorukuroo/5efb58a86c5396f13650 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
""" | |
********** | |
Matplotlib | |
********** | |
Draw networks with matplotlib. | |
See Also | |
-------- | |
matplotlib: http://matplotlib.sourceforge.net/ | |
pygraphviz: http://networkx.lanl.gov/pygraphviz/ | |
""" | |
# Copyright (C) 2004-2012 by | |
# Aric Hagberg <hagberg@lanl.gov> | |
# Dan Schult <dschult@colgate.edu> | |
# Pieter Swart <swart@lanl.gov> | |
# All rights reserved. | |
# BSD license. | |
import networkx as nx | |
from networkx.drawing.layout import shell_layout,\ | |
circular_layout,spectral_layout,spring_layout,random_layout | |
__author__ = """Aric Hagberg (hagberg@lanl.gov)""" | |
__all__ = ['set_fontproperties', | |
'draw', | |
'draw_networkx', | |
'draw_networkx_nodes', | |
'draw_networkx_edges', | |
'draw_networkx_labels', | |
'draw_networkx_edge_labels', | |
'draw_circular', | |
'draw_random', | |
'draw_spectral', | |
'draw_spring', | |
'draw_shell', | |
'draw_graphviz'] | |
def set_fontproperties(font): | |
global fontproperties | |
fontproperties = font | |
def draw(G, pos=None, ax=None, hold=None, **kwds): | |
"""Draw the graph G with Matplotlib. | |
Draw the graph as a simple representation with no node | |
labels or edge labels and using the full Matplotlib figure area | |
and no axis labels by default. See draw_networkx() for more | |
full-featured drawing that allows title, axis labels etc. | |
Parameters | |
---------- | |
G : graph | |
A networkx graph | |
pos : dictionary, optional | |
A dictionary with nodes as keys and positions as values. | |
If not specified a spring layout positioning will be computed. | |
See networkx.layout for functions that compute node positions. | |
ax : Matplotlib Axes object, optional | |
Draw the graph in specified Matplotlib axes. | |
hold : bool, optional | |
Set the Matplotlib hold state. If True subsequent draw | |
commands will be added to the current axes. | |
**kwds : optional keywords | |
See networkx.draw_networkx() for a description of optional keywords. | |
Examples | |
-------- | |
>>> G=nx.dodecahedral_graph() | |
>>> nx.draw(G) | |
>>> nx.draw(G,pos=nx.spring_layout(G)) # use spring layout | |
See Also | |
-------- | |
draw_networkx() | |
draw_networkx_nodes() | |
draw_networkx_edges() | |
draw_networkx_labels() | |
draw_networkx_edge_labels() | |
Notes | |
----- | |
This function has the same name as pylab.draw and pyplot.draw | |
so beware when using | |
>>> from networkx import * | |
since you might overwrite the pylab.draw function. | |
With pyplot use | |
>>> import matplotlib.pyplot as plt | |
>>> import networkx as nx | |
>>> G=nx.dodecahedral_graph() | |
>>> nx.draw(G) # networkx draw() | |
>>> plt.draw() # pyplot draw() | |
Also see the NetworkX drawing examples at | |
http://networkx.lanl.gov/gallery.html | |
""" | |
try: | |
import matplotlib.pyplot as plt | |
except ImportError: | |
raise ImportError("Matplotlib required for draw()") | |
except RuntimeError: | |
print("Matplotlib unable to open display") | |
raise | |
if ax is None: | |
cf = plt.gcf() | |
else: | |
cf = ax.get_figure() | |
cf.set_facecolor('w') | |
if ax is None: | |
if cf._axstack() is None: | |
ax=cf.add_axes((0,0,1,1)) | |
else: | |
ax=cf.gca() | |
# allow callers to override the hold state by passing hold=True|False | |
b = plt.ishold() | |
h = kwds.pop('hold', None) | |
if h is not None: | |
plt.hold(h) | |
try: | |
draw_networkx(G,pos=pos,ax=ax,**kwds) | |
ax.set_axis_off() | |
plt.draw_if_interactive() | |
except: | |
plt.hold(b) | |
raise | |
plt.hold(b) | |
return | |
def draw_networkx(G, pos=None, with_labels=True, **kwds): | |
"""Draw the graph G using Matplotlib. | |
Draw the graph with Matplotlib with options for node positions, | |
labeling, titles, and many other drawing features. | |
See draw() for simple drawing without labels or axes. | |
Parameters | |
---------- | |
G : graph | |
A networkx graph | |
pos : dictionary, optional | |
A dictionary with nodes as keys and positions as values. | |
If not specified a spring layout positioning will be computed. | |
See networkx.layout for functions that compute node positions. | |
with_labels : bool, optional (default=True) | |
Set to True to draw labels on the nodes. | |
ax : Matplotlib Axes object, optional | |
Draw the graph in the specified Matplotlib axes. | |
nodelist : list, optional (default G.nodes()) | |
Draw only specified nodes | |
edgelist : list, optional (default=G.edges()) | |
Draw only specified edges | |
node_size : scalar or array, optional (default=300) | |
Size of nodes. If an array is specified it must be the | |
same length as nodelist. | |
node_color : color string, or array of floats, (default='r') | |
Node color. Can be a single color format string, | |
or a sequence of colors with the same length as nodelist. | |
If numeric values are specified they will be mapped to | |
colors using the cmap and vmin,vmax parameters. See | |
matplotlib.scatter for more details. | |
node_shape : string, optional (default='o') | |
The shape of the node. Specification is as matplotlib.scatter | |
marker, one of 'so^>v<dph8'. | |
alpha : float, optional (default=1.0) | |
The node transparency | |
cmap : Matplotlib colormap, optional (default=None) | |
Colormap for mapping intensities of nodes | |
vmin,vmax : float, optional (default=None) | |
Minimum and maximum for node colormap scaling | |
linewidths : [None | scalar | sequence] | |
Line width of symbol border (default =1.0) | |
width : float, optional (default=1.0) | |
Line width of edges | |
edge_color : color string, or array of floats (default='r') | |
Edge color. Can be a single color format string, | |
or a sequence of colors with the same length as edgelist. | |
If numeric values are specified they will be mapped to | |
colors using the edge_cmap and edge_vmin,edge_vmax parameters. | |
edge_ cmap : Matplotlib colormap, optional (default=None) | |
Colormap for mapping intensities of edges | |
edge_vmin,edge_vmax : floats, optional (default=None) | |
Minimum and maximum for edge colormap scaling | |
style : string, optional (default='solid') | |
Edge line style (solid|dashed|dotted,dashdot) | |
labels : dictionary, optional (default=None) | |
Node labels in a dictionary keyed by node of text labels | |
font_size : int, optional (default=12) | |
Font size for text labels | |
font_color : string, optional (default='k' black) | |
Font color string | |
font_weight : string, optional (default='normal') | |
Font weight | |
font_family : string, optional (default='sans-serif') | |
Font family | |
label : string, optional | |
Label for graph legend | |
Examples | |
-------- | |
>>> G=nx.dodecahedral_graph() | |
>>> nx.draw(G) | |
>>> nx.draw(G,pos=nx.spring_layout(G)) # use spring layout | |
>>> import matplotlib.pyplot as plt | |
>>> limits=plt.axis('off') # turn of axis | |
Also see the NetworkX drawing examples at | |
http://networkx.lanl.gov/gallery.html | |
See Also | |
-------- | |
draw() | |
draw_networkx_nodes() | |
draw_networkx_edges() | |
draw_networkx_labels() | |
draw_networkx_edge_labels() | |
""" | |
try: | |
import matplotlib.pyplot as plt | |
except ImportError: | |
raise ImportError("Matplotlib required for draw()") | |
except RuntimeError: | |
print("Matplotlib unable to open display") | |
raise | |
if pos is None: | |
pos=nx.drawing.spring_layout(G) # default to spring layout | |
node_collection=draw_networkx_nodes(G, pos, **kwds) | |
edge_collection=draw_networkx_edges(G, pos, **kwds) | |
if with_labels: | |
draw_networkx_labels(G, pos, **kwds) | |
plt.draw_if_interactive() | |
def draw_networkx_nodes(G, pos, | |
nodelist=None, | |
node_size=300, | |
node_color='r', | |
node_shape='o', | |
alpha=1.0, | |
cmap=None, | |
vmin=None, | |
vmax=None, | |
ax=None, | |
linewidths=None, | |
label = None, | |
**kwds): | |
"""Draw the nodes of the graph G. | |
This draws only the nodes of the graph G. | |
Parameters | |
---------- | |
G : graph | |
A networkx graph | |
pos : dictionary | |
A dictionary with nodes as keys and positions as values. | |
If not specified a spring layout positioning will be computed. | |
See networkx.layout for functions that compute node positions. | |
ax : Matplotlib Axes object, optional | |
Draw the graph in the specified Matplotlib axes. | |
nodelist : list, optional | |
Draw only specified nodes (default G.nodes()) | |
node_size : scalar or array | |
Size of nodes (default=300). If an array is specified it must be the | |
same length as nodelist. | |
node_color : color string, or array of floats | |
Node color. Can be a single color format string (default='r'), | |
or a sequence of colors with the same length as nodelist. | |
If numeric values are specified they will be mapped to | |
colors using the cmap and vmin,vmax parameters. See | |
matplotlib.scatter for more details. | |
node_shape : string | |
The shape of the node. Specification is as matplotlib.scatter | |
marker, one of 'so^>v<dph8' (default='o'). | |
alpha : float | |
The node transparency (default=1.0) | |
cmap : Matplotlib colormap | |
Colormap for mapping intensities of nodes (default=None) | |
vmin,vmax : floats | |
Minimum and maximum for node colormap scaling (default=None) | |
linewidths : [None | scalar | sequence] | |
Line width of symbol border (default =1.0) | |
label : [None| string] | |
Label for legend | |
Examples | |
-------- | |
>>> G=nx.dodecahedral_graph() | |
>>> nodes=nx.draw_networkx_nodes(G,pos=nx.spring_layout(G)) | |
Also see the NetworkX drawing examples at | |
http://networkx.lanl.gov/gallery.html | |
See Also | |
-------- | |
draw() | |
draw_networkx() | |
draw_networkx_edges() | |
draw_networkx_labels() | |
draw_networkx_edge_labels() | |
""" | |
try: | |
import matplotlib.pyplot as plt | |
import numpy | |
except ImportError: | |
raise ImportError("Matplotlib required for draw()") | |
except RuntimeError: | |
print("Matplotlib unable to open display") | |
raise | |
if ax is None: | |
ax=plt.gca() | |
if nodelist is None: | |
nodelist=G.nodes() | |
if not nodelist or len(nodelist)==0: # empty nodelist, no drawing | |
return None | |
try: | |
xy=numpy.asarray([pos[v] for v in nodelist]) | |
except KeyError as e: | |
raise nx.NetworkXError('Node %s has no position.'%e) | |
except ValueError: | |
raise nx.NetworkXError('Bad value in node positions.') | |
node_collection=ax.scatter(xy[:,0], xy[:,1], | |
s=node_size, | |
c=node_color, | |
marker=node_shape, | |
cmap=cmap, | |
vmin=vmin, | |
vmax=vmax, | |
alpha=alpha, | |
linewidths=linewidths, | |
label=label) | |
node_collection.set_zorder(2) | |
return node_collection | |
def draw_networkx_edges(G, pos, | |
edgelist=None, | |
width=1.0, | |
edge_color='k', | |
style='solid', | |
alpha=None, | |
edge_cmap=None, | |
edge_vmin=None, | |
edge_vmax=None, | |
ax=None, | |
arrows=True, | |
label=None, | |
**kwds): | |
"""Draw the edges of the graph G. | |
This draws only the edges of the graph G. | |
Parameters | |
---------- | |
G : graph | |
A networkx graph | |
pos : dictionary | |
A dictionary with nodes as keys and positions as values. | |
If not specified a spring layout positioning will be computed. | |
See networkx.layout for functions that compute node positions. | |
edgelist : collection of edge tuples | |
Draw only specified edges(default=G.edges()) | |
width : float | |
Line width of edges (default =1.0) | |
edge_color : color string, or array of floats | |
Edge color. Can be a single color format string (default='r'), | |
or a sequence of colors with the same length as edgelist. | |
If numeric values are specified they will be mapped to | |
colors using the edge_cmap and edge_vmin,edge_vmax parameters. | |
style : string | |
Edge line style (default='solid') (solid|dashed|dotted,dashdot) | |
alpha : float | |
The edge transparency (default=1.0) | |
edge_ cmap : Matplotlib colormap | |
Colormap for mapping intensities of edges (default=None) | |
edge_vmin,edge_vmax : floats | |
Minimum and maximum for edge colormap scaling (default=None) | |
ax : Matplotlib Axes object, optional | |
Draw the graph in the specified Matplotlib axes. | |
arrows : bool, optional (default=True) | |
For directed graphs, if True draw arrowheads. | |
label : [None| string] | |
Label for legend | |
Notes | |
----- | |
For directed graphs, "arrows" (actually just thicker stubs) are drawn | |
at the head end. Arrows can be turned off with keyword arrows=False. | |
Yes, it is ugly but drawing proper arrows with Matplotlib this | |
way is tricky. | |
Examples | |
-------- | |
>>> G=nx.dodecahedral_graph() | |
>>> edges=nx.draw_networkx_edges(G,pos=nx.spring_layout(G)) | |
Also see the NetworkX drawing examples at | |
http://networkx.lanl.gov/gallery.html | |
See Also | |
-------- | |
draw() | |
draw_networkx() | |
draw_networkx_nodes() | |
draw_networkx_labels() | |
draw_networkx_edge_labels() | |
""" | |
try: | |
import matplotlib | |
import matplotlib.pyplot as plt | |
import matplotlib.cbook as cb | |
from matplotlib.colors import colorConverter,Colormap | |
from matplotlib.collections import LineCollection | |
import numpy | |
except ImportError: | |
raise ImportError("Matplotlib required for draw()") | |
except RuntimeError: | |
print("Matplotlib unable to open display") | |
raise | |
if ax is None: | |
ax=plt.gca() | |
if edgelist is None: | |
edgelist=G.edges() | |
if not edgelist or len(edgelist)==0: # no edges! | |
return None | |
# set edge positions | |
edge_pos=numpy.asarray([(pos[e[0]],pos[e[1]]) for e in edgelist]) | |
if not cb.iterable(width): | |
lw = (width,) | |
else: | |
lw = width | |
if not cb.is_string_like(edge_color) \ | |
and cb.iterable(edge_color) \ | |
and len(edge_color)==len(edge_pos): | |
if numpy.alltrue([cb.is_string_like(c) | |
for c in edge_color]): | |
# (should check ALL elements) | |
# list of color letters such as ['k','r','k',...] | |
edge_colors = tuple([colorConverter.to_rgba(c,alpha) | |
for c in edge_color]) | |
elif numpy.alltrue([not cb.is_string_like(c) | |
for c in edge_color]): | |
# If color specs are given as (rgb) or (rgba) tuples, we're OK | |
if numpy.alltrue([cb.iterable(c) and len(c) in (3,4) | |
for c in edge_color]): | |
edge_colors = tuple(edge_color) | |
else: | |
# numbers (which are going to be mapped with a colormap) | |
edge_colors = None | |
else: | |
raise ValueError('edge_color must consist of either color names or numbers') | |
else: | |
if cb.is_string_like(edge_color) or len(edge_color)==1: | |
edge_colors = ( colorConverter.to_rgba(edge_color, alpha), ) | |
else: | |
raise ValueError('edge_color must be a single color or list of exactly m colors where m is the number or edges') | |
edge_collection = LineCollection(edge_pos, | |
colors = edge_colors, | |
linewidths = lw, | |
antialiaseds = (1,), | |
linestyle = style, | |
transOffset = ax.transData, | |
) | |
edge_collection.set_zorder(1) # edges go behind nodes | |
edge_collection.set_label(label) | |
ax.add_collection(edge_collection) | |
# Note: there was a bug in mpl regarding the handling of alpha values for | |
# each line in a LineCollection. It was fixed in matplotlib in r7184 and | |
# r7189 (June 6 2009). We should then not set the alpha value globally, | |
# since the user can instead provide per-edge alphas now. Only set it | |
# globally if provided as a scalar. | |
if cb.is_numlike(alpha): | |
edge_collection.set_alpha(alpha) | |
if edge_colors is None: | |
if edge_cmap is not None: | |
assert(isinstance(edge_cmap, Colormap)) | |
edge_collection.set_array(numpy.asarray(edge_color)) | |
edge_collection.set_cmap(edge_cmap) | |
if edge_vmin is not None or edge_vmax is not None: | |
edge_collection.set_clim(edge_vmin, edge_vmax) | |
else: | |
edge_collection.autoscale() | |
arrow_collection=None | |
if G.is_directed() and arrows: | |
# a directed graph hack | |
# draw thick line segments at head end of edge | |
# waiting for someone else to implement arrows that will work | |
arrow_colors = edge_colors | |
a_pos=[] | |
p=1.0-0.25 # make head segment 25 percent of edge length | |
for src,dst in edge_pos: | |
x1,y1=src | |
x2,y2=dst | |
dx=x2-x1 # x offset | |
dy=y2-y1 # y offset | |
d=numpy.sqrt(float(dx**2+dy**2)) # length of edge | |
if d==0: # source and target at same position | |
continue | |
if dx==0: # vertical edge | |
xa=x2 | |
ya=dy*p+y1 | |
if dy==0: # horizontal edge | |
ya=y2 | |
xa=dx*p+x1 | |
else: | |
theta=numpy.arctan2(dy,dx) | |
xa=p*d*numpy.cos(theta)+x1 | |
ya=p*d*numpy.sin(theta)+y1 | |
a_pos.append(((xa,ya),(x2,y2))) | |
arrow_collection = LineCollection(a_pos, | |
colors = arrow_colors, | |
linewidths = [4*ww for ww in lw], | |
antialiaseds = (1,), | |
transOffset = ax.transData, | |
) | |
arrow_collection.set_zorder(1) # edges go behind nodes | |
arrow_collection.set_label(label) | |
ax.add_collection(arrow_collection) | |
# update view | |
minx = numpy.amin(numpy.ravel(edge_pos[:,:,0])) | |
maxx = numpy.amax(numpy.ravel(edge_pos[:,:,0])) | |
miny = numpy.amin(numpy.ravel(edge_pos[:,:,1])) | |
maxy = numpy.amax(numpy.ravel(edge_pos[:,:,1])) | |
w = maxx-minx | |
h = maxy-miny | |
padx, pady = 0.05*w, 0.05*h | |
corners = (minx-padx, miny-pady), (maxx+padx, maxy+pady) | |
ax.update_datalim( corners) | |
ax.autoscale_view() | |
# if arrow_collection: | |
return edge_collection | |
def draw_networkx_labels(G, pos, | |
labels=None, | |
font_size=12, | |
font_color='k', | |
font_family='sans-serif', | |
font_weight='normal', | |
alpha=1.0, | |
ax=None, | |
**kwds): | |
"""Draw node labels on the graph G. | |
Parameters | |
---------- | |
G : graph | |
A networkx graph | |
pos : dictionary, optional | |
A dictionary with nodes as keys and positions as values. | |
If not specified a spring layout positioning will be computed. | |
See networkx.layout for functions that compute node positions. | |
labels : dictionary, optional (default=None) | |
Node labels in a dictionary keyed by node of text labels | |
font_size : int | |
Font size for text labels (default=12) | |
font_color : string | |
Font color string (default='k' black) | |
font_family : string | |
Font family (default='sans-serif') | |
font_weight : string | |
Font weight (default='normal') | |
alpha : float | |
The text transparency (default=1.0) | |
ax : Matplotlib Axes object, optional | |
Draw the graph in the specified Matplotlib axes. | |
Examples | |
-------- | |
>>> G=nx.dodecahedral_graph() | |
>>> labels=nx.draw_networkx_labels(G,pos=nx.spring_layout(G)) | |
Also see the NetworkX drawing examples at | |
http://networkx.lanl.gov/gallery.html | |
See Also | |
-------- | |
draw() | |
draw_networkx() | |
draw_networkx_nodes() | |
draw_networkx_edges() | |
draw_networkx_edge_labels() | |
""" | |
try: | |
import matplotlib.pyplot as plt | |
import matplotlib.cbook as cb | |
except ImportError: | |
raise ImportError("Matplotlib required for draw()") | |
except RuntimeError: | |
print("Matplotlib unable to open display") | |
raise | |
if ax is None: | |
ax=plt.gca() | |
if labels is None: | |
labels=dict( (n,n) for n in G.nodes()) | |
# set optional alignment | |
horizontalalignment=kwds.get('horizontalalignment','center') | |
verticalalignment=kwds.get('verticalalignment','center') | |
text_items={} # there is no text collection so we'll fake one | |
for n, label in labels.items(): | |
(x,y)=pos[n] | |
if not cb.is_string_like(label): | |
label=str(label) # this will cause "1" and 1 to be labeled the same | |
t=ax.text(x, y, | |
unicode(label), | |
size=font_size, | |
color=font_color, | |
fontproperties=fontproperties, | |
family=font_family, | |
weight=font_weight, | |
horizontalalignment=horizontalalignment, | |
verticalalignment=verticalalignment, | |
transform = ax.transData, | |
clip_on=True, | |
) | |
text_items[n]=t | |
return text_items | |
def 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=1.0, | |
bbox=None, | |
ax=None, | |
rotate=True, | |
**kwds): | |
"""Draw edge labels. | |
Parameters | |
---------- | |
G : graph | |
A networkx graph | |
pos : dictionary, optional | |
A dictionary with nodes as keys and positions as values. | |
If not specified a spring layout positioning will be computed. | |
See networkx.layout for functions that compute node positions. | |
ax : Matplotlib Axes object, optional | |
Draw the graph in the specified Matplotlib axes. | |
alpha : float | |
The text transparency (default=1.0) | |
edge_labels : dictionary | |
Edge labels in a dictionary keyed by edge two-tuple of text | |
labels (default=None). Only labels for the keys in the dictionary | |
are drawn. | |
label_pos : float | |
Position of edge label along edge (0=head, 0.5=center, 1=tail) | |
font_size : int | |
Font size for text labels (default=12) | |
font_color : string | |
Font color string (default='k' black) | |
font_weight : string | |
Font weight (default='normal') | |
font_family : string | |
Font family (default='sans-serif') | |
bbox : Matplotlib bbox | |
Specify text box shape and colors. | |
clip_on : bool | |
Turn on clipping at axis boundaries (default=True) | |
Examples | |
-------- | |
>>> G=nx.dodecahedral_graph() | |
>>> edge_labels=nx.draw_networkx_edge_labels(G,pos=nx.spring_layout(G)) | |
Also see the NetworkX drawing examples at | |
http://networkx.lanl.gov/gallery.html | |
See Also | |
-------- | |
draw() | |
draw_networkx() | |
draw_networkx_nodes() | |
draw_networkx_edges() | |
draw_networkx_labels() | |
""" | |
try: | |
import matplotlib.pyplot as plt | |
import matplotlib.cbook as cb | |
import numpy | |
except ImportError: | |
raise ImportError("Matplotlib required for draw()") | |
except RuntimeError: | |
print("Matplotlib unable to open display") | |
raise | |
if ax is None: | |
ax=plt.gca() | |
if edge_labels is None: | |
labels=dict( ((u,v), d) for u,v,d in G.edges(data=True) ) | |
else: | |
labels = edge_labels | |
text_items={} | |
for (n1,n2), label in labels.items(): | |
(x1,y1)=pos[n1] | |
(x2,y2)=pos[n2] | |
(x,y) = (x1 * label_pos + x2 * (1.0 - label_pos), | |
y1 * label_pos + y2 * (1.0 - label_pos)) | |
if rotate: | |
angle=numpy.arctan2(y2-y1,x2-x1)/(2.0*numpy.pi)*360 # degrees | |
# make label orientation "right-side-up" | |
if angle > 90: | |
angle-=180 | |
if angle < - 90: | |
angle+=180 | |
# transform data coordinate angle to screen coordinate angle | |
xy=numpy.array((x,y)) | |
trans_angle=ax.transData.transform_angles(numpy.array((angle,)), | |
xy.reshape((1,2)))[0] | |
else: | |
trans_angle=0.0 | |
# use default box of white with white border | |
if bbox is None: | |
bbox = dict(boxstyle='round', | |
ec=(1.0, 1.0, 1.0), | |
fc=(1.0, 1.0, 1.0), | |
) | |
if not cb.is_string_like(label): | |
label=str(label) # this will cause "1" and 1 to be labeled the same | |
# set optional alignment | |
horizontalalignment=kwds.get('horizontalalignment','center') | |
verticalalignment=kwds.get('verticalalignment','center') | |
t=ax.text(x, y, | |
unicode(label), | |
size=font_size, | |
color=font_color, | |
fontproperties=fontproperties, | |
family=font_family, | |
weight=font_weight, | |
horizontalalignment=horizontalalignment, | |
verticalalignment=verticalalignment, | |
rotation=trans_angle, | |
transform = ax.transData, | |
bbox = bbox, | |
zorder = 1, | |
clip_on=True, | |
) | |
text_items[(n1,n2)]=t | |
return text_items | |
def draw_circular(G, **kwargs): | |
"""Draw the graph G with a circular layout.""" | |
draw(G,circular_layout(G),**kwargs) | |
def draw_random(G, **kwargs): | |
"""Draw the graph G with a random layout.""" | |
draw(G,random_layout(G),**kwargs) | |
def draw_spectral(G, **kwargs): | |
"""Draw the graph G with a spectral layout.""" | |
draw(G,spectral_layout(G),**kwargs) | |
def draw_spring(G, **kwargs): | |
"""Draw the graph G with a spring layout.""" | |
draw(G,spring_layout(G),**kwargs) | |
def draw_shell(G, **kwargs): | |
"""Draw networkx graph with shell layout.""" | |
nlist = kwargs.get('nlist', None) | |
if nlist != None: | |
del(kwargs['nlist']) | |
draw(G,shell_layout(G,nlist=nlist),**kwargs) | |
def draw_graphviz(G, prog="neato", **kwargs): | |
"""Draw networkx graph with graphviz layout.""" | |
pos=nx.drawing.graphviz_layout(G,prog) | |
draw(G,pos,**kwargs) | |
def draw_nx(G,pos,**kwds): | |
"""For backward compatibility; use draw or draw_networkx.""" | |
draw(G,pos,**kwds) | |
# fixture for nose tests | |
def setup_module(module): | |
from nose import SkipTest | |
try: | |
import matplotlib as mpl | |
mpl.use('PS',warn=False) | |
import matplotlib.pyplot as plt | |
except: | |
raise SkipTest("matplotlib not available") |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment