def observe():
global initialConditions
global g,estado,f
estado=[]
contadorAgregado=[]
cla()
node_labels={}
cmapMio=creaCmap(5)
for i in g.nodes_iter():
node_labels[i]=g.node[i]['tipo']
nx.draw_networkx (g, k=0.8,node_color = [g.node[i]['tipo'] for i in g.nodes_iter()],
pos = g.pos,cmap=cmapMio, labels=node_labels)
for i in g.nodes_iter():
estado.append(g.node[i]['tipo'])
contador=collections.Counter(estado)
contadorAgregado=[contador[0],contador[1],contador[2]+contador[3],contador[4]]
print contadorAgregado
wr.writerow(contadorAgregado)
if initialConditions == 0:
# Saving data if the simulation, using f defined in initialize()
f.write('Tipo 1' + 'Tipo 2'+'Tipo 3'+'Patogeno' +"\n")
f.write(str(contadorAgregado) +"\n")
f.write('Matrix'+"\n")
initialConditions=1
np.savetxt(f,betaMatrix, fmt='%.4e')
f.close()
def drawFactorGraph(self,var_color='w',factor_color=(.2,.2,.8),**kwargs):
"""Draw a factorgraph using networkx function calls
Args:
var_color (str, tuple): networkx color descriptor for drawing variable nodes
factor_color (str, tuple): networkx color for drawing factor nodes
var_labels (dict): variable id to label string for variable nodes
factor_labels (dict): factor id to label string for factor nodes
``**kwargs``: remaining keyword arguments passed to networkx.draw()
Example:
>>> model.drawFactorGraph( var_labels={0:'0', ... } ) # keyword args passed to networkx.draw()
"""
# TODO: specify var/factor shape,size, position, etc.; return G? silent mode?
import networkx as nx
G = nx.Graph()
vNodes = [v.label for v in self.X if v.states > 1] # list only non-trivial variables
fNodes = [-i-1 for i in range(len(self.factors))] # use negative IDs for factors
G.add_nodes_from( vNodes )
G.add_nodes_from( fNodes )
for i,f in enumerate(self.factors):
for v1 in f.vars:
G.add_edge(v1.label,-i-1)
pos = nx.spring_layout(G) # so we can use same positions multiple times...
kwargs['var_labels'] = kwargs.get('var_labels',{n:n for n in vNodes})
kwargs['labels'] = kwargs.get('var_labels',{})
nx.draw_networkx(G,pos, nodelist=vNodes,node_color=var_color,**kwargs)
kwargs['labels'] = kwargs.get('factor_labels',{}) # TODO: need to transform?
nx.draw_networkx_nodes(G,pos, nodelist=fNodes,node_color=factor_color,node_shape='s',**kwargs)
nx.draw_networkx_edges(G,pos,**kwargs)
return G
def draw(g,vi_map=None,traffic_map=None,events=[],with_labels=False,save=False,filename="out.png"):
pos = {node_id:(g.node[node_id]['data'].lon, g.node[node_id]['data'].lat) for node_id in g.nodes()}
node_color = [(1,1,1) for i in g.nodes() ]
if traffic_map!=None:
for e in events:
mesh_node = e.path[ e.pos ]
if e.status == te.TrafficEvent.RUNNING:
# print "PAINTING",e.id, e.pos, e.path[ e.pos ], g.nodes()[ e.path[ e.pos ] ]
blue = math.floor(e.last_5_avg_speed)/2.0
if blue>1:
blue = 1
red=0
if blue<1/20.0:
red = 1-10*blue
node_color[ mesh_node ] = (red,0,blue)
elif e.status == te.TrafficEvent.FINISHED:
node_color[ mesh_node ] = (1,1,1)
fig = plt.figure(frameon=False,dpi=90)
ax = fig.add_axes( [0,0,2,2])
ax.axis('off')
nx.draw_networkx(g,pos=pos,arrows=False,node_size=18,with_labels=with_labels,linewidths=0.2,node_color=node_color,vmin=0,vmax=10)
if save:
plt.savefig(filename,dpi=70,bbox_inches='tight')
else:
plt.show()
plt.close(fig)
def initialize():
G.add_node("A")
G.add_node("B")
G.add_node("C")
G.add_node("D")
G.add_node("E")
G.add_node("F")
labels = {k: k for k in G.nodes()}
G.add_edge("A", "F", weight=1)
G.add_edge("A", "E", weight=3)
G.add_edge("A", "C", weight=4)
G.add_edge("F", "B", weight=3)
G.add_edge("F", "E", weight=2)
G.add_edge("B", "D", weight=3)
G.add_edge("B", "E", weight=2)
G.add_edge("E", "D", weight=4)
G.add_edge("E", "C", weight=2)
G.add_edge("C", "D", weight=1)
labels = nx.get_edge_attributes(G, "weight")
plt.title("Single-Router Network")
nx.draw(G, pos=nx.spectral_layout(G))
nx.draw_networkx(G, with_labels=True, pos=nx.spectral_layout(G))
nx.draw_networkx_edge_labels(G, pos=nx.spectral_layout(G), edge_labels=labels)
plt.show()
def draw(inF):
G = nx.Graph()
inFile = open(inF)
S = set()
for line in inFile:
line = line.strip()
fields = line.split('\t')
for item in fields:
S.add(item)
inFile.close()
L = list(S)
G.add_nodes_from(L)
LC = []
for x in L:
if x == 'EGR1' or x == 'RBM20':
LC.append('r')
else:
LC.append('w')
inFile = open(inF)
for line in inFile:
line = line.strip()
fields = line.split('\t')
for i in range(len(fields)-1):
G.add_edge(fields[i], fields[i+1])
inFile.close()
nx.draw_networkx(G,pos=nx.spring_layout(G), node_size=800, font_size=6, node_color=LC)
limits=plt.axis('off')
plt.savefig(inF + '.pdf')
def draw(self):
positions = {}
Tree.get_positions(self, positions, x=(0, 10), y=(0, 10))
g = self.to_graph()
plt.axis('on')
nx.draw_networkx(g, positions, node_size=1500, font_size=24, node_color='g')
plt.show()
def reactionCenter(filename): # in this method, g2 do not need to be subgraph of g1 mcs = fmcsWithPath(filename=filename) # print(mcs['content1']) # print(mcs['content2']) # print(mcs['contentmcs']) # g1 = input_chem_content(mcs['content1'], 'g1') g1 = graphFromSDF(StringIO(mcs['content1']))[0] print g1.node # nx.draw_networkx(g1) # pyplot.show( ) # g2 = input_chem_content( mcs['content2'], 'g2' ) g2 = graphFromSDF( StringIO( mcs['content2'] ) )[0] print g2.node # nx.draw_networkx( g2) # pyplot.show( ) # gmcs = input_chem_content(mcs['contentmcs'], 'g2') gmcs = graphFromSDF( StringIO( mcs['contentmcs'] ) )[0] nx.draw_networkx(gmcs) pyplot.show() print getReactionCenter(g1, gmcs)
def showbgraph(event):
ax.clear()
setp(ax, xticks=[], yticks=[])
layout = radio_layout.layout
NX.draw_networkx(G, layout, alpha=0.1, labels={})
NX.draw_networkx(BG, layout, node_color='y')
draw()
def draw_graph(self, G, node_list=None, edge_colour='k', node_size=15, node_colour='r', graph_type='spring',
back_bone=None, side_chains=None, terminators=None):
# determine nodelist
if node_list is None:
node_list = G.nodes()
# determine labels
labels = {}
for l_atom in G.nodes_iter():
labels[l_atom] = l_atom.symbol
# draw graphs based on graph_type
if graph_type == 'circular':
nx.draw_circular(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
elif graph_type == 'random':
nx.draw_random(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
elif graph_type == 'spectral':
nx.draw_spectral(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
elif graph_type == 'spring':
nx.draw_spring(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
elif graph_type == 'shell':
nx.draw_shell(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
# elif graph_type == 'protein':
# self.draw_protein(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
# edge_color=edge_colour, node_color=node_colour, back_bone, side_chains, terminators)
else:
nx.draw_networkx(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size,
edge_color=edge_colour, node_color=node_colour)
plt.show()
def make_tree_figure(wanted_seqs, trop_dict, tree_file):
mat_data = get_pairwise_distances(wanted_seqs, tree_file = tree_file)
tree = Phylo.read(open(tree_file), 'newick')
net = Phylo.to_networkx(tree)
node_mapping = {}
clade = 1
for node in net.nodes():
if node.name is None:
node_mapping[node] = 'Clade-%i' % clade
clade += 1
else:
node_mapping[node] = node.name
new_net = networkx.relabel_nodes(net, node_mapping)
colors = []
for node in new_net.nodes():
if node.startswith('Clade'):
colors.append('w')
elif trop_dict[node]:
colors.append('g')
elif not trop_dict[node]:
colors.append('r')
else:
print node
#print colors, len(colors), len(new_net.nodes())
pos = networkx.graphviz_layout(new_net, 'twopi')
networkx.draw_networkx(new_net, pos, with_labels = False, node_color = colors)
def graph_show(graph, font_size=12):
pylab.rcParams['figure.figsize'] = (16.0, 12.0)
try:
nx.draw_networkx(graph,pos=nx.spring_layout(graph), node_size=6, alpha=0.1, font_size=font_size)
except:
print 'umm'
pylab.rcParams['figure.figsize'] = (10.0, 4.0)
def laucher(graph, mininet_config, draw_mpl=False, write_gexf=False):
"""
Launch the miniCPS SWaT simulation
:graph: networkx graph
:mininet_config: function pointer to the mininet configuration
:draw_mpl: flag to draw and save the graph using matplotlib
"""
# TODO: use different color for plcs, switch and attacker
if draw_mpl:
nx.draw_networkx(graph)
plt.axis('off')
# plt.show()
plt.savefig("examples/swat/%s.pdf" % graph.name)
if write_gexf:
g_gexf = nx.write_gexf(graph, "examples/swat/l1_gexf.xml")
# g2 = nx.read_gexf("examples/swat/g_gexf.xml")
# Build miniCPS topo
topo = TopoFromNxGraph(graph)
controller = POXSwat
net = Mininet(
topo=topo,
controller=controller,
link=TCLink,
listenPort=6634)
mininet_config(net)
def observe():
global initialConditions
global g,estado,f,numNodos,numTipoNodos
estado=[]
contadorAgregado=[]
cla()
node_labels={}
cmapMio=creaCmap(4)
for i in g.nodes_iter():
node_labels[i]=g.node[i]['tipo']
nx.draw_networkx (g, k=0.8,node_color = [g.node[i]['tipo'] for i in g.nodes_iter()],
pos = g.pos,cmap=cmapMio, labels=node_labels)
for i in g.nodes_iter():
estado.append(g.node[i]['tipo'])
contador=collections.Counter(estado)
contadorAgregado=contador.values()
wr.writerow(contadorAgregado)
print contadorAgregado
if initialConditions == 0:
# Saving data used in simulation, using f of file defined in initialize()
f.write('GRID de ')
f.write(str(numNodos)+"\n y tipos de nodos: ")
f.write(str(numTipoNodos)+"\n")
f.write(str(contadorAgregado) +"\n")
f.write('Matrix'+"\n")
initialConditions=1
np.savetxt(f,betaMatrix, fmt='%.4e')
f.close()
def plot(self,figure):
changed = False
for ip in self.stats:
if ip is not "127.0.0.1" and not self.graph.has_node(ip):
self.graph.add_node(ip,node_size=4000,node_shape="s")
self.graph.add_edge(ip,"127.0.0.1",attr_dict={"label":"N/A"})
changed = True
for port in self.stats[ip]:
#pnode = ip + ":" + port
pnode = port
if not self.graph.has_node(pnode):
statName = ip + ":" + port
self.graph.add_node(pnode,attr_dict={"node_size":700,"node_shape":"o","font_size":8})
self.graph.add_edge(pnode ,ip, attr_dict={"label":"N/A"})
changed = True
if changed:
figure.clf()
pos = nx.spring_layout(self.graph, weight=None, iterations=100, scale = 2)
#draw ip nodes
ipNodeList = list(self.stats)
#print(ipNodeList)
try:
nx.draw_networkx(self.graph,
nodelist = ipNodeList,
pos = pos,
with_labels = True,
node_size = 4000 ,
node_shape = "p",
font_size = 8
)
except nx.exception.NetworkXError: # catch some error about a node not having a position yet (we just re-render, that does it)
pass
#draw port nodes
portList = list(self.stats.values())
portNodesList = [ item for sublist in (list(e) for e in portList) for item in sublist ]
try:
nx.draw_networkx_nodes(self.graph,
nodelist = portNodesList,
pos = pos ,
with_labels = True,
node_size = 700 ,
node_shape = "o",
font_size=8
)
edges = self.graph.edges(data=True)
labels = {}
for (a, b, *c) in edges:
stats = "N/A"
if a in self.stats:
if b in self.stats[a]:
labels[a,b] = self.stats[a][b]
else:
if a in self.stats[b]:
labels[b,a] = self.stats[b][a]
nx.draw_networkx_edge_labels(self.graph, pos = pos, edge_labels=labels,ax=None)
except nx.exception.NetworkXError: # catch some error about a node not having a position yet (we just re-render, that does it)
pass
# draw connStats
statNodesList = list(self.statNodes)
figure.canvas.draw()
def create_simple_graph(self,name):
import networkx as nx
G=nx.Graph()
for i,r in enumerate(self.reslist):
G.add_node(i+1,name=r.name)
print G.nodes()
h = self.hbond_matrix()
nr = numpy.size(h,0)
for i in range(nr):
for j in range(i+1,nr):
if GenericResidue.touching(self.reslist[i], self.reslist[j],2.8):
print 'adding edge',i+1,j+1
G.add_edge(i+1,j+1,name="special")
# pos0=nx.spectral_layout(G)
# pos=nx.spring_layout(G,iterations=500,pos=pos0)
# pos=nx.spring_layout(G,iterations=500)
# nx.draw_shell(G)
pos0=nx.spectral_layout(G)
pos=nx.spring_layout(G,iterations=500,pos=pos0)
# pos=nx.graphviz_layout(G,root=1,prog='dot')
# nx.draw(G)
nx.draw_networkx(G,pos)
plt.axis('off')
plt.savefig(name)
def calc_clustering_coefficient(g, dest_file):
"""
calc_clustering_coefficient(g)
Calculate & plot clustering coefficient of the graph g and writes data to the created data output file
:param g: graph as source
:return: ---
"""
func_intro = "\n\nClustering Co-Efficient ..."
logging.info(cs_ref, func_intro)
print func_intro
with open(dest_file, "a") as dat_file:
dat_file.write(func_intro)
cce = nx.clustering(g) # calculate clustering co-efficient
with open(dest_file, "a") as dat_file:
dat_file.write("\n\tClustering Coefficients for nodes in graph = \t" + str(cce))
average_cce = nx.average_clustering(g)
with open(dest_file, "a") as dat_file:
dat_file.write("\n\tAverage Clustering Coefficient for graph = \t" + str(average_cce))
for edge in g.edges(): # plot clustering co-efficient
if floor(edge[0] / 5.) != floor(edge[1] / 5.):
if random.random() < 0.95:
g.remove_edge(edge[0], edge[1])
plt.figure(3)
fixed_pos = {1: (0, 0), 10: (1, 1), 30: (1, 0), 50: (0, 1)}
pos = nx.spring_layout(g, fixed=fixed_pos.keys(), pos=fixed_pos)
nx.draw_networkx(g, pos=pos)
plt.title("Clustering Co-efficient" + src_file)
plt.savefig("plots/cs1_clustering_coefficient.png")
plt.show()
def drawgraph(self,path,nodelist):
color = {}
graph = nx.Graph()
for item in nodelist:
graph.add_node(item.key.decode('utf-8'))
if item.key in path.split('->'):
color[item.key.decode('utf-8')] = 'green'
for item in nodelist:
if item.path == '':
continue
s = item.path.split('->')
for i in range(0,len(s) - 1):
if i == 0:
continue
graph.add_edge(s[i].decode('utf-8'),s[i+1].decode('utf-8'))
values = [color.get(node,'red') for node in graph.nodes() ]
pos = nx.spring_layout(graph)
if len(nodelist) > 500:
nx.draw_networkx(graph,font_family='SimHei', node_size=50,node_color=values, font_size = 5)
else:
nx.draw_networkx(graph,font_family='SimHei', node_size=1000,node_color=values, font_size = 10)
plt.savefig('HSearch.png')
plt.close()
return None
def strongly_connected_components():
conn = sqlite3.connect("zhihu.db")
#following_data = pd.read_sql('select user_url, followee_url from Following where followee_url in (select user_url from User where agree_num > 50000) and user_url in (select user_url from User where agree_num > 50000)', conn)
following_data = pd.read_sql('select user_url, followee_url from Following where followee_url in (select user_url from User where agree_num > 10000) and user_url in (select user_url from User where agree_num > 10000)', conn)
conn.close()
G = nx.DiGraph()
cnt = 0
for d in following_data.iterrows():
G.add_edge(d[1][0],d[1][1])
cnt += 1
print 'links number:', cnt
scompgraphs = nx.strongly_connected_component_subgraphs(G)
scomponents = sorted(nx.strongly_connected_components(G), key=len, reverse=True)
print 'components nodes distribution:', [len(c) for c in scomponents]
#plot graph of component, calculate saverage_shortest_path_length of components who has over 1 nodes
index = 0
print 'average_shortest_path_length of components who has over 1 nodes:'
for tempg in scompgraphs:
index += 1
if len(tempg.nodes()) != 1:
print nx.average_shortest_path_length(tempg)
print 'diameter', nx.diameter(tempg)
print 'radius', nx.radius(tempg)
pylab.figure(index)
nx.draw_networkx(tempg)
pylab.show()
# Components-as-nodes Graph
cG = nx.condensation(G)
pylab.figure('Components-as-nodes Graph')
nx.draw_networkx(cG)
pylab.show()
def print_graph(self, special_nodes):
G = nx.Graph()
self.get_graph(self.root, G)
poss = hierarchy_pos(G, self.root.val[1])
nx.draw_networkx(G, pos=poss, default=True, node_color='y')
plt.show()
def savefig(col):
global idx
pylab.clf()
#from pcd.support.matplotlibutil import get_axes, save_axes
#ax, extra = get_axes('/home/darstr1/proj/tmp-img/%05d.png'%0)
#print ax
nx.draw_networkx(g, pos=pos,
node_list=g.nodes(),
node_color=[col[n] for n in g.nodes()],
with_labels=False)
#save_axes(ax, extra)
fig = pylab.gcf()
ax = pylab.gca()
dpi = fig.dpi
bbox = ax.collections[0].get_window_extent(fig)
from matplotlib.transforms import TransformedBbox, Affine2D
bbox2 = TransformedBbox(bbox, Affine2D().scale(1. / dpi))
bbox._points[0] -= .15 * dpi
bbox._points[1] += .15 * dpi
ax = pylab.gca()
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
pylab.savefig('/home/darstr1/proj/tmp-imgs/%05d.png'%idx,
bbox_inches=bbox2)
idx += 1
def pagerank_hits():
conn = sqlite3.connect("zhihu.db")
#following_data = pd.read_sql('select user_url, followee_url from Following where followee_url in (select user_url from User where agree_num > 50000) and user_url in (select user_url from User where agree_num > 50000)', conn)
following_data = pd.read_sql('select user_url, followee_url from Following where followee_url in (select user_url from User where agree_num > 10000) and user_url in (select user_url from User where agree_num > 10000)', conn)
conn.close()
G = nx.DiGraph()
cnt = 0
for d in following_data.iterrows():
G.add_edge(d[1][0],d[1][1])
cnt += 1
print 'links number:', cnt
pylab.figure(0)
nx.draw_networkx(G)
pylab.show()
# PageRank
pr = nx.pagerank(G)
prsorted = sorted(pr.items(), key=lambda x: x[1], reverse=True)
print 'pagerank top 100:\n'
for p in prsorted[:100]:
print p[0], p[1]
# HITS
hub, auth = nx.hits(G)
print 'hub top 100:\n'
for h in sorted(hub.items(), key=lambda x: x[1], reverse=True)[:100]:
print h[0], h[1]
print '\nauth top 100:\n'
for a in sorted(auth.items(), key=lambda x: x[1], reverse=True)[:100]:
print a[0], a[1]
def main():
G_igraph, G_nx, nodes_vector = generate_data()
aca0, aca1 = separate_data_by_academy(nodes_vector, G_nx)
print aca0.nodes()
print aca1.nodes()
plt.subplot(121)
nx.draw_networkx(
G=aca0,
pos=nx.spring_layout(aca0),
with_labels=True,
node_color='g',
edge_color='b',
alpha=1)
plt.axis('off')
plt.subplot(122)
nx.draw_networkx(
G=aca1,
pos=nx.spring_layout(aca1),
with_labels=True,
node_color='g',
edge_color='b',
alpha=1)
plt.axis('off')
plt.show()
def draw_graph(graph):
# extract nodes from graph
nodes = set([n1 for n1, n2 in graph] + [n2 for n1, n2 in graph])
# create networkx graph
G=nx.Graph()
#G=nx.cubical_graph()
# add nodes
for node in nodes:
G.add_node(node)
# add edges
for edge in graph:
G.add_edge(edge[0], edge[1])
# draw graph
#pos = nx.shell_layout(G)
#pos = nx.spectral_layout(G)
pos = nx.random_layout(G) # Funciona melhor
#pos = nx.circular_layout(G) # Mais ou menos
#pos = nx.fruchterman_reingold_layout(G) # Funciona melhor
#nx.draw(G, pos)
nx.draw_networkx(G)
# show graph
plt.axis('off')
plt.show()
def draw(self):
"""
Draw a network graph of the employee relationship.
"""
if self.graph is not None:
nx.draw_networkx(self.graph)
plt.show()
def tree_width(nxg,i): maxsize=1000000000 junction_tree=nx.Graph() max_junction_tree_node=junction_tree all_subgraphs=create_all_subgraphs(nxg.edges(),i) print "All subgraphs:",all_subgraphs print "============================================" for k0 in all_subgraphs: for k1 in all_subgraphs: hash_graph_k0 = hash_graph(k0) hash_graph_k1 = hash_graph(k1) if (hash_graph_k0 != hash_graph_k1) and len(set(k0).intersection(set(k1))) > 0: junction_tree.add_edge(hash_graph_k0,hash_graph_k1) if len(k0) < maxsize: max_junction_tree_node=k0 maxsize = len(k0) if len(k1) < maxsize: max_junction_tree_node=k1 maxsize = len(k1) print "============================================" print "Junction Tree (with subgraphs of size less than",i,") :" nx.draw_networkx(junction_tree) plt.show() print "============================================" print "Junction Tree Width for subgraphs of size less than ",i," - size of largest node set:",maxsize
def plot_osm_network(G,node_size=10,with_labels=False,ax=None):
plt.figure()
pos = {}
for n in G.nodes():
pos[n] = (G.node[n].lon, G.node[n].lat)
nx.draw_networkx(G,pos,node_size=node_size,with_labels=with_labels,ax=ax)
plt.show()
def create_networkx(node_list, edge_list, args):
graph = nx.Graph()
print 'Initializing'
size_list = []
clean_node_list = []
for item in node_list:
nodesize = 300
for edge in edge_list:
if item == edge[1]:
nodesize += 100
size_list.append(nodesize)
clean_node_list.append(os.path.basename(item))
graph.add_nodes_from(clean_node_list)
print 'Nodes set'
for item in edge_list:
from_node = os.path.basename(item[1])
to_node = os.path.basename(item[0])
graph.add_edge(from_node, to_node)
print 'Edges set'
print 'Creating Graph'
position = nx.spring_layout(graph)
for item in position:
position[item] *= 10
nx.draw_networkx(graph,
pos=position,
font_size=10,
node_size=size_list)
print 'Drawing Graph'
plt.show()
print 'DONE'
def draw_basic_network(G,src_list):
slpos = nx.spring_layout(G) # see this for a great grid layout [1]
nx.draw_networkx(G, pos=slpos, node_color='b', nodelist=src_list, with_labels=False,node_size=20, \
edge_color='#7146CC')
nx.draw_networkx_nodes(G, pos=slpos, node_color='r', nodelist=[x for x in G.nodes() if x not in src_list], \
alpha=0.8, with_labels=False,node_size=20)
plt.savefig('figures/basicfig', bbox_inches='tight', pad_inches=0)
def draw_geograph(g, node_color='r', edge_color='b', node_label_field=None,
edge_label_field=None, node_size=200, node_label_x_offset=0,
node_label_y_offset=0, node_label_font_size=12,
node_label_font_color='k'):
"""
Simple function to draw a geograph via matplotlib/networkx
Uses geograph coords (projects if needed) as node positions
"""
# transform to projected if not done so
flat_coords = g.transform_coords(gm.PROJ4_FLAT_EARTH)
node_pos = {nd: flat_coords[nd] for nd in g.nodes()}
label_pos = {nd: [flat_coords[nd][0] + node_label_x_offset,
flat_coords[nd][1] + node_label_y_offset]
for nd in g.nodes()}
# Draw nodes
nx.draw_networkx(g, pos=node_pos, node_color=node_color,
with_labels=False, edge_color=edge_color, node_size=node_size)
if node_label_field:
if node_label_field != 'ix':
label_vals = nx.get_node_attributes(g, node_label_field)
nx.draw_networkx_labels(g, label_pos, labels=label_vals,
font_size=node_label_font_size, font_color=node_label_font_color)
else: # label via ids
nx.draw_networkx_labels(g, label_pos, labels=g.nodes(),
font_size=node_label_font_size, font_color=node_label_font_color)
# handle edge labels if needed
if edge_label_field:
edge_labels = nx.get_edge_attributes(g, edge_label_field)
nx.draw_networkx_edge_labels(g, pos=node_pos, edge_labels=edge_labels)
def doGraph(self,G,labels):
pos = Plotter.hierarchical_layout(G)
xs = map(lambda x:pos[x][0],pos)
ys = map(lambda x:pos[x][0],pos)
P.axis([min(xs)-0.1,
max(xs)+0.1,
min(ys)-0.1,
max(ys)+0.1])
P.subplots_adjust(left=0,
right=1,
bottom=0,
top=0.9)
NX.draw_networkx(G, pos, font_size=8, labels=labels, edge_color='g')
if labels:
for (a,b,c) in G.edges():
# the shorter line, the closer to lower node
ax,ay=pos[a]
bx,by=pos[b]
l = ((ax-bx)**2+(ay-by)**2)**0.5
ra = 1/(l+1)
rb = l/(l+1)
x=(ra*ax+rb*bx)
y=(ra*ay+rb*by)
P.text(x,y,c.type,
size=8,
horizontalalignment='center',
verticalalignment='center',
multialignment='left')
refill = 200
v_low = 30
v_high = 50
times = 1000
random_n_list = list(itertools.product(range(0, g_side), range(0, g_side)))
locations_set = random.sample(random_n_list, locations_count + 1)
g_los = locations_set
po = g_los[0]
G = nx.grid_2d_graph(g_side, g_side)
pos = dict((n, n) for n in G.nodes())
labels = dict(((i, j), i * 0 + j * 0) for i, j in G.nodes())
nx.draw_networkx(G, pos=pos, labels=labels, node_color="r", node_size=0)
list2 = []
for index in range(0, len(g_los)):
list2.append(index)
posiList = dict(zip(list2, g_los))
#print(posiList)
g_overload_set = [
random.randint(v_low, v_high) for _ in range(locations_count)
]
location_overload_set = dict(zip(g_los[1:], g_overload_set))
nx.draw_networkx_nodes(G,
posiList,
def draw(g):
pos = nx.shell_layout(g)
nx.draw_networkx(g, pos)
ax.axis('equal')
pieBigramWords, _, _ = ax.pie(list(df_bigramMostCommon20['frequency']),
radius=1.3,
labels=list(
df_bigramMostCommon20['bigramWords']),
autopct='%1.2f%%')
plt.setp(pieBigramWords, width=0.3, edgecolor='white')
plt.show()
#graph of bigram words from tweets
graphOfWords = nx.Graph()
for k, v in df_bigramMostCommon20Dict[0].items():
print(k[0], '-->', k[1])
graphOfWords.add_edge(k[0], k[1], weight=(v * 10))
graphOfWords.add_node("Airline", weight=100)
fig, ax = plt.subplots(figsize=(10, 10))
position = nx.spring_layout(graphOfWords, k=1)
nx.draw_networkx(graphOfWords, position, ax=ax, with_labels=False)
for key, value in position.items():
x, y = value[0] + 0.025, value[1] + 0.05
ax.text(x,
y,
s=key,
bbox=dict(facecolor='yellow', alpha=0.25),
horizontalalignment='center',
fontsize=12)
plt.show()
p_quit=lmbda,
n_iteration=20,
remove_totters=False,
n_jobs=multiprocessing.cpu_count(),
verbose=False)
dnew = knew[0][
0, 0] - 2 * (alpha * knew[0][0, 1] +
(1 - alpha) * knew[0][0, 2]) + (
alpha * alpha * k_list[idx1] + alpha *
(1 - alpha) * k_g2_list[idx1] +
(1 - alpha) * alpha * k_g1_list[idx2] +
(1 - alpha) * (1 - alpha) * k_list[idx2])
if dnew <= dhat: # the new distance is smaller
print('I am smaller!')
dhat = dnew
gnew = gtemp.copy()
found = True # found better graph.
r = 0
if found:
gihat_list = [gnew]
dis_gs.append(dhat)
else:
r += 1
dis_best.append(dhat)
g_best += ([g0hat] if len(gihat_list) == 0 else gihat_list)
for idx, item in enumerate(alpha_range):
print('when alpha is', item, 'the shortest distance is', dis_best[idx])
print('the corresponding pre-image is')
nx.draw_networkx(g_best[idx])
plt.show()
def plot(self,
path=None,
fig=None,
plotTitle=None,
baseSize=400,
node_size=10,
showLabels=True,
showEdgeWeights=True,
showAxes=True):
if not fig:
fig = plt.figure()
# scale node sizes by string length only if all node labels are strings
allStrs = bool(self.nodes()) and all(
isinstance(elem, str) for elem in self.nodes())
pos = nx.get_node_attributes(self, 'pos')
if allStrs:
node_size = [len(v) * baseSize for v in self.nodes()]
nx.draw_networkx(self,
pos=pos,
with_labels=showLabels,
node_size=node_size)
else:
nx.draw_networkx(self,
pos=pos,
with_labels=showLabels,
node_size=node_size,
cmap=plt.get_cmap('jet'))
# show edge weights as well
if showEdgeWeights:
labels = nx.get_edge_attributes(self, 'weight')
nx.draw_networkx_edge_labels(self, pos, edge_labels=labels)
# draw path through the graph if it exists
if path:
nx.draw_networkx_nodes(self,
pos,
nodelist=path,
node_color='r',
node_size=node_size)
path_edges = self.getPathEdges(path)
nx.draw_networkx_edges(self,
pos,
edgelist=path_edges,
edge_color='r',
width=4)
# Axes settings
ax = plt.gca()
ax.set_title(plotTitle)
if showAxes:
ax.tick_params(left=True,
bottom=True,
labelleft=True,
labelbottom=True)
else:
[sp.set_visible(False) for sp in ax.spines.values()]
ax.set_xticks([])
ax.set_yticks([])
return (fig, ax)
def plot_centroids(
self,
adata,
use_rep,
obs_col="leiden",
ctr_size=300,
pt_size=75,
draw_edges=True,
highlight_edges=False,
save_to=None,
):
"""
General plotting function for cluster centroid graph and MST
(i.e. from "leiden" or "louvain") and cute arrows and labels
Parameters
----------
adata : anndata.AnnData
object to pull dimensionality reduction from
use_rep : str
`adata.obsm` key to plot from (i.e. "X_pca")
obs_col : str, optional (default="leiden")
name of column in `adata.obs` to use as cell IDs (i.e. "leiden")
ctr_size : float, optional (default=300)
size of centroid points in plot
pt_size : float, optional (default=75)
size of points in plot
draw_edges : bool, optional (default=True)
draw edges of minimum spanning tree between all centroids
highlight_edges : list of int, optional (default=False)
list of edge IDs as tuples to highlight in red on plot. e.g.
`set(adata.uns['X_tsne_centroid_MST'].edges).difference(set(adata.uns['X_umap_centroid_MST'].edges))`
with output {(0,3), (0,7)} says that edges from centroid 0 to 3 and 0 to 7
are found in 'X_tsne_centroids' but not in 'X_umap_centroids'. highlight
the edges to show this.
save_to : str, optional (default=None)
path to `.png` file to save output. do not save if None
Returns
-------
`self.fig`, `self.ax` edited; plot saved to `.png` file if `save_to` is not
None
"""
clu_names = adata.obs[obs_col].unique().astype(str)
# use existing scanpy colors, if applicable
if obs_col == "leiden" and "leiden_colors" in adata.uns.keys():
colors = [
adata.uns["leiden_colors"][x]
for x in adata.obs.leiden.unique().astype(int)
]
elif obs_col == "louvain" and "louvain_colors" in adata.uns.keys():
colors = [
adata.uns["louvain_colors"][x]
for x in adata.obs.louvain.unique().astype(int)
]
# otherwise, get new color mapping from obs_col using self.cmap
else:
colors = self.cmap(np.linspace(0, 1, len(clu_names)))
# draw points in embedding first
sns.scatterplot(
x=adata.obsm[use_rep][:, 0],
y=adata.obsm[use_rep][:, 1],
ax=self.ax,
s=pt_size,
alpha=0.1,
color="gray",
legend=False,
edgecolor="none",
)
# draw MST edges if desired, otherwise just draw centroids
if not draw_edges:
self.ax.scatter(
x=adata.uns["{}_centroids".format(use_rep)][:, 0],
y=adata.uns["{}_centroids".format(use_rep)][:, 1],
s=ctr_size,
c=colors,
edgecolor="none",
)
else:
pos = dict(
zip(clu_names,
adata.uns["{}_centroids".format(use_rep)][:, :2]))
nx.draw_networkx(
adata.uns["{}_centroid_MST".format(use_rep)],
pos=pos,
ax=self.ax,
with_labels=False,
width=2,
node_size=ctr_size,
node_color=colors,
)
# highlight edges if desired
if highlight_edges:
nx.draw_networkx_edges(
adata.uns["{}_centroid_MST".format(use_rep)],
pos=pos,
ax=self.ax,
edgelist=highlight_edges,
width=5,
edge_color="red",
)
if save_to is None:
return
else:
plt.savefig(fname=save_to,
transparent=True,
bbox_inches="tight",
dpi=1000)
dev_ourense = qml.device("qiskit.ibmq", wires=5, backend="ibmq_ourense")
##############################################################################
#
# First, we can take a look at the arrangement of the qubits on the processor
# by plotting its hardware graph.
import matplotlib.pyplot as plt
import networkx as nx
ourense_hardware_graph = nx.Graph(
dev_ourense.backend.configuration().coupling_map)
nx.draw_networkx(
ourense_hardware_graph,
node_color="cyan",
labels={x: x
for x in range(dev_ourense.num_wires)},
)
##############################################################################
#
# .. figure:: ../demonstrations/quantum_volume/ourense.svg
# :align: center
# :width: 75%
#
##############################################################################
#
# This hardware graph is not fully connected, so the quantum compiler will have
# to make some adjustments when non-connected qubits need to interact.
#
######################## FUNÇÃO PRINCIPAL ###########################
arquivo = open('grafo2', 'r')
nvertices = int(arquivo.readline())
vertices = tuple(arquivo.readline().split())
narestas = int(arquivo.readline())
lista_arestas = []
for i in range(narestas):
lista_arestas.append(arquivo.readline().strip().replace(' ', ''))
grafo = nx.Graph()
grafo.add_nodes_from(vertices)
grafo.add_edges_from(lista_arestas)
profundidade = busca_profundidade(grafo)
print("--> Algoritmo DFS")
imprimir(profundidade)
print()
print()
print('=================================================')
print()
print("--> Algoritmo BFS")
largura = (busca_largura(grafo))
imprimir(largura)
nx.draw_networkx(grafo,
with_labels=True,
pos=nx.planar_layout(grafo),
node_color='r',
edge_color='b')
plt.show()
def visualizarGrafo(arr):
G = nx.Graph()
G.add_edges_from(arr)
nx.draw_networkx(G)
plt.show()
def draw_graph(G):
'''
Draws networkx graph G
'''
nx.draw_networkx(G)
plt.show()
return heuristics
heuristics = getHeuristics(G)
node_pos = nx.get_node_attributes(G, 'pos')
#call BFS to return set of all possible routes to the goal
route_bfs = GBfsTraverser()
routes = route_bfs.GBFS(G, heuristics, "SportsComplex", "ParkingLot")
route_list = route_bfs.path
#color the nodes in the route_bfs
node_col = [
'darkturquoise' if not node in route_list else 'peru'
for node in G.nodes()
]
peru_colored_edges = list(zip(route_list, route_list[1:]))
#color the edges as well
#print(peru_colored_edges)
edge_col = [
'darkturquoise' if not edge in peru_colored_edges else 'peru'
for edge in G.edges()
]
arc_label = nx.get_edge_attributes(G, 'label')
nx.draw_networkx(G, node_pos, node_color=node_col, node_size=450)
nx.draw_networkx_edges(G, node_pos, width=5, edge_color=edge_col)
#nx.draw_networkx_edge_labels(G, node_pos,edge_color= edge_col, edge_labels=arc_weight)
nx.draw_networkx_edge_labels(G, node_pos, edge_labels=arc_label)
plt.axis('off')
plt.show()
[0, 1, 1, 0],
[0, 1, 1, 1],
[0, 1, 1, 0],
[1, 0, 1, 1],
[1, 0, 0, 0],
]
distribution = Distribution(samples)
distribution._generate_bayes_net()
for node_ind in distribution.bayes_net.nodes():
print(distribution.bayes_net.node[node_ind])
pos = nx.spring_layout(distribution.spanning_graph)
edge_labels = dict([((
u,
v,
), d['weight']) for u, v, d in distribution.spanning_graph.edges(data=True)
])
nx.draw_networkx(distribution.spanning_graph, pos)
nx.draw_networkx_edge_labels(
distribution.spanning_graph,
pos,
edge_labels=edge_labels,
)
plt.show()
del nodes[k]
k += 1
##
pos = nx.spring_layout(H, iterations = 1000)
nx.draw_networkx_nodes(H, pos, nodelist = ['U19886'], node_color = 'r', node_size = 20)
nx.draw_networkx_nodes(H, pos, nodelist = nodes, node_color = 'b', node_size = 20)
nx.draw_networkx_nodes(H, pos, nodelist = google_employees, node_color = 'g', node_size = 20)
nx.draw_networkx_edges(H, pos)
plt.axis('off')
plt.show()
# On voit que le no U7091 est un fdp
##
nx.draw_networkx(H, pos, node_size = 20, font_size = 9)
plt.show()
##
nodes1 = list(G.nodes)
k=0
while k < len(nodes1):
if nodes1[k] == 'U7091':
del nodes1[k]
k += 1
P = G.subgraph(nodes1)
Q, offset = model.to_qubo()
bqm = dimod.BinaryQuadraticModel.from_qubo(Q, offset=offset)
# Need to relabel variables for the first figure
bqm2 = bqm.relabel_variables({curr: v
for v, curr in enumerate(bqm.variables)},
inplace=False)
# Do the embedding
dwave_sampler = DWaveSampler()
A = dwave_sampler.edgelist
embedding = find_embedding(Q, A)
# Draw the QUBO as a networkx graph
G = bqm2.to_networkx_graph()
pos = nx.spring_layout(G)
nx.draw_networkx(G, pos=pos, font_size=10, node_size=150)
plt.show()
# Draw the embedded graph
G = dnx.chimera_graph(16, 16, 4)
dnx.draw_chimera_embedding(G,
embedding,
embedded_graph=bqm.to_networkx_graph(),
unused_color=None)
plt.show()
clique_embedding = find_clique_embedding(N, 16, 16, 4, A)
dnx.draw_chimera_embedding(G, clique_embedding, unused_color=None)
plt.show()
def plot_paths(paths_data,
G,
mode=None,
save_graph=False,
show_graph=True,
layout_seed=None,
draw_edge_weights=False):
"""Plots the graph and all the generated paths (up to 8) in spring_layout."""
utils.verify_paths(paths_data)
if mode is None:
mode = {}
if save_graph:
figsize = (10 * 1.8, 10)
dpi = 200
title_fontsize = 22
legend_fontsize = 20
else:
figsize = (8 * 1.8, 8)
dpi = 100
title_fontsize = 18
legend_fontsize = 16
# path_nodes_pos = [
# (1, -1),
# (0.7, -0.1),
# (0.35, -0.5),
# (0.15, 0),
# (-0.1, -0.1),
# (-0.4, 0.3),
# (-0.6, -0.1),
# (-1, 1.1)
# ]
# path_nodes_pos = {paths_data[0][0][i]: path_nodes_pos[i] for i in range(8)}
fig = plt.figure(figsize=figsize, dpi=dpi)
# , k=1 / sqrt(G.number_of_nodes()) # the default spring coefficient
pos = nx.spring_layout(
G,
seed=layout_seed,
# pos=path_nodes_pos,
k=5 / sqrt(G.number_of_nodes()),
# fixed=path_nodes_pos.keys()
)
# Layouts
# -------
# circular_layout
# spring_layout <--
# fruchterman_reingold_layout <--
# spiral_layout <--
# 1. Draw the graph
node_size, path_node_size, failed_node_size = _node_sizes(G)
nx.draw_networkx(G, pos, node_size=node_size, width=0.3, alpha=0.3,
with_labels=False, arrows=False)
if draw_edge_weights:
edge_labels = nx.get_edge_attributes(G, "weight")
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
# 2. Draw the nodes of all the paths
all_paths_nodes = set()
for path in paths_data:
all_paths_nodes.update(path[0])
# Change the font of the labels of the path nodes and restore alpha=None.
for node, (x, y) in pos.items():
if node in all_paths_nodes:
plt.text(x, y, node, fontsize=19, ha='center', va='center')
nx.draw_networkx_nodes(G, pos=pos,
nodelist=all_paths_nodes, node_size=path_node_size,
edgecolors='k', node_color="deepskyblue", alpha=0.9)
# 3. Draw the paths
colors = iter(COLORS)
width_step = 6.5
last_path_width = 4
first_path_width = max(last_path_width + (len(paths_data) - 1) * width_step,
8)
for i, path in enumerate(paths_data):
try:
color = next(colors)
except StopIteration:
warn("Up to 8 paths can be plotted. Try the -v option, to print all the"
" generated paths.")
break
label = path_label(path, i + 1, mode.get("failing", "edges"))
path_edges_sequence = list(zip(path[0], path[0][1:]))
# arrows=False, arrowsize=20, arrowstyle='fancy',
# min_source_margin=1, min_target_margin=1,
# from matplotlib.patches import ConnectionStyle
# connectionstyle=ConnectionStyle("Arc3", rad=0.2),
nx.draw_networkx_edges(G, pos=pos, edgelist=path_edges_sequence,
edge_color=color, alpha=0.8, arrows=False,
width=first_path_width - i * width_step,
label=label)
# Mark the disconnceted edge or node with an ×.
if mode.get("failing") == "nodes":
if (len(path) > 2) and (path[3] not in [None, [None]]):
if hasattr(path[3], "__len__"):
nodelist = path[3]
else:
nodelist = [path[3]]
nx.draw_networkx_nodes(G, pos=pos, nodelist=nodelist,
node_color=color, node_shape='x',
node_size=failed_node_size, linewidths=5)
elif mode.get("failing") == "edges":
# Check for the case of the absolute shortest path, where there is no
# disconnected edge.
if (len(path) > 2) and (path[3] is not None): # ✕×✗
nx.draw_networkx_edge_labels(G, pos, edge_labels={path[3]: '×'},
font_size=60, font_color=color,
bbox=dict(alpha=0), rotate=False)
elif mode.get("failing") is None:
pass
else:
raise ValueError("failing should be 'edges', 'nodes' or None")
if (len(path) > 2) and (path[3] is not None):
online_status = "on-line" if mode.get('online') else "off-line"
frame_title = ("Replacement-paths\n"
f"mode: {online_status} / failing {mode.get('failing')}")
else:
frame_title = "\nk-shortest paths"
frame_title += (f"\n#nodes: {G.number_of_nodes()} "
f"#edges: {G.number_of_edges()} "
f"#paths: {len(paths_data)}")
plt.title(frame_title, fontsize=title_fontsize)
leg = plt.legend(fontsize=legend_fontsize)
leg.get_frame().set_alpha(None)
leg.get_frame().set_facecolor((1, 1, 1, 0.5))
plt.tight_layout()
xmin, xmax, ymin, ymax = _xylimits(pos)
plt.xlim(xmin, xmax)
plt.ylim(ymin, ymax)
if save_graph:
date_n_time = str(datetime.now())[:19]
date_n_time = date_n_time.replace(':', '-').replace(' ', '_')
file_name = f"graph_vis_{date_n_time}.png"
plt.savefig(os.path.join(os.getcwd(), file_name), dpi=fig.dpi)
if show_graph:
plt.show()
query2 = "von"
for tree in trees:
id = dict([(u, d['id']) for u, d in tree.nodes(data=True)])
for token, i in id.items():
if token == query2:
print("Token", i, ":", token)
print(nx.info(tree, token))
print("\n")
# visualise a sentence
query3 = 33
dg = trees[query3]
print("Dependency Tree for Sentence", query3, ":")
print(nx.info(dg))
print("Token IDs:",
nx.get_node_attributes(dg, 'id')) # mapping back into dataframe
pos = nx.spectral_layout(dg)
edge_labels = dict([((u, v), d['rel']) for u, v, d in dg.edges(data=True)])
nx.draw_networkx_edge_labels(dg, pos, edge_labels=edge_labels)
nx.draw_networkx(dg, pos, with_labels=True)
plt.axis('off')
plt.show()
def state_retrieval_vis(G,
paths_data,
visited_nodes_forward,
visited_nodes_reverse,
retrieved_nodes_forward,
retrieved_nodes_reverse,
visited_after_retrieval,
meeting_edge: tuple,
mode,
random_seed,
layout_seed,
show_graph,
save_graph):
if save_graph:
figsize = (10 * 1.8, 10)
dpi = 200
title_fontsize = 23
legend_fontsize = 21
else:
figsize = (8 * 1.8, 8)
dpi = 100
title_fontsize = 18
legend_fontsize = 16
k_0 = 18
fig = plt.figure(figsize=figsize, dpi=dpi)
pos = nx.spring_layout(G,
seed=layout_seed,
k=k_0 / sqrt(G.number_of_nodes()))
# 1. Draw the graph
# Exclude the visited nodes
nodelist = set(G.nodes()).difference(visited_nodes_forward) \
.difference(visited_nodes_reverse) \
.difference(visited_after_retrieval)
node_size, path_node_size, failed_node_size = _node_sizes(G)
nx.draw_networkx(G, pos, node_size=node_size, width=0.3, alpha=0.3,
nodelist=nodelist, with_labels=False, arrows=False)
# 2. Draw the forward state
if visited_nodes_forward:
nx.draw_networkx_nodes(G, pos=pos, nodelist=visited_nodes_forward,
node_color='#2c051a', alpha=0.8, node_size=2900,
linewidths=0, label="forward visited")
nx.draw_networkx_nodes(G, pos=pos, nodelist=retrieved_nodes_forward,
node_color='limegreen', alpha=0.7, node_size=2000, # #132226
linewidths=0, label="forward retrieved")
# 3. Draw the reverse state
# background : foreground
# ------------------------------
# 603F83FF 343148FF : C7D3D4FF
# 192e5b : 72a2c0
# 00539CFF : 9CC3D5FF B1624EFF A2A2A1FF f2eaed
nx.draw_networkx_nodes(G, pos=pos, nodelist=visited_nodes_reverse,
node_color='navy', alpha=0.75, node_size=2900,
linewidths=0, label="reverse visited")
nx.draw_networkx_nodes(G, pos=pos, nodelist=retrieved_nodes_reverse,
node_color='#f2eaed', alpha=0.8, node_size=2000,
linewidths=0, label="reverse retrieved")
# 4. Draw the visited after retrieval
nx.draw_networkx_nodes(G, pos=pos, nodelist=visited_after_retrieval,
node_color='orangered', alpha=0.8, node_size=2000,
linewidths=0, label="visited after retrieval")
# 5. Draw the nodes of all the paths
all_paths_nodes = set()
for path in paths_data:
all_paths_nodes.update(path[0])
# Change the font of the labels of the path nodes and restore alpha=None.
for node, (x, y) in pos.items():
if node in all_paths_nodes:
plt.text(x, y, node, fontsize=20, ha='center', va='center')
nx.draw_networkx_nodes(G, pos=pos,
nodelist=all_paths_nodes, node_size=path_node_size,
edgecolors='k', node_color="deepskyblue")
# 6. Draw the paths
colors = iter(['mediumblue', 'r'])
edgewidth_max = 12
edgewidth_step = 7
for i, path in enumerate(paths_data):
color = next(colors)
label = path_label(path, i + 1, mode["failing"])
path_edges_sequence = list(zip(path[0], path[0][1:]))
nx.draw_networkx_edges(G, pos=pos, edgelist=path_edges_sequence,
edge_color=color, alpha=0.8, arrows=False,
width=edgewidth_max - edgewidth_step * i,
label=label)
# Mark the disconnceted edge or node with an ×.
if mode["failing"] == "nodes":
if (len(path) > 2) and (path[3] not in [None, [None]]):
if hasattr(path[3], "__len__"):
disconnected = path[3]
else:
disconnected = [path[3]]
nx.draw_networkx_nodes(G, pos=pos, nodelist=disconnected,
node_color=color, node_shape='x',
node_size=failed_node_size, linewidths=5)
elif mode["failing"] == "edges":
# Check for the case of the absolute shortest path, where there is no
# disconnected edge.
# if path[3] == meeting_edge:
# x_pos = 0.5
# else:
# x_pos = 0.51
x_pos = 0.5
if (len(path) > 2) and (path[3] is not None): # ✕×✗
nx.draw_networkx_edge_labels(G, pos, edge_labels={path[3]: '×'},
font_size=80, font_color=color,
label_pos=x_pos, bbox=dict(alpha=0),
rotate=False)
elif mode["failing"] is None:
pass
else:
raise ValueError("failing should be 'edges', 'nodes' or None")
# 7. Draw the meeting edge
nx.draw_networkx_edges(G, pos=pos, edgelist=[meeting_edge],
edge_color="aqua", alpha=0.9, arrows=False,
width=edgewidth_max - edgewidth_step,
label=f"meeting edge: {meeting_edge}")
leg = plt.legend(fontsize=legend_fontsize)
leg.get_frame().set_alpha(None)
leg.get_frame().set_facecolor((1, 1, 1, 0.5))
online_mode = "online" if mode["online"] else "offline"
plt.title(("State retrieval\n"
f"n: {G.number_of_nodes()}"
f" m: {G.number_of_edges()}"
f" mode: {online_mode}"),
fontsize=title_fontsize)
plt.tight_layout()
xmin, xmax, ymin, ymax = _xylimits(pos)
plt.xlim(xmin, xmax)
plt.ylim(ymin, ymax)
if ((visited_nodes_forward == retrieved_nodes_forward)
and (visited_nodes_reverse == retrieved_nodes_reverse)):
failed_edge = "_me"
else:
failed_edge = ""
if save_graph:
file_name = (f"state_retrieval_vis_k_0_{k_0}_s_{random_seed}"
f"_l_{layout_seed}_e_{paths_data[1][3][0]}_dpi_{dpi}"
"{failed_edge}.png")
plt.savefig(os.path.join(os.getcwd(), file_name), dpi=fig.dpi)
if show_graph:
plt.show()
def draw_mas_sys(self):
plt.figure()
nx.draw_networkx(self.G)
def show_graph(G):
nx.draw_networkx(G,
pos=nx.kamada_kawai_layout(G),
with_labels=False,
node_size=100)
plt.show()
def plot_search_sphere(G,
visited,
path,
show_graph=True,
save_graph=False,
layout_seed=0,
visited_reverse=None,
meeting_edge_head=None):
"""Plots the visited nodes of the uni/bi-directional search."""
if save_graph:
figsize = (10 * 1.8, 10)
dpi = 200
title_fontsize = 22
legend_fontsize = 20
else:
figsize = (8 * 1.8, 8)
dpi = 100
title_fontsize = 18
legend_fontsize = 16
visited_nodes_forward = visited_nodes(visited, path[0])
num_visited_forward = len(visited_nodes_forward)
if visited_reverse is None:
algorithm = "Dijkstra's algorithm"
file_name = "dijkstra"
path_forward = path
else:
algorithm = "Bidirectional Dijkstra's algorithm"
file_name = "bidirectional"
visited_nodes_reverse = visited_nodes(visited_reverse, path[-1])
num_visited_reverse = len(visited_nodes_reverse)
meeting_edge_head_idx = path.index(meeting_edge_head)
path_forward = path[:meeting_edge_head_idx]
path_reverse = path[meeting_edge_head_idx:]
fig = plt.figure(figsize=figsize, dpi=dpi)
pos = nx.spring_layout(G,
seed=layout_seed,
k=72 / sqrt(G.number_of_nodes()))
# 1. Draw the graph
node_size, path_node_size, failed_node_size = _node_sizes(G)
nx.draw_networkx(G, pos, node_size=node_size, width=0.15, alpha=0.3,
with_labels=False, arrows=False)
# 2. Draw the visited nodes
nx.draw_networkx_nodes(G, pos=pos, nodelist=visited_nodes_forward,
node_color='goldenrod', node_size=800, linewidths=0,
label="forward search", alpha=0.85)
if visited_reverse is not None:
nx.draw_networkx_nodes(G, pos=pos, nodelist=visited_nodes_reverse,
node_color='g', node_size=800, linewidths=0,
label="reverse search", alpha=0.8)
# 3. Draw the path-nodes
for node, (x, y) in pos.items():
if node in path:
plt.text(x, y, node, fontsize=20, ha='center', va='center')
nx.draw_networkx_nodes(G, pos=pos, nodelist=path_forward, edgecolors='k',
node_size=path_node_size, node_color="deepskyblue")
if visited_reverse is not None:
nx.draw_networkx_nodes(G, pos=pos, nodelist=path_reverse, edgecolors='k',
node_size=path_node_size, node_color="deepskyblue")
# 4. Draw the path
if visited_reverse:
label = f"forward subpath: {path_forward}"
else:
label = f"path: {path_forward}"
path_edges_sequence = list(zip(path_forward[:-1], path_forward[1:]))
nx.draw_networkx_edges(G, pos=pos, edgelist=path_edges_sequence,
edge_color='k', arrows=False,
width=10, label=label)
if visited_reverse is not None:
# then, draw the reverse subpath
path_edges_sequence = list(zip(path_reverse[:-1], path_reverse[1:]))
nx.draw_networkx_edges(G, pos=pos, edgelist=path_edges_sequence,
edge_color='mediumblue', arrows=False,
width=10, label=f"reverse subpath: {path_reverse}")
meeting_edge = [(path_forward[-1], path_reverse[0])]
nx.draw_networkx_edges(G, pos=pos, edgelist=meeting_edge,
edge_color='r', arrows=False,
width=10, label=f"meeting edge: {meeting_edge[0]}")
if visited_reverse is None:
num_visited_total = num_visited_forward
else:
num_visited_total = num_visited_forward + num_visited_reverse
frame_title = (f"{algorithm} search space\n"
f"n: {G.number_of_nodes()}"
f" m: {G.number_of_edges()}"
f" nodes visited: {num_visited_total}")
plt.title(frame_title, fontsize=title_fontsize)
plt.legend(fontsize=legend_fontsize)
plt.tight_layout()
if save_graph:
date_n_time = str(datetime.now())[:19]
date_n_time = date_n_time.replace(':', '-').replace(' ', '_')
file_name = (f"search_sphere_{file_name}_{date_n_time}.png")
plt.savefig(os.path.join(os.getcwd(), file_name), dpi=fig.dpi)
if show_graph:
plt.show()
def graph_to_networkx(self, idx, data):
#non-directed,non-weighted,normal
edge_labels = {}
if self._s2 == 'non-directed' and self._s3 == 'non-weighted' and self._s4 == 'normal':
n, m = map(int, data.pop(0).split())
g = nx.Graph()
g.add_nodes_from(list(range(idx, n + idx)))
for i in range(m):
a, b = map(int, data[i].split())
g.add_edge(a, b)
###non-directed,weighted,normal
if self._s2 == 'non-directed' and self._s3 == 'weighted' and self._s4 == 'normal':
n, m = map(int, data.pop(0).split())
g = nx.Graph()
g.add_nodes_from(list(range(idx, n + idx)))
for i in range(m):
a, b, c = map(int, data[i].split())
g.add_edge(a, b, weight=c)
edge_labels[(a, b)] = c
###directed,non-weighted,normal
if self._s2 == 'directed' and self._s3 == 'non-weighted' and self._s4 == 'normal':
n, m = map(int, data.pop(0).split())
g = nx.DiGraph()
g.add_nodes_from(list(range(idx, n + idx)))
for i in range(m):
a, b = map(int, data[i].split())
g.add_edge(a, b)
###directed,weighted,normal
if self._s2 == 'directed' and self._s3 == 'weighted' and self._s4 == 'normal':
n, m = map(int, data.pop(0).split())
g = nx.DiGraph()
g.add_nodes_from(list(range(idx, n + idx)))
for i in range(m):
a, b, c = map(int, data[i].split())
g.add_edge(a, b, weight=c)
edge_labels[(a, b)] = c
###non-directed,non-weighted,martrix
if self._s2 == 'non-directed' and self._s3 == 'non-weighted' and self._s4 == 'martrix':
n = int(data.pop(0))
data = [list(map(int, d.split())) for d in data]
g = nx.Graph()
g.add_nodes_from(list(range(idx, n + idx)))
for i in range(n):
for j in range(n):
if data[i][j]:
g.add_edge(i + idx, j + idx)
###non-directed,weighted,martrix
if self._s2 == 'non-directed' and self._s3 == 'weighted' and self._s4 == 'martrix':
n = int(data.pop(0))
data = [list(map(int, d.split())) for d in data]
g = nx.Graph()
g.add_nodes_from(list(range(idx, n + idx)))
for i in range(n):
for j in range(n):
if data[i][j] != 0:
g.add_edge(i + idx, j + idx, weight=data[i][j])
edge_labels[(i + idx, j + idx)] = data[i][j]
###directed,non-weighted,martrix
if self._s2 == 'directed' and self._s3 == 'non-weighted' and self._s4 == 'martrix':
n = int(data.pop(0))
data = [list(map(int, d.split())) for d in data]
g = nx.DiGraph()
g.add_nodes_from(list(range(idx, n + idx)))
for i in range(n):
for j in range(n):
if data[i][j] == 1:
g.add_edge(i + idx, j + idx)
###directed,weighted,martrix
if self._s2 == 'directed' and self._s3 == 'weighted' and self._s4 == 'martrix':
n = int(data.pop(0))
data = [list(map(int, d.split())) for d in data]
g = nx.DiGraph()
g.add_nodes_from(list(range(idx, n + idx)))
for i in range(n):
for j in range(n):
if data[i][j] != 0:
g.add_edge(i + idx, j + idx, weight=data[i][j])
edge_labels[(i + idx, j + idx)] = data[i][j]
fig = plt.figure(figsize=(15, 15))
pos = nx.spring_layout(g, k=self._k)
nx.draw_networkx(g,
pos,
node_size=self._node_size,
node_color=self._node_color,
node_shape=self._node_shape,
width=self._width,
edge_color=self._edge_color,
alpha=self._alpha,
font_color=self._font_color,
font_weight=self._font_weight,
font_size=self._font_size)
if edge_labels:
nx.draw_networkx_edge_labels(g,
pos,
edge_labels=edge_labels,
font_size=self._font_size - 2)
plt.axis('off')
return fig
import networkx as nx
from networkx.algorithms import community
import matplotlib.pyplot as plt
# 1.Genereating network
G = nx.barabasi_albert_graph(100, 3)
# 2.Drawing degree distribution
pos = nx.spring_layout(G)
nx.draw_networkx(G, pos, with_labels=True)
plt.show()
# 3.Finding all communities (I used Louvain Modularity Algorithm.)
communities = list(community.greedy_modularity_communities(G))
# 4.Number of communities
print(f"There are {len(communities)} communities.")
# 5.Naming communities (I assigned all the communities that I created into a array called community. When I want to access it, I will do this using the index value.)
community = []
for frozenset in communities:
community.append(list(frozenset))
# 6.Print the size and the node labels in each community
i = 1
def perform_test(test_set):
'''
test_set form: {'tree': name_of_example OR name_of_pickled_tree,
'viz': true or false,
'classification': [TreeNN, TreeInsert]}
'''
tree_built = False
query_results = {}
# Define a test tree
if test_set['tree'] == "wiki":
print "\nBuilding Tree with Wikipedia example...\n"
labels = ['a', 'b', 'c', 'q', 'e'] #d is query protein - q
class_map = {'a':'class1','b':'class1','c':'class2','q':'query','e':'class3'}
dist_matrix = pd.DataFrame([[0, 5, 9, 9, 8],
[5, 0, 10, 10, 9],
[9, 10, 0, 8, 7],
[9, 10, 8, 0, 3],
[8, 9, 7, 3, 0]],
index=labels, columns=labels)
query_name = 'q'
elif test_set['tree'] == "protein_database":
print "\nBuilding Tree with data/distance_matrix.csv & data/id_lookup.csv...\n"
dist_matrix = read_distance_csv('./data/distance_matrix.csv')
class_map = read_classes_csv('./data/id_lookup.csv')
query_name = class_map.keys()[0]
else:
print "\nUsing built tree from file: " + test_set['tree'] + " ...\n"
njt = pickle.load(open(test_set['tree'], "rb" ))
query_name = njt.class_map.keys()[0]
tree_built=True
# Build the test tree
if not tree_built:
njt = NJTree()
njt.build(dist_matrix, class_map, myClusterNaming)
# Record query info
query_results['Protein'] = query_name
truth_class = njt.class_map[query_name]
query_results['Truth_Class'] = truth_class
print "QUERY: ", query_name
print "TRUTH: ", truth_class
# Visualize tree
# TODO add key to the viz
if test_set['viz']:
labels = {i[0]: i[1]['c'] for i in njt.tree.nodes(data=True)}
layout = nx.spring_layout(njt.tree)
all_node_classes = nx.get_node_attributes(njt.tree, 'c')
# Get rid of internal nodes
node_classes = {k: v for k,v in all_node_classes.items() if len(v) > 0}
unique_classes = list(Set(node_classes.values()))
unique_colors = plt.cm.Set3(np.linspace(0, 1, len(unique_classes)))
color_map = {unique_classes[i] : unique_colors[i] for i in range(len(unique_colors))}
node_list = node_classes.keys()
node_colors = [color_map[njt.tree.node[node]['c']] for node in node_list]
# Add legend
f = plt.figure(1)
ax = f.add_subplot(1,1,1)
for cls in color_map:
ax.plot([0], [0], '-', color=color_map[cls], label=cls, linewidth=10)
#nx.draw_networkx(njt.tree, pos=layout, with_labels=True) #ID labels
#nx.draw_networkx(njt.tree, with_labels=True, labels=labels, node_size=100) #class labels
nx.draw_networkx(njt.tree, with_labels=False, node_size=150,
nodelist=node_list, node_color=node_colors, ax=ax) #no labels
plt.axis('off')
f.set_facecolor('w')
plt.legend(loc='upper left')
f.tight_layout()
plt.show()
# Classify
classifications = [i.lower() for i in test_set['classification']]
if "treenn" in classifications:
query_class = njt.classify_treeNN(query_name)
query_results['TreeNN'] = query_class
query_results['TreeNN_Correct'] = (query_class == truth_class)
print '\nQUERY CLASS (TreeNN): ', query_class
if "treeinsert" in classifications:
query_class = njt.classify_treeInsert(query_name, myClusterNaming)
query_results['TreeInsert'] = query_class
query_results['TreeInsert_Correct'] = (query_class == truth_class)
print '\nQUERY CLASS (TreeInsert): ', query_class
return njt, query_results
def Partition_F(name1, xxx, k):
# name1 = 'E:\\脑电python3\\分区块数据\\'
name2 = 'data%d.pdf' % (k)
name = name1 + name2
with PdfPages(name) as pdf:
data = np.nonzero(xxx)
row = data[0]
col = data[1]
di = zip(row, col)
list_di = list(di)
G = nx.Graph()
G.add_edges_from(list_di)
# print("list_di---", list_di)
# print("type(list_di[0])---", type(list_di[0]))
# print("type(list_di[0][0])---", type(list_di[0][0]))
# 将节点写入txt文件
for l1 in list_di:
# print("l1---", l1)
# print("l2---", l2)
num1 = int(l1[0])
num2 = int(l1[1])
# list_num = [num1, num2]
# print(list_num)
fp = open("E:\\脑电python3\\ceshi\\node.txt", "a+")
fp.writelines(str(num1)+" "+str(num2)+" "+"1" + "\n")
# fp.writelines(str(list_num) + "\n")
fp.close()
# 画圆
x1 = y1 = np.arange(-1, 15, 0.1)
x1, y1 = np.meshgrid(x1, y1)
plt.contour(x1, y1, (x1 - 7) ** 2 + (y1 - 7) ** 2, [49])
plt.axis('scaled')
# plt.show()
# 统计节点的度
list_degree = G.degree()
print("节点的度：", list_degree)
d1 = list_degree[0]
print(d1)
# 画网络图
pos = [(5.5, 13.5), (5, 13), (4.5, 11.5), (3, 12.5), (2, 9.5),
(5.5, 9.5), (3, 7), (0, 7), (2, 5), (5.5, 5),
(4.5, 2.5), (3, 2), (5, 1.5), (6, 0.5), (7, 0),
(7, 3), (8.5, 13.5), (9, 13), (7, 11), (9.5, 11.5),
(11, 12.5), (12, 9.5), (8.5, 9.5), (7, 7), (11, 7),
(14, 7), (12, 5), (8.5, 5), (9.5, 2.5), (11, 2),
(9, 1.5), (8, 0.5)]
nx.draw_networkx(G, pos, cmap=plt.cm.Blues, with_labels=True)
plt.title('Page1')
pdf.savefig() # saves the current figure into a pdf page
plt.close()
# 实现网络划分（计算Q）
# 画圆
x1 = y1 = np.arange(-1, 15, 0.1)
x1, y1 = np.meshgrid(x1, y1)
plt.contour(x1, y1, (x1 - 7) ** 2 + (y1 - 7) ** 2, [49])
plt.axis('scaled')
# 分类
# part = community.best_partition(G)
# print("part-----", part)
# mod = community.modularity(part, G)
# print("mod-----", mod)
# values = [part.get(node) for node in G.nodes()]
# print("values-----", values)
# nx.draw_networkx(G, pos, node_color=values, with_labels=True)
# # plt.savefig('E:\\脑电python3\\分区块数据\\bbb.jpg')
# # plt.show()
# plt.title('Page2')
# pdf.savefig() # saves the current figure into a pdf page
# plt.close()
# values = []
mod, values = FastUnfolding()
nx.draw_networkx(G, pos, node_color=values, with_labels=True)
plt.title('Page2')
pdf.savefig() # saves the current figure into a pdf page
plt.close()
# print("mod-----------", mod)
# print("values-----------", values)
# 过程
x1 = y1 = np.arange(-1, 15, 0.1)
x1, y1 = np.meshgrid(x1, y1)
plt.contour(x1, y1, (x1 - 7) ** 2 + (y1 - 7) ** 2, [49])
plt.axis('scaled')
values2 = [0, 0, 0, 0, 1, 2, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 2, 3, 3, 3, 2, 2, 5, 5, 5, 5, 5, 5, 5, 5]
nx.draw_networkx(G, pos, node_color=values2, with_labels=True)
plt.title('Page3')
pdf.savefig() # saves the current figure into a pdf page
plt.close()
return mod
def is_eorbit_pair(g, e, f):
return is_same_degrees(g, e, f) and is_same_endpoints_neighbors(g, e, f)
def is_eorbit_group(g, s):
if len(s) == 1:
return True
return all(is_eorbit_pair(g, e, f) for e, f in combinations(s, 2))
def edge_orbits(g):
for ss in all_partitions(g, list(g.edges())):
if all(is_eorbit_group(g, s) for s in ss):
return ss
if __name__ == '__main__':
g, pos = gen()
print(vertex_orbits(g))
print(edge_orbits(g))
# matplotlib.use('module://backend_ipe')
# isy = "/Applications/Ipe.app/Contents/Resources/styles/basic.isy"
# matplotlib.rcParams['ipe.stylesheet'] = isy
nx.draw_networkx(g, pos, node_color='#ff9999')
plt.gca().set_aspect('equal')
plt.gca().axis('off')
plt.show()
# plt.savefig('orbits_01.ipe', format='ipe')
from parse import parse
import networkx as nx
pattern = 'Step {start} must be finished before step {stop} can begin.'
sleigh_steps = nx.DiGraph()
for line in open('input.txt'):
result = parse(pattern, line)
sleigh_steps.add_edge(result['start'], result['stop'])
print(''.join(nx.lexicographical_topological_sort(sleigh_steps)))
# for order in nx.all_topological_sorts(sleigh_steps):
# print(order)
# print(''.join(min(nx.all_topological_sorts(sleigh_steps))))
import matplotlib.pyplot as plt
pos = nx.nx_agraph.graphviz_layout(sleigh_steps, prog='dot')
nx.draw_networkx(sleigh_steps, pos=pos)
plt.show()
Build the keyword graph.
Arguments:
cooccuranceThreshold : If the cooccurances of two keywords is above
coocuranceThreshold, there is an edge between the nodes represented
by the keywords.
Default value is 1
Returns:
A networkx graph with keywords as nodes and there is an edge between two nodes
if their similarity value is greater than similarityThreshold.
"""
docsForWords = self.docsContainingWords()
h = nx.Graph()
for w in self.vocabalury():
h.add_node(w)
for w1 in h.nodes():
for w2 in h.nodes():
weight = len(set(docsForWords[w1]) & set(docsForWords[w2]))
if (weight > cooccuranceThreshold):
h.add_edge(w1, w2, weight=weight)
return h
if __name__ == '__main__':
grapher = TextGraph(open(sys.argv[1]))
g = grapher.sentenceGraph()
subgraphs = nx.connected_component_subgraphs(g)
nx.draw_networkx(subgraphs[0], with_labels=False)
plt.show()
def build(self, dist_matrix, class_map, cluster_naming_function):
"""Builds this classification tree via the neighbor-joining method.
Args:
dist_matrix (pandas.DataFrame): Matrix of pairwise distances labelled with element IDs.
class_map (dict): Dictionary where keys are element IDs and values are class labels.
cluster_naming_function (function): Function to assign new names to clusters based on
nodes to be clustered and the cluster dictionary in form myFunct(node1, node2, cluster_map).
"""
# Update attributes
self.orig_dist_matrix = dist_matrix
self.class_map = class_map
self.work_dist_matrix = dist_matrix
# Get number of elements
n = dist_matrix.shape[0]
if PROGRESS:
print 'Starting tree build now!'
# Loop through n-3 elements & add nodes in tree
for i in range(n - 3):
if DEBUG:
print 'Distance Matrix'
pprint(self.work_dist_matrix)
print
# Calculate q_matrix matrix from distances
q_matrix = _calculate_q_matrix(self.work_dist_matrix)
if DEBUG:
print 'Q matrix:'
pprint(q_matrix)
print
# Find pair of elements (i,j) where q_matrix(i,j) has the lowest value
(min_col, min_row) = _find_min_pair(q_matrix)
# Add nodes i,j, and cluster node of i and j to this tree
# And update working distance matrix accordingly
new_cluster_name = cluster_naming_function(min_row, min_col, self.cluster_map)
self.cluster_leaves(min_row, min_col, new_cluster_name)
if DEBUG:
print 'Tree:'
pprint(nx.clustering(self.tree))
pprint(self.cluster_dictionary)
print '\n\n'
# View graph after each step for debugging
if VIEW_ALL:
labels = {i[0]: i[0]+'/'+i[1]['c'] for i in njt.tree.nodes(data=True)}
layout = nx.spring_layout(njt.tree)
nx.draw_networkx(njt.tree, pos=layout, with_labels=True, labels=labels) #class labels
plt.show()
if PROGRESS:
print str(i + 1) + " down, " + str(n-i-4) + " to go..."
# Add remaining branch lengths and nodes from working distance matrix to this tree
previous_cluster = new_cluster_name
mid_edge_length = 0.5 * (self.work_dist_matrix.iat[0, 1]
+ self.work_dist_matrix.iat[0, 2]
- self.work_dist_matrix.iat[1, 2])
(node1, node2) = (self.work_dist_matrix.columns[0], self.work_dist_matrix.columns[1])
new_cluster = cluster_naming_function(node1, node2, self.cluster_map)
self.cluster_leaves(node1, node2, new_cluster)
# Viz only scales based on a weight attribute, so we set that as the length
self.tree.add_edge(previous_cluster, new_cluster, length=mid_edge_length, weight=mid_edge_length)
if DEBUG:
print 'Final tree:'
pprint(nx.clustering(self.tree))
pprint(self.cluster_dictionary)
def main():
"""
Main method to perform part A ,B C
:return:
"""
# Webscraping for names
print("reading names from web..")
readNames("boy", "boys.dat")
readNames("girl", "girls.dat")
print("done...")
mean = np.empty([10, 150])
mname = dl.yieldName('male')
fname = dl.yieldName('female')
for j in range(1, 11):
print("")
print("**************************************************")
print("Trial No.{}".format(str(j)))
start_year = 0
dolph_list = []
mothers = []
fathers = []
dolphinPop_75 = []
populations = np.empty(150)
years = np.empty(150)
births = 0
dol1 = Dolphins(next(mname), 'male', 'abc', 'xys', 0)
dol2 = Dolphins(next(fname), 'female', 'ab', 'xyf', 0)
dol3 = Dolphins(next(mname), 'male', 'a', 'f', 0)
dol4 = Dolphins(next(fname), 'female', 'b', 'y', 0)
dolph_list.append(dol1)
dolph_list.append(dol2)
dolph_list.append(dol3)
dolph_list.append(dol4)
for year in range(150):
years[year] = year
alive_list = alive_lst(year, dolph_list)
pop = len(alive_list)
populations[year] = pop
male_alive = []
female_alive = []
for dol in alive_list:
if dol.sex == 'male':
male_alive.append(dol)
else:
female_alive.append(dol)
update_all_procreation(year, male_alive)
update_all_procreation(year, female_alive)
p_mothers = []
p_fathers = []
for f in female_alive:
if f.years_since_procreation >= 5 and f.age > 6:
p_mothers.append(f)
for m in male_alive:
if m.years_since_procreation >= 5 and f.age > 6:
p_fathers.append(m)
mothers = []
fathers = []
breeding = len(p_fathers) + len(p_mothers)
for mom in p_mothers:
if len(p_fathers) != 0:
dad = random.sample(p_fathers, 1)[0]
if mom.request_procreation(dad):
if random.random() > 0.5: # deciding the gender
sex = 'male'
name = next(mname)
else:
sex = 'female'
name = next(fname)
new = Dolphins(name, sex, mom, dad, year)
dolph_list.append(new)
mom.children.append(new)
dad.children.append(new)
mothers.append(mom)
fathers.append(dad)
births += 1
if year != 5 or year != 6:
update_all_procreation(year, alive_list)
if year == 0:
print("##################################################")
print('entering year 0 with 4 dolphins, with 0 breeding.')
if year % 25 == 0 and year != 100 and year != 0:
print("##################################################")
print("entering year ", year, " with ", pop,
" dolphins, with ", breeding, "breeding")
if year == 100:
print("##################################################")
print("entering year ", year, " with ", pop,
" dolphins, with ", breeding, "breeding")
if year == 75:
dolphinPop_75 = dolphinPop_75 + alive_list
if year == 101:
print("at year ", year - 1, " there are ", pop,
" living dolphins.")
print("there have been", births, "births, in total.")
if year == 149:
print("##################################################")
print("At year, ", year, " there are ", pop,
" living dolphins")
mean[j - 1] = populations
# For calculating the mean
mean_popopulation = np.mean(mean, axis=0)
# For calculating the standard deviation
std_population = np.std(mean, axis=0)
y1 = mean_popopulation + std_population
y2 = mean_popopulation - std_population
plt.plot(years, mean_popopulation, 'b')
plt.xlabel("Years")
plt.ylabel("Number of Living Dolphins")
plt.title("Average population and standard deviation from 10 trials")
plt.fill_between(years, y1, y2, facecolor='red')
plt.savefig("population_growth.pdf")
plt.show()
# for plotting the genology tree
rand = random.randrange(0, 10)
dolph_pop = []
dolphin_pop = dolphinPop_75
char = (random.sample(dolphin_pop, 1))[0]
mom_char = char.mother
dad_char = char.father
mom_half = []
dad_half = []
full_sib = []
for elem in dolphin_pop:
if elem.mother == mom_char and elem.father == dad_char and elem != char:
full_sib.append(elem)
elif elem.mother == mom_char and elem != char:
mom_half.append(elem)
elif elem.father == dad_char and elem != char:
dad_half.append(elem)
# Creates graph for geneology.
# and plots the graph accordingly
gen = nx.Graph()
gen.add_node(mom_char, pos=(0, 3)) # adding mother node
gen.add_node(dad_char, pos=(3, 3)) # adding father node
xheight = .5
xfloor = 0
for j in dolphin_pop:
if j in mom_half:
gen.add_node(j, pos=(xheight, 1))
gen.add_edge(j, mom_char)
xheight += 2
if j in dad_half:
gen.add_node(j, pos=(xheight, 1))
gen.add_edge(j, dad_char)
xheight += 2
if j in full_sib:
gen.add_node(j, pos=(xfloor, 2))
gen.add_edge(j, mom_char)
gen.add_edge(j, dad_char)
xfloor += 2
pos = nx.get_node_attributes(gen, 'pos')
nx.draw_networkx(gen, pos)
plt.title(char.name + "'s Family")
plt.axis('off')
plt.savefig("genealogy.pdf")
plt.show()
with open(filename) as f:
# Create a csv reader object.
reader = csv.reader(f)
# Store the latitudes and longitudes in the appropriate lists.
i = 0
for row in reader:
countries.append(row[0])
lats.append(float(row[1]))
lons.append(float(row[2]))
i = i + 1
m = Basemap(projection='robin', resolution = 'l', area_thresh = 1000.0,
lat_0=0, lon_0=0)
m.drawcoastlines()
m.drawcountries()
#m.fillcontinents(color = 'gray')
m.drawmapboundary()
#m.drawmeridians(np.arange(0, 360, 30))
#m.drawparallels(np.arange(-90, 90, 30))
for country, lon, lat, in zip(countries, lons, lats):
G.add_node(country)
x,y = m(lon, lat)
pos[country] = (x,y)
#m.plot(x, y, 'yo', markersize=msize)
nx.draw_networkx(G,pos,node_size=50,node_color='yellow',labels = False)
#plt.show()
