def test_scale_and_center_arg(self):
G = nx.complete_graph(9)
G.add_node(9)
vpos = nx.random_layout(G, scale=2, center=(4,5))
self.check_scale_and_center(vpos, scale=2, center=(4,5))
vpos = nx.spring_layout(G, scale=2, center=(4,5))
self.check_scale_and_center(vpos, scale=2, center=(4,5))
vpos = nx.spectral_layout(G, scale=2, center=(4,5))
self.check_scale_and_center(vpos, scale=2, center=(4,5))
# circular can have twice as big length
vpos = nx.circular_layout(G, scale=2, center=(4,5))
self.check_scale_and_center(vpos, scale=2*2, center=(4,5))
vpos = nx.shell_layout(G, scale=2, center=(4,5))
self.check_scale_and_center(vpos, scale=2*2, center=(4,5))
# check default center and scale
vpos = nx.random_layout(G)
self.check_scale_and_center(vpos, scale=1, center=(0.5,0.5))
vpos = nx.spring_layout(G)
self.check_scale_and_center(vpos, scale=1, center=(0.5,0.5))
vpos = nx.spectral_layout(G)
self.check_scale_and_center(vpos, scale=1, center=(0.5,0.5))
vpos = nx.circular_layout(G)
self.check_scale_and_center(vpos, scale=2, center=(0,0))
vpos = nx.shell_layout(G)
self.check_scale_and_center(vpos, scale=2, center=(0,0))
def find_football_communities():
""" Finds the communities produced for the football network, uses compare
methods to graph
"""
fgraph = CD.football_graph()
known = CD.football_known_c()
temp7 = known[7]
temp8 = known[8]
temp9 = known[9]
known[7] = temp8
known[8] = temp9
known[9] = temp7
center_g = nx.Graph()
center_g.add_nodes_from(range(12))
centers = nx.circular_layout(center_g, scale = 10)
pos = {}
subgraphs = [nx.subgraph(fgraph, c) for c in known]
count = -1
for g in subgraphs:
count += 1
(off_x, off_y) = centers[count]
pos_local = nx.circular_layout(g, scale=2.)
for n, place in pos_local.iteritems():
pos[n] = place + np.array([off_x, off_y])
compare_methods(fgraph,
'football_',
param=[1., 1., 5./115., 4, 0, .7, 20],
known=known,
pos=pos,
color_map={76:1, 11:2, 7:3, 102:4, 104:5, 47:6, 98:7,
96:8, 23:9, 94:10, 27:0},
data_path="FootballGames/football_metis")
def plot_graphs(self):
# draw lables
# choose same layout as in drawing the rest of the graph
pos_G=nx.circular_layout(self.g1) # positions for all nodes for G (in this case circular)
pos_H=nx.circular_layout(self.g2) # positions for all nodes for H (in this case circular)
labels_G = {} # create a dict with labels
for item in self.g1.nodes():
labels_G[item] = item
labels_H = {} # create a dict with labels
for item in self.g2.nodes():
labels_H[item] = item
# color-mapping via numpy
# list of cmaps can be found here: http://matplotlib.org/examples/color/colormaps_reference.html
# I chose this cmap because there are no dark colors in it so the labels stay readable regardless
# the color of the label.
plt.subplots_adjust(left=0,right=1,bottom=0,top=0.95,wspace=0.01,hspace=0.01)
plt.subplot(121)
plt.title("Graph G")
nx.draw_circular(self.g1, cmap=plt.get_cmap('Set1'), node_color=self.nc1)
nx.draw_networkx_labels(self.g1, pos_G, labels_G)
plt.subplot(122)
plt.title("Graph H")
nx.draw_circular(self.g2, cmap=plt.get_cmap('Set1'), node_color=self.nc2)
nx.draw_networkx_labels(self.g2, pos_H, labels_H)
plt.show()
def displayRGA(self, pairingoption=1, nodepositions=None):
"""This method will display the RGA pairings.
It has 2 options of pairings:
1) pairingoption = 1 (the default) This displays the standard RGA
pairings where the decision to pair is positive if the relative gain
array has an element value of more than or equal to 0.5.
2) pairingoption = 2 This displays the RGA pairs where each input is
forced to have a paired output. This is selected by using the maximum
value in each column as a pair.
It has an optional parameter to set node positions. If left out
the default node positions will be circular. """
if pairingoption == 1:
pairingpattern = self.bristol.pairedvariablesHalf
message = "Standard RGA Pairings"
self.G1 = nx.DiGraph()
self.G1 = self.G.copy()
print(pairingpattern)
self.G1.add_edges_from(self.G1.edges(), edgecolour='k')
self.G1.add_edges_from(pairingpattern, edgecolour='r')
#correct up to here
pairingtuplelist = [(row[0], row[1]) for row in pairingpattern] #what a mission to find this error
edgecolorlist = ["r" if edge in pairingtuplelist else "k" for edge in self.G1.edges()]
if nodepositions == None:
nodepositions = nx.circular_layout(self.G1)
plt.figure(message)
nx.draw_networkx(self.G1, pos=nodepositions)
nx.draw_networkx_edges(self.G1, pos=nodepositions, width=2.5, edge_color=edgecolorlist, style='solid', alpha=0.5)
nx.draw_networkx_nodes(self.G1, pos=nodepositions, node_color='y', node_size=450)
plt.axis('off')
else:
pairingpattern = self.bristol.pairedvariablesMax
message = "Maximum RGA Pairings"
self.G2 = nx.DiGraph()
self.G2 = self.G.copy()
print(pairingpattern)
self.G2.add_edges_from(self.G2.edges(), edgecolour='k')
self.G2.add_edges_from(pairingpattern, edgecolour='r')
#correct up to here
pairingtuplelist = [(row[0], row[1]) for row in pairingpattern] #what a mission to find this error
edgecolorlist = ["r" if edge in pairingtuplelist else "k" for edge in self.G2.edges()]
if nodepositions == None:
nodepositions = nx.circular_layout(self.G2)
plt.figure(message)
nx.draw_networkx(self.G2, pos=nodepositions)
nx.draw_networkx_edges(self.G2, pos=nodepositions, width=2.5, edge_color=edgecolorlist, style='solid', alpha=0.5)
nx.draw_networkx_nodes(self.G2, pos=nodepositions, node_color='y', node_size=450)
plt.axis('off')
def test_fixed_node_fruchterman_reingold(self):
# Dense version (numpy based)
pos = nx.circular_layout(self.Gi)
npos = nx.fruchterman_reingold_layout(self.Gi, pos=pos, fixed=[(0, 0)])
assert_equal(tuple(pos[(0, 0)]), tuple(npos[(0, 0)]))
# Sparse version (scipy based)
pos = nx.circular_layout(self.bigG)
npos = nx.fruchterman_reingold_layout(self.bigG, pos=pos, fixed=[(0, 0)])
for axis in range(2):
assert_almost_equal(pos[(0,0)][axis], npos[(0,0)][axis])
def test_empty_graph(self):
G=nx.Graph()
vpos = nx.random_layout(G)
vpos = nx.circular_layout(G)
vpos = nx.spring_layout(G)
vpos = nx.fruchterman_reingold_layout(G)
vpos = nx.shell_layout(G)
vpos = nx.spectral_layout(G)
# center arg
vpos = nx.random_layout(G, scale=2, center=(4,5))
vpos = nx.circular_layout(G, scale=2, center=(4,5))
vpos = nx.spring_layout(G, scale=2, center=(4,5))
vpos = nx.shell_layout(G, scale=2, center=(4,5))
vpos = nx.spectral_layout(G, scale=2, center=(4,5))
def test_single_node(self):
G = nx.Graph()
G.add_node(0)
vpos = nx.random_layout(G)
vpos = nx.circular_layout(G)
vpos = nx.spring_layout(G)
vpos = nx.fruchterman_reingold_layout(G)
vpos = nx.shell_layout(G)
vpos = nx.spectral_layout(G)
# center arg
vpos = nx.random_layout(G, scale=2, center=(4,5))
vpos = nx.circular_layout(G, scale=2, center=(4,5))
vpos = nx.spring_layout(G, scale=2, center=(4,5))
vpos = nx.shell_layout(G, scale=2, center=(4,5))
vpos = nx.spectral_layout(G, scale=2, center=(4,5))
def final_graphs(Graphs,psi):
if Graphs == []:
print "There are no models for the input formula: ", (syntax.formula_to_string(psi))
print "So the the negation of it : ", "~(",(syntax.formula_to_string(psi)), ") is valid."
else:
for i in range(0,len(Graphs)):
graph = Graphs[i]
custom_labels={}
node_colours=['y']
for node in graph.nodes():
custom_labels[node] = graph.node[node]
node_colours.append('c')
nx.draw(Graphs[i], nx.circular_layout(Graphs[i]), node_size=1500, with_labels=True, labels = custom_labels, node_color=node_colours)
#show with custom labels
fig_name = "graph" + str(i) + ".png"
plt.savefig(fig_name)
plt.show()
print "Satisfiable models have been displayed."
if len(Graphs) == 1:
print "You have ",len(Graphs), " valid model."
else:
print "You have ",len(Graphs), " valid models."
print "Your provided formula is: ", (syntax.formula_to_string(psi))
print "Pictures of the graphs have been saves as: graph0.png, graph1.png etc."
def main(args):
pi = scipy.io.loadmat(args[1])
dims = scipy.io.loadmat(args[2])
total = 1
for i in range(len(dims["dims"][0])):
total = total * dims["dims"][0][i]
# Debug
print dims["dims"]
print total
print pi["pi"]
# chain = nx.Graph()
chain = pgv.AGraph(directed=True)
for i in range(total):
for j in range(total):
wt = pi["pi"][i][j]
if (wt > 0):
chain.add_edge(i + 1, j + 1, weight=wt)
edge = chain.get_edge(i + 1, j + 1)
edge.attr['label'] = wt
pos = nx.circular_layout(chain)
# pos = nx.shell_layout(chain)
# nx.draw_networkx_edge_labels(chain, pos, edge_labels = edgeLabels, label_pos = 0.3)
# nx.draw_networkx_labels(chain, pos, nodeLabels, font_size = 12)
# nx.draw(chain)
chain.layout(prog='dot')
chain.draw('chain.png')
def draw_graph(G,savefile=None):
pos = nx.circular_layout(G)
colors = range(G.number_of_edges())
nx.draw(G,pos,color='#336699',edge_color=colors,width=4,
edge_cmap=plt.cm.Blues,with_labels=True)
savefile!=None and plt.savefig(savefile)
plt.show()
def display(g, title):
"""Displays a graph with the given title."""
pos = nx.circular_layout(g)
plt.figure()
plt.title(title)
nx.draw(g, pos)
nx.draw_networkx_edge_labels(g, pos, font_size=20)
def circular_iter(G, start_pos=None):
if start_pos == None: start_pos = nx.circular_layout(G)
best_pos = start_pos.copy()
best_crossings = len(nx_detect_crosses(G,best_pos))
if best_crossings == 0:
return best_pos
for x in range(1,len(G.nodes())):
print "\nIteration number:",x
new_pos = all_pair_swaps(G, best_pos)
new_crossings = len(nx_detect_crosses(G,new_pos))
if new_crossings < best_crossings:
best_pos = new_pos.copy()
best_crossings = new_crossings
if best_crossings == 0:
print "Success! Zero crossings."
break
else:
print "Dead end! Progress stuck at {} crossings.".format(best_crossings)
break
return best_pos
def show_graph(self):
graph = nx.Graph(self.graph)
pos = nx.circular_layout(graph)
# pos=nx.spectral_layout(graph)
nx.draw_networkx_nodes(graph, pos, node_color="r", node_size=500, alpha=0.8)
nx.draw_networkx_edges(graph, pos, width=1, alpha=0.5)
nx.draw_networkx_edges(
graph, pos, edge_labels={}, edgelist=self.get_edgelist(), width=8, alpha=0.5, edge_color="r"
)
nx.draw_networkx_edge_labels(graph, pos, self.get_list_weights_edge(), label_pos=0.3)
labels = self.set_labels()
nx.draw_networkx_labels(graph, pos, labels, font_size=16)
plt.title("Dijkstra")
plt.text(
0.5,
0.97,
"Start: " + str(self.start) + " End: " + str(self.end),
horizontalalignment="center",
transform=plt.gca().transAxes,
)
plt.text(
0.5,
0.94,
"Shortest Path: " + str(self.shortest_path),
horizontalalignment="center",
transform=plt.gca().transAxes,
)
plt.text(
0.5, 0.90, "Weights: " + str(self.weights), horizontalalignment="center", transform=plt.gca().transAxes
)
plt.text(0.5, 0.86, "Pred: " + str(self.Preds), horizontalalignment="center", transform=plt.gca().transAxes)
plt.axis("off")
plt.ion()
plt.show()
def difference(graph2, graph1):
D1 = nx.difference(graph2, graph1)
pos = nx.circular_layout(D1)
D2 = nx.difference(graph1, graph2) # edges in graph1 but not in graph2
pos = nx.circular_layout(D2)
nx.draw_networkx_nodes(D1,pos, node_color="g", node_size=1000)
nx.draw_networkx_edges(D1,pos, edge_color='g',width=10)
nx.draw_networkx_nodes(D2,pos, node_color="r", node_size=1000)
nx.draw_networkx_edges(D2,pos, edge_color='r',width=10)
plt.show()
# plt.savefig("M.PDF",facecolor='pink') #save graph
return difference
def generate_minimum(self):
#ele gera a topologia (com pesos) e ja seta os ligados/desligados iniciais.
for food in self.food_list:
self.add_node(food, {'on': True,'Next': True, 'Threshold': 0}) #CORRIGIR ISSO PRA COMIDA QUE TA ERRADO!!!!!
self.colors.append(palette[1])
for gene in self.genes_list:
r = (True == rndm.randint(0,1))
self.add_node(gene, {'on': r, 'Next': r, 'Threshold': 0}) #QUANTO COLOCAR PARA O THRESHOLD?
self.add_edge(gene, gene, {'w': 1.0})
self.colors.append(palette[2 if r else 0])
if r:
self.switch_dict.update({gene: True})
for interm in self.intermediate_list:
r = (True == rndm.randint(0,1))
self.add_node(interm, {'on': r ,'Next': r , 'Threshold': interm % 2}) #quanto deve ser o threshold inicial??
self.add_edge(interm, interm, {'w': 1.0})
self.colors.append(palette[3 if r else 0])
pos2 = nx.circular_layout(self)
self.pos = {}
for i in self.control_list:
self.pos[i] = pos2[self.nodes()[self.control_list.index(i)]]
self.draw_BN(self.pos, self.control_list)
def draw_graph(graph, graph_layout='shell',
node_size=1600, node_color='blue', node_alpha=0.3, node_text_size=12,
edge_color='blue', edge_alpha=0.3, edge_tickness=1, edge_text_pos=0.3,
text_font='sans-serif', save=True, filename=None):
edge_labels=dict([((u,v,),d['weight']) for u,v,d in graph.edges(data=True)])
# these are different layouts for the network you may try
# shell seems to work best
if graph_layout == 'spring':
graph_pos=nx.spring_layout(graph)
elif graph_layout == 'spectral':
graph_pos=nx.spectral_layout(graph)
elif graph_layout == 'random':
graph_pos=nx.random_layout(graph)
elif graph_layout == 'circular':
graph_pos=nx.circular_layout(graph)
else:
graph_pos=nx.shell_layout(graph)
# draw graph
nx.draw_networkx_nodes(graph, graph_pos, node_size=node_size, alpha=node_alpha, node_color=node_color)
nx.draw_networkx_edges(graph, graph_pos, width=edge_tickness, alpha=edge_alpha, edge_color=edge_color)
nx.draw_networkx_labels(graph, graph_pos, font_size=node_text_size, font_family=text_font)
nx.draw_networkx_edge_labels(graph, graph_pos, edge_labels=edge_labels, label_pos=edge_text_pos)
# show graph
if save == True:
plt.savefig(filename, dpi=1000)
plt.show()
def generate_minimum(self):
#ele gera a topologia (com pesos) e ja seta os ligados/desligados iniciais.
for gene in range(self.number_genes):
r = (True == rndm.randint(0,1))
self.add_node(self.genes_list[gene], {'on': r or (gene in range(self.number_food_total)),'Next': r or (gene in range(self.number_food_total))})
if gene not in range(self.number_food_total):
self.add_edge(self.genes_list[gene], self.genes_list[gene], {'w': 1.0})
self.colors.append(palette[(r or (gene in range(self.number_food_total))) + 0])
if r and (gene not in range(self.number_food_total)): #or (gene1 in range(self.number_food_total)):
self.switch_dict.update({self.genes_list[gene]:True})
for interm in range(self.intermediate):
r = (True == rndm.randint(0,1))
self.add_node((interm,), {'on': r ,'Next': r })
self.colors.append(palette[r + 0])
## if r:
## self.switch_dict.update({(interm,):True})
pos2 = nx.circular_layout(self)
self.pos = {}
for i in self.genes_list + [(c,) for c in range(self.intermediate)]:
self.pos[i] = pos2[self.nodes()[(self.genes_list + [(c,) for c in range(self.intermediate)]).index(i)]]
self.draw_BN(self.pos, self.genes_list)
def test_from_networkx_dictionary_positions(self):
import networkx as nx
G = nx.Graph()
G.add_nodes_from([1, 2, 3])
positions = nx.circular_layout(G)
graph = Graph.from_networkx(G, positions)
self.assertEqual(graph.nodes.dimension_values(2), np.array([1, 2, 3]))
def updatePlot(G, position, spinUp, spinDown, upColor, downColor, ax, E, step):
"""
Updates plot of network for viewing MC moves.
"""
pl.cla()
position = nx.circular_layout(G)
nx.draw_networkx_nodes(G,position, nodelist=spinUp,
node_color=upColor)
nx.draw_networkx_nodes(G,position, nodelist=spinDown,
node_color=downColor)
nx.draw_networkx_edges(G,position)
nx.draw_networkx_labels(G,position)
ax.text(-0.1, 0.98, 'Spin Up', style='italic',
bbox={'facecolor':upColor, 'alpha':0.9, 'pad':10})
ax.text(-0.1, 1.1, 'Spin Down', style='italic',color='White',
bbox={'facecolor':downColor, 'alpha':0.9, 'pad':10})
if E:
os.chdir('./data/')
if os.path.exists('./animate'):
pass
else:
os.mkdir('./animate/')
os.chdir('./animate/')
pl.savefig('animate_'+str(step)+'.png')
os.chdir('../..')
pl.draw()
def generate_minimum(self):
#ele gera a topologia (com pesos) e ja seta os ligados/desligados iniciais.
for gene in range(self.number_genes):
r = (True == rndm.randint(0,1))
self.add_node(self.genes_list[gene], {'on': r or (gene in range(Constants.food)),'Next': r or (gene in range(Constants.food)), 'Threshold': 0})
if gene not in range(Constants.food):
self.add_edge(self.genes_list[gene], self.genes_list[gene], {'w': 1.0})
self.colors.append(palette[2 if r else 0])
else:
self.colors.append(palette[1])
if r and (gene not in range(Constants.food)): #or (gene1 in range(Constants.food)):
self.switch_dict.update({self.genes_list[gene]:True})
for interm in range(Constants.intermediate):
r = (True == rndm.randint(0,1))
self.add_node(interm + Constants.metabolites + Constants.reactions, {'on': r ,'Next': r , 'Threshold': interm % 2}) #quanto deve ser o threshold inicial??
self.colors.append(palette[3 if r else 0])
pos2 = nx.circular_layout(self)
self.pos = {}
for i in self.genes_list + [c + Constants.metabolites + Constants.reactions for c in range(Constants.intermediate)]:
self.pos[i] = pos2[self.nodes()[(self.genes_list + [c + Constants.metabolites + Constants.reactions for c in range(Constants.intermediate)]).index(i)]]
self.draw_BN(self.pos, self.genes_list)
def displayEigenRankBlendGoogle(self, nodummyvariablelist, alpha, nodepos=None):
"""This method displays the blended weightings of nodes i.e. it takes
both forward and backward rankings into account.
Note that this is purely ranking i.e. the standard google rankings do
not come into play yet."""
self.blendedrankingGoogle = dict()
for variable in nodummyvariablelist:
self.blendedrankingGoogle[variable] = (1 - alpha) * self.gfgain.rankDict[variable] + (alpha) * self.gbgain.rankDict[variable]
self.EBGG = nx.DiGraph()
for i in range(self.normalforwardgain.n):
for j in range(self.normalforwardgain.n):
if (self.normalforwardgain.gMatrix[i, j] != 0):
self.EBGG.add_edge(self.normalforwardgain.gVariables[j], self.normalforwardgain.gVariables[i]) #draws the connectivity graph to visualise rankArray
plt.figure("Blended Node Rankings: Google")
rearrange = self.EBGG.nodes()
for node in self.EBGG.nodes():
self.EBGG.add_node(node, importance=self.blendedrankingGoogle[node])
nodelabels = dict((n, [n, round(self.blendedrankingGoogle[n], 3)]) for n in self.EBGG.nodes())
sizeArray = [self.blendedrankingGoogle[var] * 10000 for var in rearrange]
if nodepos == None:
nodepos = nx.circular_layout(self.EBGG)
nx.draw_networkx(self.EBGG, pos=nodepos , labels=nodelabels, node_size=sizeArray, node_color='y')
nx.draw_networkx_edges(self.EBGG, pos=nodepos)
plt.axis("off")
def displayEdgeWeights(self, nodepos=None):
"""This method will compute and store the edge weights of the ranking web.
It *NEEDS* the methods displayEigenBlend and displayEigenBlendGoogle to have
been run!"""
self.P = nx.DiGraph()
self.edgelabels = dict()
for i in range(self.normalforwardgain.n):
for j in range(self.normalforwardgain.n):
if (self.normalforwardgain.gMatrix[i, j] != 0):
temp = self.normalforwardgain.gMatrix[i, j] * self.blendedranking[self.normalforwardgain.gVariables[j]] - self.blendedrankingGoogle[self.normalforwardgain.gVariables[j]] * self.normalforwardgoogle.gMatrix[i, j]
self.edgelabels[(self.normalforwardgain.gVariables[j], self.normalforwardgain.gVariables[i])] = round(-1 * temp, 4)
self.P.add_edge(self.normalforwardgain.gVariables[j], self.normalforwardgain.gVariables[i], weight= -1 * temp)
plt.figure("Edge Weight Graph")
for node in self.P.nodes():
self.P.add_node(node, importanceNormal=self.blendedranking[node])
self.P.add_node(node, importanceGoogle=self.blendedrankingGoogle[node])
if nodepos == None:
nodepos = nx.circular_layout(self.P)
nx.draw_networkx(self.P, pos=nodepos)
nx.draw_networkx_edge_labels(self.P, pos=nodepos, edge_labels=self.edgelabels, label_pos=0.3)
nx.draw_networkx_edges(self.P, pos=nodepos, width=2.5, edge_color='k', style='solid', alpha=0.15)
nx.draw_networkx_nodes(self.P, pos=nodepos, node_color='y', node_size=450)
plt.axis("off")
def displayEigenRankGGb(self, nodepos=None):
"""This method constructs a network graph showing connections and rankings
in terms of node size going BACKWARD and using unity gains between all node
i.e. the google rank.
It has an optional parameter nodepos which sets the positions of the nodes,
if left out the node layout defaults to circular. """
self.GGB = nx.DiGraph()
for i in range(self.gbgain.n):
for j in range(self.gbgain.n):
if (self.gbgain.gMatrix[i, j] != 0):
self.GGB.add_edge(self.gbgain.gVariables[j], self.gbgain.gVariables[i])
plt.figure("Node Rankings: Google Gain Backward: Scaled")
rearrange = self.GGB.nodes()
for node in self.GGB.nodes():
self.GGB.add_node(node, importance=self.gbgain.rankDict[node])
nodelabels = dict((n, [n, round(self.gbgain.rankDict[n], 3)]) for n in self.GGB.nodes())
sizeArray = [self.gbgain.rankDict[var] * 10000 for var in rearrange]
if nodepos == None:
nodepos = nx.circular_layout(self.GGB)
nx.draw_networkx(self.GGB, pos=nodepos , labels=nodelabels, node_size=sizeArray, node_color='y')
nx.draw_networkx_edges(self.GGB, pos=nodepos)
plt.axis("off")
def draw(self):
"""Draws the current game state."""
unavailables = []
availables = []
reds = []
blues = []
for i in self.graph.nodes_iter():
if self.graph.node[i]["label"] == labels.AVAILABLE:
availables.append(i)
elif self.graph.node[i]["label"] == labels.RED:
reds.append(i)
elif self.graph.node[i]["label"] == labels.BLUE:
blues.append(i)
else:
unavailables.append(i)
node_labels = {}
for i in self.graph.nodes_iter():
node_labels[i] = i
pos = nx.circular_layout(self.graph)
nx.draw_networkx_edges(self.graph, pos, edgelist=self.graph.edges(), width=4)
nx.draw_networkx_nodes(self.graph, pos, nodelist=availables, node_color="w", node_size=500, alpha=1)
nx.draw_networkx_nodes(self.graph, pos, nodelist=reds, node_color="r", node_size=500, alpha=1)
nx.draw_networkx_nodes(self.graph, pos, nodelist=blues, node_color="b", node_size=500, alpha=1)
nx.draw_networkx_nodes(self.graph, pos, nodelist=unavailables, node_color="black", node_size=500, alpha=0.6)
nx.draw_networkx_node_labels(self.graph, pos, node_labels, font_size=16)
def topology(g):
if g.size() > 30:
print "Not drawing topology as size > 30"
else:
networkx.draw(g, pos=networkx.circular_layout(g))
pylab.savefig("topology.png")
pylab.clf()
def get(self):
G = nx.Graph()
self.add_header("Access-Control-Allow-Origin", "*")
n_name = self.get_argument('cnode')
lt = list(one_x_extend(n_name))
rtid = {"nodes":[],"links":[]}
for item in cast_path_2_node(lt):
tmp = {"name":str(item)}
rtid["nodes"].append(tmp)
cdict = {}
for item in enumerate(cast_path_2_node(lt)):
cdict[str(item[1])] = item[0]
for item in cast_path_2_link(lt):
G.add_edge(item[0],item[1])
tmp = {"source":item[0],"target":item[1]}
rtid["links"].append(tmp)
co = choice('01')
#pos = nx.spring_layout(G, scale=1.0)
if co == '0':
pos = nx.circular_layout(G)
elif co == '1':
pos = nx.spring_layout(G)
else:
pos = nx.shell_layout(G)
text = ''.join(cast_dict_2_gexf(rtid,pos))
print text
self.write(text)
def visualize_weighted_graph(file_name):
"""@todo: Given a file with file that is a graph with first
column a vertex and preceding columns
its neighbors and there distances, neighbors are separated by commas
:a_file: name of the file
:creates: graph visualization of the Graph and saves it as a file_name.png
"""
G = nx.Graph()
with open(file_name) as f:
for line in f:
if line:
line = line.split()
v1, neighbors = line[0],line[1:]
for neighbor in neighbors:
v2, weight = neighbor.split(',')
G.add_edge(v1, v2, weight=int(weight))
pos=nx.circular_layout(G)
pylab.figure(2)
nx.draw(G,pos)
edge_labels=dict([((u,v,),d['weight'])
for u,v,d in G.edges(data=True)])
nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels)
pylab.savefig(file_name.replace('txt','png'))
def displayEigenRankNormalBackward(self, nodepos=None):
"""This method constructs a network graph showing connections and rankings
in terms of node size going BACKWARD and using the local gains. (it is not
scaled)
It has an optional parameter nodepos which sets the positions of the nodes,
if left out the node layout defaults to circular. """
self.NBG = nx.DiGraph()
for i in range(self.normalbackwardgain.n):
for j in range(self.normalbackwardgain.n):
if (self.normalbackwardgain.gMatrix[i, j] != 0):
self.NBG.add_edge(self.normalbackwardgain.gVariables[j], self.normalbackwardgain.gVariables[i]) #draws the connectivity graph to visualise rankArray
plt.figure("Node Rankings: Local Gain Backward: Normal")
rearrange = self.NBG.nodes()
for node in self.NBG.nodes():
self.NBG.add_node(node, importance=self.normalbackwardgain.rankDict[node])
nodelabels = dict((n, [n, round(self.normalbackwardgain.rankDict[n], 3)]) for n in self.NBG.nodes())
sizeArray = [self.normalbackwardgain.rankDict[var] * 10000 for var in rearrange]
if nodepos == None:
nodepos = nx.circular_layout(self.NBG)
nx.draw_networkx(self.NBG, pos=nodepos , labels=nodelabels, node_size=sizeArray, node_color='y')
nx.draw_networkx_edges(self.NBG, pos=nodepos)
plt.axis("off")
def transmission(path,g,src,dest):
global disp_count
global bar_colors
global edge_colors
global node_colors
k=0
j=0
list_of_edges = g.edges()
for node in path :
k=path.index(node)
disp_count = disp_count + 1
if k != (len(path)-1):
k=path[k+1]
j=list_of_edges.index((node,k))
initialize_edge_colors(j)
#ec[disp_count].remove(-3000)
pylab.subplot(121)
nx.draw_networkx(g,pos = nx.circular_layout(g),node_color= node_colors,edge_color = edge_colors)
pylab.annotate("Source",node_positions[src])
pylab.annotate("Destination",node_positions[dest])
pylab.title("Transmission")
he=initializeEnergies(disp_count)
print he
pylab.subplot(122)
pylab.bar(left=[1,2,3,4,5],height=[300,300,300,300,300],width=0.5,color = ['w','w','w','w','w'],linewidth=0)
pylab.bar(left=[1,2,3,4,5],height=initializeEnergies(disp_count),width=0.5,color = 'b')
pylab.title("Node energies")
#pylab.legend(["already passed throgh","passing" , "yet to pass"])
pylab.xlabel('Node number')
pylab.ylabel('Energy')
pylab.suptitle('Leach Protocol', fontsize=12)
pylab.pause(2)
else :
return
def printClusters(msp_list_deleted, msp_list_remain, msp_list, name):
G = nx.Graph()
deleted = nx.Graph()
remain = nx.Graph()
for l in range(0, len(msp_list)):
G.add_edge(msp_list[l][1], msp_list[l][2], weight="{0:.2f}".format(msp_list[l][0]))
pos = nx.circular_layout(G)
for l in range(0, len(msp_list_deleted)):
deleted.add_edge(msp_list_deleted[l][1], msp_list_deleted[l][2],
weight="{0:.2f}".format(msp_list_deleted[l][0]))
for l in range(0, len(msp_list_remain)):
remain.add_edge(msp_list_remain[l][1], msp_list_remain[l][2], weight="{0:.2f}".format(msp_list_remain[l][0]))
nx.draw(G, pos)
edge_labels = dict([((u, v,), d['weight']) for u, v, d in G.edges(data=True)])
edge_labels_deleted = dict([((u, v,), d['weight']) for u, v, d in deleted.edges(data=True)])
edge_labels_remain = dict([((u, v,), d['weight']) for u, v, d in remain.edges(data=True)])
nx.draw_networkx_edges(G, pos, edge_labels=edge_labels_deleted)
nx.draw_networkx_edge_labels(remain, pos, edge_labels=edge_labels)
nx.draw_networkx_edges(deleted, pos, edge_labels=edge_labels_remain, width=3, edge_color='w', style='dashed')
plt.savefig(name + ".png")
import sys
import networkx as nx
import matplotlib.pyplot as plt
from antlr4 import *
from EnquestesLexer import EnquestesLexer
from EnquestesParser import EnquestesParser
from antlr4.InputStream import InputStream
from EnquestesVisitor import EnquestesVisitor
if len(sys.argv) > 1:
input_stream = FileStream(sys.argv[1], encoding='utf-8')
else:
input_stream = InputStream(input('? '))
lexer = EnquestesLexer(input_stream)
token_stream = CommonTokenStream(lexer)
parser = EnquestesParser(token_stream)
tree = parser.chatboot()
print(tree.toStringTree(recog=parser))
visitor = EnquestesVisitor()
arbol = visitor.visit(tree)
nx.write_gpickle(arbol, "../boot/arbol.pickle")
pos = nx.circular_layout(arbol)
colors = [arbol[u][v]['color'] for u, v in arbol.edges()]
nx.draw(arbol, pos, with_labels=True, edge_color=colors)
plt.show()
def test_edge_colors_and_widths(self):
pos = nx.circular_layout(self.G)
for G in (self.G, self.G.to_directed()):
nx.draw_networkx_nodes(G, pos, node_color=[(1.0, 1.0, 0.2, 0.5)])
nx.draw_networkx_labels(G, pos)
# edge with default color and width
nx.draw_networkx_edges(G,
pos,
edgelist=[(0, 1)],
width=None,
edge_color=None)
# edges with global color strings and widths in lists
nx.draw_networkx_edges(G,
pos,
edgelist=[(0, 2), (0, 3)],
width=[3],
edge_color=['r'])
# edges with color strings and widths for each edge
nx.draw_networkx_edges(G,
pos,
edgelist=[(0, 2), (0, 3)],
width=[1, 3],
edge_color=['r', 'b'])
# edges with fewer color strings and widths than edges
nx.draw_networkx_edges(G,
pos,
edgelist=[(1, 2), (1, 3), (2, 3), (3, 4)],
width=[1, 3],
edge_color=['g', 'm', 'c'])
# edges with more color strings and widths than edges
nx.draw_networkx_edges(G,
pos,
edgelist=[(3, 4)],
width=[1, 2, 3, 4],
edge_color=['r', 'b', 'g', 'k'])
# with rgb tuple and 3 edges - is interpreted with cmap
nx.draw_networkx_edges(G,
pos,
edgelist=[(4, 5), (5, 6), (6, 7)],
edge_color=(1.0, 0.4, 0.3))
# with rgb tuple in list
nx.draw_networkx_edges(G,
pos,
edgelist=[(7, 8), (8, 9)],
edge_color=[(0.4, 1.0, 0.0)])
# with rgba tuple and 4 edges - is interpretted with cmap
nx.draw_networkx_edges(G,
pos,
edgelist=[(9, 10), (10, 11), (10, 12),
(10, 13)],
edge_color=(0.0, 1.0, 1.0, 0.5))
# with rgba tuple in list
nx.draw_networkx_edges(G,
pos,
edgelist=[(9, 10), (10, 11), (10, 12),
(10, 13)],
edge_color=[(0.0, 1.0, 1.0, 0.5)])
# with color string and global alpha
nx.draw_networkx_edges(G,
pos,
edgelist=[(11, 12), (11, 13)],
edge_color='purple',
alpha=0.2)
# with color string in a list
nx.draw_networkx_edges(G,
pos,
edgelist=[(11, 12), (11, 13)],
edge_color=['purple'])
# with single edge and hex color string
nx.draw_networkx_edges(G,
pos,
edgelist=[(12, 13)],
edge_color='#1f78b4f0')
# edge_color as numeric using vmin, vmax
nx.draw_networkx_edges(G,
pos,
edgelist=[(7, 8), (8, 9)],
edge_color=[0.2, 0.5],
edge_vmin=0.1,
edge_max=0.6)
plt.show()
def plot_circular(G,
labels=None,
dist_text=1.2,
cmap="Blues",
color_nodes=(),
title=""):
"""Plot G as a circular graph.
Usage
-----
import networkx as nx
G = nx.from_numpy_matrix(A)
fig = plot_circular(G, labels)
py.offline.iplot(fig, filename='networkx')
"""
if labels is None:
labels = [r"$x_%d$" % i for i in G.nodes]
pos = nx.circular_layout(G)
dmin = 1
# ncenter = 0
for n in pos:
x, y = pos[n]
d = (x - 0.5)**2 + (y - 0.5)**2
if d < dmin:
# ncenter = n
dmin = d
# pp = nx.single_source_shortest_path_length(G, ncenter)
pos_array = np.array(list(pos.values())) # python 3 compatibility
center = np.array([
(np.min(pos_array[:, 0]) + np.max(pos_array[:, 0])) / 2,
(np.min(pos_array[:, 1]) + np.max(pos_array[:, 1])) / 2,
])
# radius = np.linalg.norm(pos_array - center)
pos_text = center + dist_text * (pos_array - center) # text position
# Compute the text angle
angles = -180 * np.arctan(
(pos_array[:, 1] - center[1]) / (pos_array[:, 0] - center[0])) / np.pi
axis = dict(showgrid=False, zeroline=False, showticklabels=False)
layout = go.Layout(
title=title,
titlefont=dict(size=16),
showlegend=False,
hovermode="closest",
margin=dict(b=40, l=5, r=5, t=40),
width=650,
height=650,
annotations=[
# dict(
# text=
# "Python code: <a href='https://plot.ly/ipython-notebooks/network-graphs/'> https://plot.ly/ipython-notebooks/network-graphs/</a>",
# showarrow=False, xref="paper", yref="paper", x=0.005, y=-0.002)
],
xaxis=dict(axis),
yaxis=dict(axis),
)
# annotations around the circle
# textangle=angles[k] is the angle with horizontal line through (x,y)
# in degrees
# + =clockwise, -=anti-clockwise
layout["annotations"] += tuple([
go.layout.Annotation(
x=pos_text[k][0],
y=pos_text[k][1],
text=labels[k],
textangle=angles[k],
font=dict(size=20, color="rgb(0,0,0)"),
showarrow=False,
) for k in range(pos_array.shape[0])
])
# V = list(G.nodes())
Es = G.edges()
Weights = [edge["weight"] for edge in Es.values()]
edge_trace = lines_chord(G, pos, labels, Weights, cmap=cmap)
node_trace = go.Scatter(
x=[],
y=[],
text=[],
mode="markers",
hoverinfo="text",
marker=dict(
showscale=False,
colorscale=cmap,
reversescale=True,
color=color_nodes,
size=20,
colorbar=dict(thickness=15,
title="Node Connections",
xanchor="left",
titleside="right"),
line=dict(width=2),
),
)
for node in G.nodes():
x, y = pos[node]
node_trace["x"] += tuple([x])
node_trace["y"] += tuple([y])
for node, adjacencies in enumerate(G.adjacency()):
node_trace["marker"]["color"] += tuple([len(adjacencies[1])])
node_info = "# of connections: {}".format(len(adjacencies[1]))
node_trace["text"] += tuple([node_info])
data = edge_trace + [node_trace]
return go.Figure(data=data, layout=layout)
nodes_reflex = {'Luis(15)','Fernando(16)','Julia(18)'}
nodes_no_reflex = {'Maria(15)','Yanet(17)','Rosi(16)','Desisy(18)',
'Pedro(17)','Claudia(16)'}
black=[('Maria(15)','Yanet(17)'),
('Maria(15)','Fernando(16)'),('Fernando(16)','Desisy(18)'),
('Yanet(17)','Julia(18)'),('Desisy(18)','Pedro(17)'),
('Pedro(17)','Julia(18)'), ('Pedro(17)','Rosi(16)'),
('Fernando(16)','Claudia(16)')]
bl=[('Fernando(16)','Desisy(18)'),('Pedro(17)','Rosi(16)')]
lista=['Luis(15)','Julia(18)','Yanet(17)','Rosi(16)','Desisy(18)','Claudia(16)'], ['Maria(15)','Fernando(16)','Pedro(17)']
posicion=nx.circular_layout(A, scale=0.5, center=None, dim=2)
nx.draw_networkx_nodes(A,posicion,nodelist=nodes_reflex,
node_size=1800, node_color= '#ea6d6d')
nx.draw_networkx_nodes(A,posicion,nodelist=nodes_no_reflex,
node_size=1500, node_color= '#cde95b')
nx.draw_networkx_edges(A, posicion, edgelist=bl, width=5, alpha=0.5,
edge_color='b')
nx.draw_networkx_edges(A, posicion, edgelist=black, width=2,
edge_color='Black')
nx.draw_networkx_labels(A,posicion, font_size=11,font_family='arial',
font_color='#4f5148', font_weight='bold')
plot.axis('off')
plot.savefig("Graf9_circular_layout.eps")
plot.show(A)
def completed_graph(inchikey):
#graphs generated using PIBAS dataset, UniChem and Bio2RDF
G6 = nx.Graph()
G8 = nx.Graph()
#we start from PIBAS local ontology and for a given InChiKey we found compound acronym
sparql = SPARQLWrapper("http://cpctas-lcmb.pmf.kg.ac.rs:2020/sparql")
sparql.setQuery(
"""
PREFIX pibas: <http://cpctas-lcmb.pmf.kg.ac.rs/2012/3/PIBAS#>
SELECT ?pibas_compound_acronym ?inchikey
FROM <http://cpctas-lcmb.pmf.kg.ac.rs/2012/3/PIBAS/pibasOntology.owl>
WHERE
{
?pibas_compound pibas:InChIkey ?inchikey;
pibas:acronym ?pibas_compound_acronym.
FILTER(?inchikey="%s").
}
"""% inchikey)
sparql.setReturnFormat(JSON)
final_results = sparql.query().convert()
for result in final_results["results"]["bindings"]:
pibas_acronym=result["pibas_compound_acronym"]["value"]
#print pibas_acronym
#add pibas acronym in corresponding form to G6 graph
pibas_node=pibas_acronym.split(':')[0]+'/'+pibas_acronym.split(':')[1]
G6.add_node(0,name_label=pibas_node)
#for a given acronym and PIBAS mapp we found mapping substance
sparql.setQuery(
"""
PREFIX pibas: <http://cpctas-lcmb.pmf.kg.ac.rs/2012/3/PIBAS#>
SELECT ?mapping_node ?sourceNumber
FROM <http://cpctas-lcmb.pmf.kg.ac.rs/2012/3/PIBAS/pibasmapping.owl>
WHERE
{
%s pibas:sameAs ?mapping_node;
pibas:sourceNumber ?sourceNumber.
}
"""% pibas_acronym)
sparql.setReturnFormat(JSON)
final_results = sparql.query().convert()
for result in final_results["results"]["bindings"]:
pibas_mapping=result["mapping_node"]["value"].split(':')[0]+'/'+result["mapping_node"]["value"].split(':')[1]
pibas_mapping_source_number=result["sourceNumber"]["value"]
#print pibas_mapping
#add pibas mapping node to graph G6
G6.add_node(1,name_label=pibas_mapping)
url = 'https://www.ebi.ac.uk/unichem/rest/src_compound_id_all/'+str(pibas_mapping.split('/')[1])+'/'+str(pibas_mapping_source_number)
#print url
j=2
storage = StringIO()
c = pycurl.Curl()
c.setopt(c.URL, url)
c.setopt(c.WRITEFUNCTION, storage.write)
c.perform()
c.close()
content = storage.getvalue()
unichem_content = json.loads(content)
for rs in unichem_content:
src_compound_id= rs['src_compound_id']
url = 'https://www.ebi.ac.uk/unichem/rest/sources/'+rs['src_id']
storage = StringIO()
c = pycurl.Curl()
c.setopt(c.URL, url)
c.setopt(c.WRITEFUNCTION, storage.write)
c.perform()
c.close()
content = storage.getvalue()
unichem_src_name = json.loads(content)
for rs in unichem_src_name:
name=rs['name']
#print name
if ((name+'/'+src_compound_id)!=pibas_mapping):
if((name+'/'+src_compound_id)!=pibas_node):
G6.add_node(j,name_label=name+'/'+src_compound_id)
j=j+1
bio2rdf_dataset=['bindingdb','pubchem','pharmgkb','chebi','kegg_ligand','pdb','drugbank','chembl','pibas','ndc']
num1=G6.number_of_nodes()
nodes1=G6.nodes()
for x in range(0, num1):
if(((G6.node[x]['name_label']).split('/')[0] in bio2rdf_dataset) and ("pibas" not in (G6.node[x]['name_label']).split('/')[0])):
sparql = SPARQLWrapper("http://cpctas-lcmb.pmf.kg.ac.rs:2020/sparql")
if((G6.node[x]['name_label']).split('/')[0]=='kegg_ligand'):
sparql.setQuery(
"""
PREFIX bindingdb: <http://bio2rdf.org/bindingdb:>
PREFIX pubchem: <http://bio2rdf.org/pubchem:>
PREFIX pharmgkb: <http://bio2rdf.org/pharmgkb:>
PREFIX chebi: <http://bio2rdf.org/chebi:>
PREFIX kegg_ligand: <http://bio2rdf.org/kegg:>
PREFIX pdb: <http://bio2rdf.org/pdb:>
PREFIX drugbank: <http://bio2rdf.org/drugbank:>
PREFIX chembl: <http://bio2rdf.org/chembl:>
PREFIX ndc: <http://bio2rdf.org/ndc:>
select ?p ?o
WHERE
{
SERVICE SILENT<http://kegg.bio2rdf.org/sparql> {
OPTIONAL{
%s:%s ?p ?o.
FILTER(CONTAINS(str(?p),"http://bio2rdf.org/kegg_vocabulary:x-drugbank") || CONTAINS(str(?p),"http://bio2rdf.org/kegg_vocabulary:x-pubchem.compound") || CONTAINS(str(?p),"http://bio2rdf.org/kegg_vocabulary:x-kegg") || CONTAINS(str(?p),"http://bio2rdf.org/kegg_vocabulary:x-chembl") || CONTAINS(str(?p),"http://bio2rdf.org/kegg_vocabulary:x-chebi") || CONTAINS(str(?p),"http://bio2rdf.org/kegg_vocabulary:same-as")).
}
}
}
""" % (((G6.node[x]['name_label']).split('/')[0]),((G6.node[x]['name_label']).split('/')[1])))
else:
sparql.setQuery(
"""
PREFIX bindingdb: <http://bio2rdf.org/bindingdb:>
PREFIX pubchem: <http://bio2rdf.org/pubchem:>
PREFIX pharmgkb: <http://bio2rdf.org/pharmgkb:>
PREFIX chebi: <http://bio2rdf.org/chebi:>
PREFIX kegg_ligand: <http://bio2rdf.org/kegg:>
PREFIX pdb: <http://bio2rdf.org/pdb:>
PREFIX drugbank: <http://bio2rdf.org/drugbank:>
PREFIX chembl: <http://bio2rdf.org/chembl:>
PREFIX ndc: <http://bio2rdf.org/ndc:>
select ?p ?o
WHERE
{
SERVICE SILENT<http://%s.bio2rdf.org/sparql> {
OPTIONAL{
%s:%s ?p ?o.
FILTER(CONTAINS(str(?p),"http://bio2rdf.org/%s_vocabulary:x-drugbank") || CONTAINS(str(?p),"http://bio2rdf.org/%s_vocabulary:x-pubchem.compound") || CONTAINS(str(?p),"http://bio2rdf.org/%s_vocabulary:x-kegg") || CONTAINS(str(?p),"http://bio2rdf.org/%s_vocabulary:x-chembl") || CONTAINS(str(?p),"http://bio2rdf.org/%s_vocabulary:x-chebi") || CONTAINS(str(?p),"http://bio2rdf.org/%s_vocabulary:x-ndc") || CONTAINS(str(?p),"http://bio2rdf.org/%s_vocabulary:same-as")).
}
}
}
""" % (((G6.node[x]['name_label']).split('/')[0]),((G6.node[x]['name_label']).split('/')[0]),((G6.node[x]['name_label']).split('/')[1]),((G6.node[x]['name_label']).split('/')[0]),((G6.node[x]['name_label']).split('/')[0]),((G6.node[x]['name_label']).split('/')[0]),((G6.node[x]['name_label']).split('/')[0]),((G6.node[x]['name_label']).split('/')[0]),((G6.node[x]['name_label']).split('/')[0]),((G6.node[x]['name_label']).split('/')[0])))
sparql.setReturnFormat(JSON)
final_results1 = sparql.query().convert()
try:
v=G6.number_of_nodes()
for result1 in final_results1["results"]["bindings"]:
if(result1["o"]["value"]!=""):
node_for_add=result1["o"]["value"]
node_of_second_level=node_for_add.split("/")[-1]
if(node_of_second_level.split(':')[0]=='kegg'):
node_for_add='kegg_ligand/'+node_of_second_level.split(':')[1]
else:
node_for_add=node_of_second_level.split(':')[0]+'/'+node_of_second_level.split(':')[1]
#print node_for_add
compare_node=[]
for x in range(0,G6.number_of_nodes()):
compare_node.append(str((G6.node[x]['name_label']).split('/')[0])+'/'+str((G6.node[x]['name_label']).split('/')[1]))
if(node_for_add not in compare_node):
G6.add_node(v,name_label=node_for_add,predicate=result1["p"]["value"])
v=v+1
#print v
except:
continue
nodes=G6.nodes()
#print nodes
edges = combinations(nodes, 2)
G6.add_nodes_from(nodes)
G6.add_edges_from(edges)
num1=G6.number_of_nodes()
nodes1=G6.nodes()
left_graph_for_remove=[]
for x in range(0, num1):
if(((G6.node[x]['name_label']).split('/')[0] not in bio2rdf_dataset)):
G6.remove_node(x)
nodes1=G6.nodes()
#print nodes1
custom_labels1={}
for x in nodes1:
custom_labels1[x] = str(x)+':'+G6.node[x]['name_label']
#print custom_labels1
#create and draw graph G6
pos=nx.circular_layout(G6,dim=2, scale=100)
plt.clf()
nx.draw(G6, labels=custom_labels1, with_labels=True)
plt.savefig('/var/www/specint.org/public_html/specint/img/completed_graph_bio2rdf_'+inchikey+'.png')
#******************Using Chem2Bio2RDF***********************************************************************************
G7 = nx.Graph()
index_for_new_graph=max(G6.nodes())
#print index_for_new_graph
url = 'https://www.ebi.ac.uk/unichem/rest/inchikey/'+inchikey
#print url
j=index_for_new_graph+1
storage = StringIO()
c = pycurl.Curl()
c.setopt(c.URL, url)
c.setopt(c.WRITEFUNCTION, storage.write)
c.perform()
c.close()
content = storage.getvalue()
unichem_content = json.loads(content)
for rs in unichem_content:
src_compound_id= rs['src_compound_id']
url = 'https://www.ebi.ac.uk/unichem/rest/sources/'+rs['src_id']
storage = StringIO()
c = pycurl.Curl()
c.setopt(c.URL, url)
c.setopt(c.WRITEFUNCTION, storage.write)
c.perform()
c.close()
content = storage.getvalue()
unichem_src_name = json.loads(content)
for rs in unichem_src_name:
name=rs['name']
#print name
G7.add_node(j,name_label=name+'/'+src_compound_id)
j=j+1
chem2bio2rdf_dataset=['bindingdb','pubchem','chebi','kegg_ligand','kegg','pdb','drugbank','chembl','uniprot','matador','ctd','dcdb','hgnc','pharmgkb','hprd']
num1=G7.number_of_nodes()
nodes1=G7.nodes()
for x in range(index_for_new_graph+1,index_for_new_graph+num1):
if(((G7.node[x]['name_label']).split('/')[0] in bio2rdf_dataset) and ("chembl" not in (G7.node[x]['name_label']).split('/')[0])):
sparql = SPARQLWrapper("http://cpctas-lcmb.pmf.kg.ac.rs:2020/sparql")
if((G7.node[x]['name_label']).split('/')[0]=='kegg_ligand'):
sparql.setQuery(
"""
PREFIX bindingdb: <http://chem2bio2rdf.org/bindingdb/resource/>
PREFIX pubchem: <http://chem2bio2rdf.org/pubchem/resource/>
PREFIX uniprot: <http://chem2bio2rdf.org/uniprot/resource/>
PREFIX chebi: <http://chem2bio2rdf.org/chebi/resource/chebi/CHEBI~>
PREFIX kegg_ligand: <http://chem2bio2rdf.org/kegg/resource/kegg_ligand/>
PREFIX pdb: <http://chem2bio2rdf.org/pdb/resource/pdb_ligand/>
PREFIX drugbank: <http://chem2bio2rdf.org/drugbank/resource/>
PREFIX matador: <http://chem2bio2rdf.org/matador/resource/>
PREFIX chembl: <http://chem2bio2rdf.org/chembl/resource/>
PREFIX uniprot: <http://chem2bio2rdf.org/uniprot/resource/>
PREFIX db: <http://chem2bio2rdf.org/kegg/resource/>
select ?o
WHERE
{
SERVICE SILENT<http://cheminfov.informatics.indiana.edu:8080/kegg/sparql> {
OPTIONAL{
%s:%s db:CID ?o.
}
}
}
""" % (((G7.node[x]['name_label']).split('/')[0]),((G7.node[x]['name_label']).split('/')[1])))
elif((G7.node[x]['name_label']).split('/')[0]=='drugbank'):
sparql.setQuery(
"""
PREFIX db:<http://chem2bio2rdf.org/drugbank/resource/>
PREFIX drugbank:<http://chem2bio2rdf.org/drugbank/resource/drugbank_drug/>
select ?o
WHERE
{
SERVICE SILENT<http://147.91.203.161:8890/sparql>{
drugbank:%s db:CID ?o.
}
}
""" % (G7.node[x]['name_label']).split('/')[1])
else:
sparql.setQuery(
"""
PREFIX bindingdb: <http://bio2rdf.org/bindingdb:>
PREFIX pubchem: <http://bio2rdf.org/pubchem:>
PREFIX pharmgkb: <http://bio2rdf.org/pharmgkb:>
PREFIX chebi: <http://bio2rdf.org/chebi:>
PREFIX kegg_ligand: <http://bio2rdf.org/kegg:>
PREFIX pdb: <http://bio2rdf.org/pdb:>
PREFIX drugbank: <http://bio2rdf.org/drugbank:>
PREFIX chembl: <http://bio2rdf.org/chembl:>
PREFIX ndc: <http://bio2rdf.org/ndc:>
PREFIX db: <http://chem2bio2rdf.org/%s/resource/>
select ?o
WHERE
{
SERVICE SILENT<http://cheminfov.informatics.indiana.edu:8080/%s/sparql> {
OPTIONAL{
%s:%s db:CID ?o.
}
}
}
""" % (((G7.node[x]['name_label']).split('/')[0]),((G7.node[x]['name_label']).split('/')[0]),((G7.node[x]['name_label']).split('/')[0]),((G7.node[x]['name_label']).split('/')[1])))
sparql.setReturnFormat(JSON)
final_results1 = sparql.query().convert()
try:
v=G7.number_of_nodes()
for result1 in final_results1["results"]["bindings"]:
if(result1["o"]["value"]!=""):
node_for_add=result1["o"]["value"]
node_of_second_level=node_for_add.split("/")[-1]
if(node_of_second_level.split(':')[0]=='kegg'):
node_for_add='kegg_ligand/'+node_of_second_level.split(':')[1]
else:
node_for_add=node_of_second_level.split(':')[0]+'/'+node_of_second_level.split(':')[1]
#print node_for_add
compare_node=[]
for x in range(index_for_new_graph+1,index_for_new_graph+num1):
compare_node.append(str((G7.node[x]['name_label']).split('/')[0])+'/'+str((G7.node[x]['name_label']).split('/')[1]))
if(node_for_add not in compare_node):
G7.add_node(v,name_label=node_for_add,predicate=result1["p"]["value"])
v=v+1
#print v
except:
continue
nodes=G7.nodes()
#print nodes
edges = combinations(nodes, 2)
G7.add_nodes_from(nodes)
G7.add_edges_from(edges)
num1=G7.number_of_nodes()
nodes1=G7.nodes()
left_graph_for_remove=[]
for x in nodes1:
if(((G7.node[x]['name_label']).split('/')[0] not in chem2bio2rdf_dataset)):
G7.remove_node(x)
nodes1=G7.nodes()
custom_labels1={}
for x in nodes1:
custom_labels1[x] = str(x)+':'+G7.node[x]['name_label']
#create and draw graph G7
pos=nx.circular_layout(G7,dim=2, scale=100)
plt.clf()
nx.draw(G7, labels=custom_labels1, with_labels=True)
plt.savefig('/var/www/specint.org/public_html/specint/img/completed_graph_chem2bio2rdf_'+inchikey+'.png')
#*************Join grpahs*************************
G10=nx.union(G6,G7)
nodes1=G10.nodes()
custom_labels1={}
for x in nodes1:
custom_labels1[x] = str(x)+':'+G10.node[x]['name_label']
#create and draw graph G10
pos=nx.circular_layout(G10,dim=2, scale=300)
plt.clf()
nx.draw(G10, labels=custom_labels1, with_labels=True)
plt.savefig('/var/www/specint.org/public_html/specint/img/completed_graph_'+inchikey+'.eps',format='eps', dpi=300)
plt.savefig('/var/www/specint.org/public_html/specint/img/completed_graph_'+inchikey+'.png')
#************************Removing node************************
nodes_for_connection=[]
nodes_value_for_connection=[]
values_for_connected_nodes=['pubchem','chebi','drugbank','kegg_ligand']
#print values_for_connected_nodes
for x in values_for_connected_nodes:
nodes_for_connection=[]
#connection_node=random.choice(values_for_connected_nodes)
connection_node=x
#print connection_node
nodes5=G10.nodes()
for x in nodes5:
if((G10.node[x]['name_label']).split('/')[0]==connection_node):
nodes_for_connection.append(x)
nodes_value_for_connection.append((G10.node[x]['name_label']).split('/')[1])
#print nodes_for_connection
if(len(nodes_for_connection)>=2):
my_array_for_node_connected=[]
for x in range(0,len(nodes_value_for_connection)-1):
for y in range(x+1,len(nodes_value_for_connection)):
if(nodes_value_for_connection[x]==nodes_value_for_connection[y]):
my_array_for_node_connected.append(nodes_for_connection[x])
my_array_for_node_connected.append(nodes_for_connection[y])
#print my_array_for_node_connected
#print max(my_array_for_node_connected)
#print min(my_array_for_node_connected)
if(len(my_array_for_node_connected)>0):
G10.remove_node(max(my_array_for_node_connected))
for_delete=G10.nodes()
#print for_delete
position=(G10.nodes()).index(min(my_array_for_node_connected))
#print position
for x in for_delete:
if((x>min(my_array_for_node_connected)) and (x not in G6.nodes())):
G10.add_edge(min(my_array_for_node_connected),x)
nodes1=G10.nodes()
custom_labels1={}
for x in nodes1:
custom_labels1[x] = str(x)+':'+G10.node[x]['name_label']
#create and draw graph G10
pos=nx.circular_layout(G10,dim=2, scale=300)
plt.clf()
nx.draw(G10, labels=custom_labels1, with_labels=True)
plt.savefig('/var/www/specint.org/public_html/specint/img/completed_graph_'+inchikey+'.eps',format='eps', dpi=300)
plt.savefig('/var/www/specint.org/public_html/specint/img/completed_graph_'+inchikey+'.png')
#H = nx.Graph()
#H.add_nodes_from(G10.nodes())
#H.add_edges_from(G10.edges())
image='myimage_for_completed_graph.png'
if(nx.is_connected(G10)==True):
fv=nx.fiedler_vector(G10,method='lobpcg')
create_python_file(G10.nodes(),G10.edges(), inchikey)
return {'fv':fv, 'connection_node':connection_node}
break
else:
#print 'Undirected graph is not connected! Please, try again!';
return {'fv':'Undirected graph is not connected! Please, try again!'}
else:
#print 'Undirected graph is not connected! Please, try again!'
return {'fv':'Undirected graph is not connected! Please, try again!'}
else:
#return completed_graph(inchikey)
#continue
#print 'Undirected graph is not connected! Please, try again!'
return {'fv':'Undirected graph is not connected! Please, try again!'}
def show_rela_diagnosis(relation, select, cmap=plt.cm.Blues):
""" Visualize diagnosis on relationships of 4 scales
Args:
relation: (np.array | torch.tensor) of shpae (60,)
select: List of select item indices
"""
mats = vec2mat(relation , select)
fig = plt.figure(figsize=(20, 5))
all_names = {0:'Top', 1:'Bottom', 2:'Shoe', 3:'Bag', 4:'Accssory'}
node_names = {i:all_names[s] for i, s in enumerate(select)}
edge_vmax = max(m.max() for m in mats)
edge_vmin = min(m.min() for m in mats)
container = []
for idx in range(4):
A = mats[idx]
if isinstance(A, torch.Tensor):
A = A.cpu().data.numpy()
A = np.triu(A, k=1)
A = np.round(A, decimals=2)
container.append(A)
container = np.stack(container)
sorted_vedge = sorted(container.ravel(), reverse=True)
for idx in range(4):
plt.subplot(1, 4, idx+1)
plt.title("Layer {}".format(idx+1), fontsize=28)
A = mats[idx]
if isinstance(A, torch.Tensor):
A = A.cpu().data.numpy()
A = np.triu(A, k=1)
A = np.round(A, decimals=2)
indices = np.triu_indices(A.shape[0], k=1)
weights = A[indices[0], indices[1]]
# Generate graph
G = nx.Graph()
for i, j, weight in zip(*indices, weights):
G.add_edge(node_names[i], node_names[j], weight=weight)
elarge, esmall, filtered_weights = [], [], []
for e in G.edges(data=True):
if e[2]['weight'] in sorted_vedge[:3]:
elarge.append((e[0], e[1]))
else:
esmall.append((e[0], e[1]))
filtered_weights.append(e[2]['weight'])
pos=nx.circular_layout(G) # positions for all nodes
# nodes
nx.draw_networkx_nodes(G, pos, nodelist=[n for n in G.nodes()], node_size=1600, node_color='#A0CBE2')
# edges
nx.draw_networkx_edges(G,pos,edgelist=esmall, width=6, alpha=0.5, edge_color=filtered_weights, edge_cmap=cmap,
edge_vmax=edge_vmax, edge_vmin=edge_vmin)
nx.draw_networkx_edges(G,pos,edgelist=elarge, width=6, alpha=0.5, edge_color='red', style='dashed')
# labels
labels = nx.get_edge_attributes(G,'weight')
nx.draw_networkx_labels(G,pos, font_size=18, font_family='Times New Roman')
if len(select) == 4:
nx.draw_networkx_edge_labels(G, pos, font_size=18, font_family='Times New Roman', edge_labels=labels, label_pos=0.33)
else:
nx.draw_networkx_edge_labels(G, pos, font_size=18, font_family='Times New Roman', edge_labels=labels)
plt.axis('off')
plt.gca().get_xaxis().set_visible(False)
plt.gca().get_yaxis().set_visible(False)
plt.tight_layout()
plt.show()
G.add_edge(7, 8)
G.add_edge(7, 9)
G.add_edge(7, 14)
G.add_edge(7, 16)
G.add_edge(7, 17)
G.add_edge(8, 9)
G.add_edge(8, 14)
G.add_edge(8, 16)
G.add_edge(8, 17)
G.add_edge(9, 14)
G.add_edge(9, 16)
G.add_edge(9, 17)
G.add_edge(14, 16)
G.add_edge(14, 17)
G.add_edge(16, 17)
G.add_edge(23, 25)
G.add_edge(23, 26)
G.add_edge(23, 27)
G.add_edge(25, 26)
G.add_edge(25, 27)
G.add_edge(26, 27)
print G.nodes()
print nx.fiedler_vector(G, method='lobpcg')
pos = nx.circular_layout(G, dim=50, scale=100)
plt.clf()
nx.draw(G, with_labels=True)
plt.savefig(
'C:/Users/Branko/Desktop/ZRIHAIZYIMGOAB-UHFFFAOYSA-N_unoriented.png')
temp_sum += row[i]
temp_count += 1
g1 = generate_visibility_graph({
"t": range(len(month_temp)),
"x": average_temp
})
g2 = generate_visibility_graph({
"t": range(len(month_humidity)),
"x": average_humidity
})
print(g1.edges())
print(g2.edges())
graph_pos = nx.circular_layout(g1)
nx.draw_networkx_nodes(g1, graph_pos, node_size=1000, node_color='skyblue')
nx.draw_networkx_edges(g1, graph_pos)
nx.draw_networkx_labels(g1, graph_pos, font_size=12, font_family='sans-serif')
plt.figure()
plt.stem(range(len(month_temp)), average_temp)
plt.figure()
graph_pos = nx.circular_layout(g2)
nx.draw_networkx_nodes(g2, graph_pos, node_size=1000, node_color='skyblue')
nx.draw_networkx_edges(g2, graph_pos)
nx.draw_networkx_labels(g2, graph_pos, font_size=12, font_family='sans-serif')
plt.figure()
plt.stem(range(len(month_humidity)), average_humidity)
def draw_graph(graph,
vertex_label='label',
secondary_vertex_label=None,
edge_label='label',
secondary_edge_label=None,
vertex_color=None,
vertex_color_dict=None,
vertex_alpha=0.6,
vertex_border=1,
vertex_size=600,
colormap='YlOrRd',
vmin=0,
vmax=1,
invert_colormap=False,
edge_colormap='YlOrRd',
edge_vmin=0,
edge_vmax=1,
edge_color=None,
edge_width=None,
edge_alpha=0.5,
dark_edge_colormap='YlOrRd',
dark_edge_vmin=0,
dark_edge_vmax=1,
dark_edge_color=None,
dark_edge_dotted=True,
dark_edge_alpha=0.3,
size=10,
size_x_to_y_ratio=1,
font_size=9,
layout='graphviz',
prog='neato',
pos=None,
verbose=True,
file_name=None,
title_key='id',
ignore_for_layout="edge_attribute",
logscale=False):
"""Plot graph layout."""
if size is not None:
size_x = size
size_y = int(float(size) / size_x_to_y_ratio)
plt.figure(figsize=(size_x, size_y))
plt.grid(False)
plt.axis('off')
if vertex_label is not None:
if secondary_vertex_label:
vertex_labels = dict()
for u, d in graph.nodes(data=True):
label1 = _serialize_list(d.get(vertex_label, 'N/A'))
label2 = _serialize_list(d.get(secondary_vertex_label, 'N/A'))
vertex_labels[u] = '%s\n%s' % (label1, label2)
else:
vertex_labels = dict()
for u, d in graph.nodes(data=True):
label = d.get(vertex_label, 'N/A')
vertex_labels[u] = _serialize_list(label)
edges_normal = [(u, v) for (u, v, d) in graph.edges(data=True)
if d.get('nesting', False) is False]
edges_nesting = [(u, v) for (u, v, d) in graph.edges(data=True)
if d.get('nesting', False) is True]
if edge_label is not None:
if secondary_edge_label:
edge_labels = dict([
((
u,
v,
), '%s\n%s' %
(d.get(edge_label, ''), d.get(secondary_edge_label, '')))
for u, v, d in graph.edges(data=True)
])
else:
edge_labels = dict([((
u,
v,
), d.get(edge_label, '')) for u, v, d in graph.edges(data=True)])
if vertex_color is None:
node_color = 'white'
elif vertex_color in ['_labels_', '_label_', '__labels__', '__label__']:
node_color = []
for u, d in graph.nodes(data=True):
label = d.get('label', '.')
if vertex_color_dict is not None:
node_color.append(vertex_color_dict.get(label, 0))
else:
node_color.append(hash(_serialize_list(label)))
else:
if invert_colormap:
node_color = [
-d.get(vertex_color, 0) for u, d in graph.nodes(data=True)
]
else:
node_color = [
d.get(vertex_color, 0) for u, d in graph.nodes(data=True)
]
if logscale is True:
log_threshold = 0.01
node_color = [
math.log(c) if c > log_threshold else math.log(log_threshold)
for c in node_color
]
if edge_width is None:
widths = 1
elif isinstance(edge_width, int):
widths = edge_width
else:
widths = [
d.get(edge_width, 1) for u, v, d in graph.edges(data=True)
if 'nesting' not in d
]
if edge_color is None:
edge_colors = 'black'
elif edge_color in ['_labels_', '_label_', '__labels__', '__label__']:
edge_colors = [
hash(str(d.get('label', '.')))
for u, v, d in graph.edges(data=True) if 'nesting' not in d
]
else:
if invert_colormap:
edge_colors = [
-d.get(edge_color, 0) for u, v, d in graph.edges(data=True)
if 'nesting' not in d
]
else:
edge_colors = [
d.get(edge_color, 0) for u, v, d in graph.edges(data=True)
if 'nesting' not in d
]
if dark_edge_color is None:
dark_edge_colors = 'black'
else:
dark_edge_colors = [
d.get(dark_edge_color, 0) for u, v, d in graph.edges(data=True)
if 'nesting' in d
]
tmp_edge_set = [(a, b, d) for (a, b, d) in graph.edges(data=True)
if ignore_for_layout in d]
graph.remove_edges_from(tmp_edge_set)
if pos is None:
if layout == 'graphviz':
graph_copy = graph.copy()
# remove all attributes for graphviz layout
for u, d in graph_copy.nodes(data=True):
graph_copy.node[u] = {}
for u, v, d in graph_copy.edges(data=True):
graph_copy.edge[u][v] = {}
pos = nx.graphviz_layout(graph_copy,
prog=prog,
args="-Gmaxiter=1000")
elif layout == "RNA":
import RNA
rna_object = RNA.get_xy_coordinates(graph.graph['structure'])
pos = {
i: (rna_object.get(i).X, rna_object.get(i).Y)
for i in range(len(graph.graph['structure']))
}
elif layout == 'circular':
pos = nx.circular_layout(graph)
elif layout == 'random':
pos = nx.random_layout(graph)
elif layout == 'spring':
pos = nx.spring_layout(graph)
elif layout == 'shell':
pos = nx.shell_layout(graph)
elif layout == 'spectral':
pos = nx.spectral_layout(graph)
elif layout == 'KK':
pos = KKEmbedder().transform(graph)
else:
raise Exception('Unknown layout format: %s' % layout)
if vertex_border is False:
linewidths = 0.001
else:
linewidths = 1
graph.add_edges_from(tmp_edge_set)
nodes = nx.draw_networkx_nodes(graph,
pos,
node_color=node_color,
alpha=vertex_alpha,
node_size=vertex_size,
linewidths=linewidths,
cmap=plt.get_cmap(colormap),
vmin=vmin,
vmax=vmax)
nodes.set_edgecolor('k')
nx.draw_networkx_edges(graph,
pos,
edgelist=edges_normal,
width=widths,
edge_color=edge_colors,
edge_cmap=plt.get_cmap(edge_colormap),
edge_vmin=edge_vmin,
edge_vmax=edge_vmax,
alpha=edge_alpha)
if dark_edge_dotted:
style = 'dotted'
else:
style = 'solid'
nx.draw_networkx_edges(graph,
pos,
edgelist=edges_nesting,
width=1,
edge_cmap=plt.get_cmap(dark_edge_colormap),
edge_vmin=dark_edge_vmin,
edge_vmax=dark_edge_vmax,
edge_color=dark_edge_colors,
style=style,
alpha=dark_edge_alpha)
if edge_label is not None:
nx.draw_networkx_edge_labels(graph,
pos,
edge_labels=edge_labels,
font_size=font_size)
if vertex_label is not None:
nx.draw_networkx_labels(graph,
pos,
vertex_labels,
font_size=font_size,
font_color='black')
if title_key:
title = str(graph.graph.get(title_key, ''))
font = FontProperties()
font.set_family('monospace')
plt.title(title, fontproperties=font)
if size is not None:
# here we decide if we output the image.
# note: if size is not set, the canvas has been created outside
# of this function.
# we wont write on a canvas that we didn't create ourselves.
if file_name is None:
plt.show()
else:
plt.savefig(file_name,
bbox_inches='tight',
transparent=True,
pad_inches=0)
plt.close()
def draw_lesion_graph(G, bl, labels=None, subnets=None, lesion_nodes=None):
"""
Parameters
subnets : dict
A colors,label list dict of subnetworks that covers the graph
"""
if labels is None:
labels = G.nodes()
if subnets is None:
subnets = dict(b=G.nodes())
all_nodes = set(labels)
lab_idx = range(len(labels))
labels_dict = dict(zip(labels, lab_idx))
idx2lab_dict = dict(zip(lab_idx, labels))
# Check that all subnets cover the whole graph
subnet_nodes = []
for ss in subnets.values():
subnet_nodes.extend(ss)
subnet_nodes = set(subnet_nodes)
assert subnet_nodes == all_nodes
# Check that the optional lesion list is contained in all the nodes
if lesion_nodes is None:
lesion_nodes = set()
else:
lesion_nodes = set(lesion_nodes)
assert lesion_nodes.issubset(all_nodes),\
"lesion nodes:%s not a subset of nodes" % lesion_nodes
# Make a table that maps lesion nodes to colors
lesion_colors = pick_lesion_colors(lesion_nodes, subnets)
# Compute positions for all nodes - nx has several algorithms
pos = nx.circular_layout(G)
# Create the actual plot where the graph will be displayed
#fig = plt.figure()
#plt.subplot(1,12,bl+1)
good_nodes = all_nodes - lesion_nodes
# Draw nodes
for node_color, nodes in subnets.items():
nodelabels = set(nodes) - lesion_nodes
nodelist = lab2node(nodelabels, labels_dict)
nx.draw_networkx_nodes(G,
pos,
nodelist=nodelist,
node_color=node_color,
node_size=700,
node_shape='o')
for nod in lesion_nodes:
nx.draw_networkx_nodes(G,
pos,
nodelist=[labels_dict[nod]],
node_color=lesion_colors[nod],
node_size=700,
node_shape='s')
# Draw edges
draw_networkx_edges(G, pos)
# Draw labels
nx.draw_networkx_labels(G, pos, idx2lab_dict)
def plot_graph(
G,
pos=None,
colors=None,
node_labels=None,
node_size=0.04,
edgescale=1.0,
nodeopts={},
labelopts={},
arrowopts={},
bidir_arrows=True,
cmap='Paired',
):
"""Plot a graphs. Supports both directed and undirected graphs.
Undirected edges are drawn as lines while directed edges are drawn
as arrows.
For example:
.. plot::
:include-source:
>>> from graphy import plotting
>>> import networkx as nx
>>> G=nx.karate_club_graph()
>>> plotting.plot_graph(G, pos=nx.spring_layout(G), colors=range(G.number_of_nodes())) # doctest: +SKIP
Parameters
----------
G : networkx Graph object or 2-d np.array
Graph to plot, either instance of networkx Graph or a 2-d connectivity
matrix.
pos : dict
Dict specifying positions of nodes, as in {node: (x,y). If not provided,
nodes are arranged along a circle.
colors : list of ints (default None)
Color(s) to use for node faces, if desired.
node_labels : list of strings (default None)
Labels to use for node labels, if desired.
node_size : float (default 0.05)
Size of nodes.
edgescale : float (default 1.0)
Controls thickness of edges between nodes.
nodeopts : dict (default {})
Extra options to pass into plt.Circle call for plotting nodes.
labelopts : dict (default {})
Extra options to pass into plt.text call for plotting labels.
Could be used to specify fontsize, for example.
arrowopts : dict (default {})
Extra options to pass into plt.arrow call for plotting edges.
bidir_arrows : bool (default True)
Whether to draw arrowheads when graph is directed and two
nodes are connected bidirectionally.
cmap : string (default 'Paired')
Name of colormap to use.
"""
class MplColorHelper:
"""Class that helps pick colors from specified colormaps.
"""
def __init__(self, cmap_name, start_val, stop_val):
self.cmap_name = cmap_name
self.cmap = plt.get_cmap(cmap_name)
self.norm = mpl.colors.Normalize(vmin=start_val, vmax=stop_val)
self.scalarMap = cm.ScalarMappable(norm=self.norm, cmap=self.cmap)
def get_rgb(self, val):
return self.scalarMap.to_rgba(val)
def intersect_two_circles(xy1, r1, xy2, r2):
d = np.linalg.norm(xy2 - xy1)
a = (r1**2 - r2**2 + d**2) / (2 * d)
b = d - a
h = np.sqrt(r1**2 - a**2)
xy3 = xy1 + a * (xy2 - xy1) / d
ix = xy3[0] + h * (xy2[1] - xy1[1]) / d
iy = xy3[1] - h * (xy2[0] - xy1[0]) / d
return np.array([ix, iy])
if isinstance(G, (np.ndarray, np.generic)):
G = nx.from_numpy_matrix(G, create_using=nx.DiGraph())
elif not isinstance(G, nx.Graph):
raise ValueError('Unknown type of graph: %s' % str(type(G)))
if pos is None:
pos = nx.circular_layout(G)
if colors is None:
colors = 1
if not isinstance(colors, collections.Iterable):
colors = [
colors,
] * G.number_of_nodes()
colors = np.asarray(colors)
cmap_helper = MplColorHelper(cmap, colors.min(), colors.max())
bbox = plt.gca().get_window_extent()
asp_ratio = bbox.width / bbox.height
node_map = {n: ndx for ndx, n in enumerate(G.nodes())}
xys = np.array([pos[n] for n in G.nodes()])
xys -= xys.min(axis=0)
maxvalues = xys.max(axis=0)
maxvalues[maxvalues == 0] = 1
xys /= maxvalues
xys[:, 0] *= asp_ratio
plt.xlim([-(3 * node_size) * asp_ratio, (1 + (3 * node_size)) * asp_ratio])
plt.ylim([-(3 * node_size), 1 + (3 * node_size)])
plt.axis('off')
try:
edge_weights = nx.get_edge_attributes(G, 'weight')
except KeyError:
edge_weights = {}
arrowdict = dict(ec='k', fc='k', length_includes_head=True, shape='full')
for k, v in arrowopts.items():
arrowdict[k] = v
for edge in G.edges():
startxy = xys[node_map[edge[0]], :].copy()
endxy = xys[node_map[edge[1]], :].copy()
arrowdict['lw'] = edge_weights.get(edge, 1.0) * edgescale
headscale = node_size * 0.5
has_reverse = (edge[1], edge[0]) in G.edges()
if G.is_directed() and (not has_reverse or bidir_arrows):
head_scale = node_size * 0.5
else:
head_scale = 0
arrowdict['head_length'] = head_scale
arrowdict['head_width'] = head_scale
if edge[0] == edge[1]:
loopoffset = np.sign(startxy - xys.mean(axis=0)) * node_size * 1.05
cloop = plt.Circle(startxy + loopoffset,
radius=node_size * 0.65,
ec='k',
fill=False,
lw=arrowdict['lw'])
plt.gca().add_artist(cloop)
arrowloc = intersect_two_circles(startxy, node_size,
startxy + loopoffset,
node_size * 0.7)
arrowlocstart = arrowloc + (arrowloc - startxy) * 1e-5
plt.arrow(arrowlocstart[0], arrowlocstart[1],
arrowloc[0] - arrowlocstart[0],
arrowloc[1] - arrowlocstart[1], **arrowdict)
else:
angle = np.arctan2(endxy[1] - startxy[1], endxy[0] - startxy[0])
offset = np.array([np.cos(angle), np.sin(angle)]) * node_size
startxy += offset
endxy -= offset
if nx.is_directed(G) and has_reverse:
midxy = (startxy + endxy) / 2.0
plt.arrow(midxy[0], midxy[1], endxy[0] - midxy[0],
endxy[1] - midxy[1], **arrowdict)
plt.arrow(midxy[0], midxy[1], startxy[0] - midxy[0],
startxy[1] - midxy[1], **arrowdict)
else:
carrowdict = arrowdict
carrowdict = carrowdict.copy()
plt.arrow(startxy[0], startxy[1], endxy[0] - startxy[0],
endxy[1] - startxy[1], **arrowdict)
for ndx, xy in enumerate(xys): # Plot nodes
cnode = plt.Circle((xy[0], xy[1]),
radius=node_size,
ec='none',
color=cmap_helper.get_rgb(colors[ndx]),
**nodeopts)
plt.gca().add_artist(cnode)
if node_labels is not None:
plt.text(xy[0],
xy[1],
node_labels[ndx],
ha='center',
va='center',
**labelopts)
estaConnectado = algoritmos.isConnected(G)
if estaConnectado:
apl_coeficiente = metricas.APL(
list(nx.all_pairs_shortest_path_length(G)), 1000000)
cc = nx.average_clustering(G)
with open('APL.txt', 'a') as f:
f.write("%s\n" % apl_coeficiente)
with open('CC.txt', 'a') as f:
f.write("%s\n" % cc)
with open("redes/" + str(contador) + ".txt", 'a') as f:
f.write("[\n")
for item in G.edges:
f.write("%s,\n" % list(item))
f.write("]\n")
pos = nx.circular_layout(G, scale=0.5)
plt.figure(3, figsize=(35, 35))
labels = {}
edgeswidth = []
for i in range(100):
labels[i] = i
for i in range(200):
edgeswidth.append(5)
nx.draw_circular(G,
node_size=1000,
labels=labels,
width=edgeswidth,
arrowsize=10)
plt.savefig("figuras/" + str(contador) + ".png")
plt.clf()
def generate_column_correlation_network(df,
th=0.8,
edge_labels_flag=True,
layout="spring_layout"):
G = nx.Graph()
col_numerical = list(df.select_dtypes([np.number]).columns)
comb2_col_numerical = list(itertools.combinations(
col_numerical, 2)) # Make combinations from col_numerical
# go over all combinations calculate correlation
for rec in comb2_col_numerical:
col1 = rec[0]
col2 = rec[1]
corr = df[col1].corr(df[col2], method='pearson')
corr = round(corr, 2)
if abs(corr) >= th: # if correlation is high enoigh add edge to graph
G.add_edge(col1, col2, weight=corr)
num_nodes = G.number_of_nodes()
num_edges = G.number_of_edges()
if num_nodes <= 1 or num_edges == 0:
print("netwotk has no nodes (or just 1) or edges")
return
# calculate communities
if num_edges > 1:
communities_generator = community.girvan_newman(G)
top_level_communities = next(communities_generator)
next_level_communities = next(communities_generator)
display(Markdown("## Communites:"))
node_to_cc_dict = dict()
cc = sorted(map(sorted, next_level_communities))
counter = 0
if len(cc) == 0:
print("netwotk has no communites")
return
for c in cc:
counter += 1
for n in list(c):
node_to_cc_dict[n] = counter
print(c)
print("-------------------")
# print communites and plot
display(Markdown("## Network:"))
print("number of nodes:", num_nodes)
print("number of edges:", num_edges)
plt.figure(figsize=(26, 10))
if layout == "spring_layout":
pos = nx.spring_layout(G, k=0.15, iterations=20, scale=2)
elif layout == "planar_layout":
pos = nx.planar_layout(G)
elif layout == "circular_layout":
pos = nx.circular_layout(G)
else:
print("problrm with choosing a layout")
if num_edges > 1:
com_values = [node_to_cc_dict[n] for n in G.nodes()]
nx.draw_networkx(G,
pos,
cmap=plt.get_cmap('jet'),
node_color=com_values,
with_labels=True,
alpha=0.6,
font_size=14)
else:
nx.draw_networkx(G,
pos,
cmap=plt.get_cmap('jet'),
with_labels=True,
alpha=0.6,
font_size=16)
if edge_labels_flag:
edge_labels = nx.get_edge_attributes(G, 'weight')
nx.draw_networkx_edge_labels(G,
pos,
edge_labels=edge_labels,
alpha=0.8)
plt.show()
"Graph Theory - Find Shortest path using Dijkstra Algo"
import networkx as nx
import matplotlib.pyplot as plt
G = nx.Graph()
e = [('a', 'b', 3), ('b', 'c', 9), ('a', 'c', 5), ('c', 'd', 12),
('c', 'e', 12)]
G.add_weighted_edges_from(e)
nx.draw(G,
pos=nx.circular_layout(G),
nodecolor='r',
edge_color='b',
with_labels=True,
with_edges=True)
nx.draw_networkx_edge_labels(G=G, pos=nx.circular_layout(G))
#print shortest path
print(nx.dijkstra_path(G, 'b', 'd'))
plt.show()
import networkx as net
import matplotlib.pyplot as plt
# create graph
graph = net.DiGraph()
graph.add_edge('Univ', 'ProfA')
graph.add_edge('Univ', 'ProfB')
graph.add_edge('ProfA', 'StudentA')
graph.add_edge('StudentA', 'Univ')
graph.add_edge('ProfB', 'StudentB')
graph.add_edge('StudentB', 'ProfB')
show_graph = True
if show_graph:
net.draw(graph, pos=net.circular_layout(graph), with_labels=True)
plt.show()
C = 0.8
def similarity_dict(g, k):
def sim(a, b):
sum = 0
if a == b:
return 1
for a_inc, _ in g.in_edges(a):
for b_inc, _ in g.in_edges(b):
s = r_prev.get((a_inc, b_inc), 0.)
sum += s
return C / (len(g.in_edges(a)) * len(g.in_edges(b))) * sum
AdjL = sc.array(GenRdmAdjList(MaxN, C))
print(AdjL)
Sps = sc.unique(AdjL) # Get species ids
print(Sps)
# Gnerate species body size data
SizRan = ([-10, 10]) # Use log10 scale
Sizs = sc.random.uniform(SizRan[0], SizRan[1], MaxN) # Randomly distributed node size
print(Sizs)
# Plot histogram of body size
p.hist(Sizs) # log10 scale
p.hist(10 ** Sizs) # raw scale
p.close('all') # close all open plot objects
pos = nx.circular_layout(Sps) # Take species data and plot in circular layout
# Create a network graph object
G = nx.Graph() #
# Add nodes and links
G.add_nodes_from(Sps)
G.add_edges_from(tuple(AdjL)) # this function needs a tuple input
# Generate node sizes proportional to log body sizes
NodSizs= 1000 * (Sizs-min(Sizs))/(max(Sizs)-min(Sizs))
# Plots the graph and saves to pdf
f = p.figure()
nx.draw_networkx(G, pos, node_size = NodSizs)
f.savefig(r'../results/Food_network.pdf')
def visualize(G: nx.Graph,
remove_empty_nodes: bool = True,
layout: str = "spring") -> go.Figure:
"""Generates an interactive plot of a voting network.
adapted from source: https://plot.ly/python/network-graphs/
:param G: A network as created with the "create_network()" function
:type G: nx.Graph
:param remove_empty_nodes: Whether to remove nodes that have no edges: i.e. MEPs that did not vote for any of the bills in the selection, defaults to True
:param remove_empty_nodes: bool, optional
:param layout: what layout algorithm should be used. Options are: 'circular', 'random', 'shell', 'spring', 'spectral'. , defaults to "spring"
:param layout: str, optional
:raises RuntimeError: If an layout option is given that doesnt exist.
:return: A plotly figure object containing the plotted network.
:rtype: go.Figure
"""
global party_color_map
if remove_empty_nodes:
remove_loose_nodes(G)
#Get Node Positions
# pos=nx.get_node_attributes(G,'pos')
print(f"calculating positions with {layout} layout...", flush=True)
if layout == 'circular':
pos = nx.circular_layout(G)
elif layout == 'random':
pos = nx.random_layout(G)
elif layout == 'shell':
pos = nx.shell_layout(G)
elif layout == 'spring':
pos = nx.spring_layout(G, iterations=100)
elif layout == 'spectral':
pos = nx.spectral_layout(G)
else:
raise RuntimeError(f"Unknown layout option: {layout}")
# print(pos)
dmin = 1
ncenter = 0
for n in pos:
G.nodes[n]['pos'] = pos[n]
# pp.pprint(G.nodes[n])
x, y = pos[n]
d = (x - 0.5)**2 + (y - 0.5)**2
if d < dmin:
ncenter = n
dmin = d
p = nx.single_source_shortest_path_length(G, ncenter)
# Create Edges
print(f"create {len(G.edges())} edges ...", flush=True)
edge_trace = go.Scatter(x=[],
y=[],
line=dict(width=0.5, color='black'),
hoverinfo='none',
mode='lines')
for edge in tqdm.tqdm(G.edges()):
x0, y0 = G.node[edge[0]]['pos']
x1, y1 = G.node[edge[1]]['pos']
edge_trace['x'] += tuple([x0, x1, None])
edge_trace['y'] += tuple([y0, y1, None])
# Create Nodes
print("create nodes ...", flush=True)
node_trace = go.Scatter(x=[],
y=[],
text=[],
mode='markers',
hoverinfo='text',
marker=dict(color=[], size=[], line=dict(width=2)))
for node in tqdm.tqdm(G.nodes()):
x, y = G.node[node]['pos']
node_trace['x'] += tuple([x])
node_trace['y'] += tuple([y])
# Color Node Points
print("Color Node Points ...", flush=True)
for i, (key, node) in tqdm.tqdm(enumerate(G.nodes().items())):
if node.get('type', False) == 'division':
if node['aye_count'] - node['noes_count'] > 0:
node_trace['marker']['color'] += tuple(['green'])
else:
node_trace['marker']['color'] += tuple(['red'])
node_info = f"Vote: {node['title']} - Ayes count: {node['aye_count']} - Noes count: {node['noes_count']}"
node_trace['text'] += tuple([node_info])
node_trace['marker']['size'] += tuple([15])
else:
node_trace['marker']['color'] += tuple(
[party_color_map[node['party']]])
node_info = f"{node['name']} - {node['party']} - {node['constituency']}"
node_trace['text'] += tuple([node_info])
node_trace['marker']['size'] += tuple([10])
print("create network graph ...", flush=True)
fig = go.Figure(data=[edge_trace, node_trace],
layout=go.Layout(
title='Network graph for votes at uk parliament.',
titlefont=dict(size=16),
showlegend=False,
hovermode='closest',
margin=dict(b=20, l=5, r=5, t=40),
annotations=[
dict(text="test",
showarrow=False,
xref="paper",
yref="paper",
x=0.005,
y=-0.002)
],
xaxis=dict(showgrid=False,
zeroline=False,
showticklabels=False),
yaxis=dict(showgrid=False,
zeroline=False,
showticklabels=False)))
print("returning figure")
return fig
def DrawButtonSingleCSV_clicked(self):
#G = nx.DiGraph()
usbiptocompare = []
usbidtocompare = []
usbnametocompare = []
usbcnamecompare = []
usbidcheck = []
usbipcheck = []
usbnamecheck = []
usbcnamecheck = []
#dates
usbdatecheck = []
usbtimecheck = []
usbfirstplugdatecompare = []
usbfirstplugtimecompare = []
a = 0
b = 0
c = 0
if self.projectopen and self.drawcsv == False:
singlecsvfile = self.classdatafilecsv
else:
singlecsvfile = QtGui.QFileDialog.getOpenFileName(
self, 'Open single CSV File to plot')
with open(singlecsvfile) as f:
first_line = f.readline()
self.drawcsv = True
datacsvfile = []
with open(singlecsvfile) as f:
for row in csv.DictReader(f):
datacsvfile.append(row)
self.listWidgetRemoteOutput.addItem(
"Processing data from CSV file ... please wait ...")
self.listWidgetRemoteOutput.addItem(
"Click on usb picture to proceed to the next plot")
QtGui.QApplication.processEvents()
csvhdheader = "computer_name,computer_ip,usbdevice_name,usbdevice_id,usb_firstplugdate,usb_firstplugtime"
if first_line.rstrip() != csvhdheader:
msg = QtGui.QMessageBox()
msg.setText("Error, file is not HD CSV")
ret = msg.exec()
datosjsondump = json.dumps(datacsvfile)
datosjsonraw = json.loads(datosjsondump)
datosjson = sorted(datosjsonraw,
key=lambda k: datetime.strptime(
k['usb_firstplugdate'], "%Y/%m/%d"),
reverse=False)
for item in datosjson:
usbidtocompare.append(item.get("usbdevice_id"))
usbiptocompare.append(item.get("computer_ip"))
usbnametocompare.append(item.get("usbdevice_name"))
usbcnamecompare.append(item.get("computer_name"))
usbfirstplugdatecompare.append(item.get("usb_firstplugdate"))
usbfirstplugtimecompare.append(item.get("usb_firstplugtime"))
# Remove duplicates
for i in usbidtocompare:
if i not in usbidcheck:
usbidcheck.append(i)
usbipcheck.append(usbiptocompare[b])
usbnamecheck.append(usbnametocompare[b])
usbcnamecheck.append(usbcnamecompare[b])
#dates
usbdatecheck.append(usbfirstplugdatecompare[b])
usbtimecheck.append(usbfirstplugtimecompare[b])
b = b + 1
else:
b = b + 1
d = 0
n = 0
for idusb in usbidcheck:
G = nx.DiGraph()
testArrow = matplotlib.patches.ArrowStyle.Fancy(head_length=.4,
head_width=.4,
tail_width=.1)
pathrepo = os.path.dirname(
os.path.realpath(__file__)) + "\\reports\\"
timestr = time.strftime("%Y%m%d-%H%M%S")
preusbipcomp = usbipcheck[d]
preusbcomputername = usbcnamecheck[d]
#dates
preusbdate = usbdatecheck[d]
preusbtime = usbtimecheck[d]
# PDF
pdf = FPDF()
pdf.add_page()
pdf.set_font('Arial', 'B', 20)
pdf.cell(110, 10, 'Hidden Networks USB Report', 1, 1)
pdf.set_font('Arial', 'B', 15)
pdf.cell(30, 10, 'USB Name: ' + usbnamecheck[c], 0, 1)
pdf.cell(30, 10, 'USB id: ' + idusb, 0, 1)
pdf.cell(30, 15, 'Tracking: ', 0, 1)
for item in datosjson:
usbidcomp = item.get("usbdevice_id")
usbipcomp = item.get("computer_ip")
computername = item.get("computer_name")
#date
usbdate = item.get("usb_firstplugdate")
usbtime = item.get("usb_firstplugtime")
if usbidcomp == idusb:
#PDF
pdf.set_font('Arial', '', 8)
pdf.cell(0, 5, 'Connected to: ' + computername, 0, 2)
pdf.cell(0, 5, 'IP: ' + usbipcomp, 0, 2)
pdf.cell(0, 5, 'Date: ' + usbdate + ' Time: ' + usbtime, 0,
2)
pdf.cell(0, 10, '--->', 0, 2)
listaprueba = [
preusbipcomp, preusbcomputername, preusbdate,
preusbtime
]
nuevonodo = '\n'.join(listaprueba)
listaprueba2 = [usbipcomp, computername, usbdate, usbtime]
nuevonodo2 = '\n'.join(listaprueba2)
G.add_edge(nuevonodo, nuevonodo2)
preusbipcomp = usbipcomp
preusbcomputername = computername
preusbdate = usbdate
preusbtime = usbtime
d = d + 1
self.listWidgetRemoteOutput.addItem(usbnamecheck[c])
QtGui.QApplication.processEvents()
# Graph plot
#pos = nx.shell_layout(G)
pos = nx.circular_layout(G, center=(0, 0))
#Nodes / computers
num_nodes = G.number_of_nodes()
list_nodes = list(G.nodes)
color_map = []
a = 0
# Insolated or connected (IP)
for node in G:
if list_nodes[a][0] == '\n':
color_map.append('lightsalmon')
else:
color_map.append('skyblue')
a = a + 1
options = {
'font_size': '7',
'node_shape': 'o',
'node_size': 3000,
'width': 2,
'arrowstyle': testArrow,
'arrowsize': 12,
}
nx.draw(G,
pos,
alpha=0.7,
node_color=color_map,
edge_color='gray',
arrows=True,
with_labels=True,
**options)
plt.axis("off")
plt.gcf().canvas.set_window_title(usbnamecheck[c])
plt.savefig(pathrepo + idusb + timestr + '.png')
#pdf.add_page()
pdf.image(pathrepo + idusb + timestr + '.png', 80, 50, 120)
#plt.show(nx)
# Shows image in new window as subplot
localrunpath = os.path.dirname(os.path.realpath(__file__))
print(localrunpath)
path = localrunpath + "\\images\\{0}".format(usbnamecheck[c])
if not os.path.exists(path):
os.makedirs(path)
bbid_run = "bbid.py -s \"{0}\" -o \"{1}\" --limit 3".format(
usbnamecheck[c], path)
try:
os.system(bbid_run)
print("Ejecutando ...")
#subprocess.call([bbid_run])
usb_image_path = os.listdir(path)[0]
usb_image_full_path = path + "\\" + usb_image_path
except:
print("No Internet ERROR ...")
usb_image_full_path = localrunpath + "\\" + "notfound.jpg"
fig, (ax) = plt.subplots()
#fig.canvas.set_window_title(usbnamecheck[c])
ax.imshow(plt.imread(usb_image_full_path, ))
ax.text(0.95,
0.01,
idusb,
verticalalignment='bottom',
horizontalalignment='right',
transform=ax.transAxes,
color='gray',
fontsize=15)
plt.axis("off")
n = n + 1
win = plt.gcf().canvas.manager.window
win.setWindowFlags(win.windowFlags()
| QtCore.Qt.CustomizeWindowHint)
win.setWindowFlags(win.windowFlags()
& ~QtCore.Qt.WindowCloseButtonHint)
# PDF
pdf.image(usb_image_full_path, 90, 150, 100)
# Save PDF Report file
pdf.output(pathrepo + idusb + timestr + '.pdf', 'F')
plt.show()
plt.waitforbuttonpress()
plt.close('all')
c = c + 1
self.listWidgetRemoteOutput.addItem("Finished!")
QtGui.QApplication.processEvents()
plt.xticks(FontProperties = font, size = 5)
plt.ylabel("degree")
plt.show()
plt.figure(figsize = (12, 12))
# 生成社交网络图
G = nx.Graph()
# 添加边
for ii in Red_df2.index:
G.add_edge(Red_df2.First[ii], Red_df2.Second[ii], weight = Red_df2.weight[ii])
# 定义两种边
elarge = [(u, v) for (u, v, d) in G.edges(data = True) if d['weight'] > 0.3]
emidle = [(u, v) for (u, v, d) in G.edges(data = True) if (d['weight'] > 0.2) & (d['weight'] <= 0.3)]
esmall = [(u, v) for (u, v, d) in G.edges(data = True) if d['weight'] <= 0.2]
# 图的布局
pos = nx.circular_layout(G) # positions for all nodes
# nodes 根据节点的入度和出度来设置节点的大小
nx.draw_networkx_nodes(G, pos, alpha = 0.6, node_size = 20 + Gdegree.degree * 15)
# edges
nx.draw_networkx_edges(G, pos, edgelist = elarge,
width = 2, alpha = 0.9, edge_color = 'g')
nx.draw_networkx_edges(G, pos, edgelist = emidle,
width = 1.5, alpha = 0.6, edge_color = 'y')
nx.draw_networkx_edges(G, pos, edgelist = esmall,
width = 1, alpha = 0.3, edge_color = 'b', style = 'dashed')
# labels
nx.draw_networkx_labels(G, pos, font_size = 10) # font_size = 10, 即设置图中字体的大小
plt.axis('off')
plt.title("《红楼梦》社交网络")
plt.show()
C = 0.75
AdjL = sc.array(GenRdmAdjList(MaxN, C)) ## make adjecency list
AdjL
Sps = sc.unique(AdjL) # get species ids
SizRan = ([-10, 10]) # use log10 scale
Sizs = sc.random.uniform(SizRan[0], SizRan[1], MaxN)
Sizs
###plotting###
p.hist(Sizs)
# p.show()
p.hist(10**Sizs) ### plot raw scale
# p.show()
p.close("all") # close all open plot objects
pos = nx.circular_layout(Sps)
G = nx.Graph()
G.add_nodes_from(Sps)
G.add_edges_from(tuple(AdjL))
NodSizs = 1000 * (Sizs - min(Sizs)) / (max(Sizs) - min(Sizs))
f = p.figure()
nx.draw_networkx(G, pos, node_size=NodSizs)
# p.show()
f.savefig("../Results/DrawFW.pdf")
def generateAdjacencyNonIntersect(overlaps, labels):
G = nx.DiGraph()
for x in labels:
for t in range(0, len(overlaps) - 1):
if x in overlaps[t] and x not in overlaps[t + 1]:
for nextbin in range(t + 1, len(overlaps) - 1):
if x not in overlaps[nextbin]:
ys = [
y for y in overlaps[nextbin]
if y not in overlaps[t]
]
if ys:
node_x = Node(x)
if not G.has_node(node_x):
G.add_node(node_x)
node_y = Node(ys[0])
weights = [
G[node_x][Node(y)]['weight'] for y in ys
if G.has_node(Node(y))
and G.has_edge(node_x, Node(y))
]
if weights:
y_index = np.argmax(np.array(weights))
node_y = Node(ys[y_index])
if not G.has_node(node_y):
G.add_node(node_y)
if not G.has_edge(node_x, node_y):
G.add_edge(node_x, node_y, weight=1.0)
else:
G[node_x][node_y]['weight'] = G[node_x][
node_y]['weight'] + 1.0
break
bad = [(u, v) for (u, v, w) in G.edges(data='weight') if w <= 1]
G.remove_edges_from(bad)
more_bad = []
for (u, v) in G.edges():
if not G.has_edge(v, u):
more_bad.append((u, v))
G.remove_edges_from(more_bad)
outdeg = G.out_degree()
indeg = G.in_degree()
to_remove = [n for n in G.nodes() if outdeg[n] == 0 and indeg[n] == 0]
G.remove_nodes_from(to_remove)
labels = nx.get_edge_attributes(G, 'weight')
pos = nx.circular_layout(G)
nx.draw(G, pos)
nx.draw_networkx_edge_labels(G, pos, edge_labels=labels, label_pos=0.8)
nx.draw_networkx_labels(G, pos)
plt.show()
def wl_fig_freq(main, tokens_freq_files, settings, label_x):
files = main.wl_files.get_selected_files()
files += [{'name': main.tr('Total')}]
if settings['rank_min_no_limit']:
rank_min = 1
else:
rank_min = settings['rank_min']
if settings['rank_max_no_limit']:
rank_max = None
else:
rank_max = settings['rank_max']
# Line Chart
if settings['graph_type'] == main.tr('Line Chart'):
tokens_freq_files = wl_sorting.sorted_tokens_freq_files(
tokens_freq_files)
total_freqs = numpy.array(list(zip(*tokens_freq_files))[1]).sum(axis=0)
total_freq = sum(total_freqs)
tokens = [item[0] for item in tokens_freq_files[rank_min - 1:rank_max]]
freqs = [item[1] for item in tokens_freq_files if item[0] in tokens]
if settings['use_pct']:
if settings['use_cumulative']:
matplotlib.pyplot.ylabel(
main.tr('Cumulative Percentage Frequency'))
else:
matplotlib.pyplot.ylabel(main.tr('Percentage Frequency'))
else:
if settings['use_cumulative']:
matplotlib.pyplot.ylabel(main.tr('Cumulative Frequency'))
else:
matplotlib.pyplot.ylabel(main.tr('Frequency'))
if settings['use_cumulative']:
for i, freq_files in enumerate(freqs):
if i >= 1:
freqs[i] = [
freq_cumulative + freq
for freq_cumulative, freq in zip(
freqs[i - 1], freq_files)
]
if settings['use_pct']:
for i, file in enumerate(files):
matplotlib.pyplot.plot([
freq_files[i] / total_freqs[i] * 100
for freq_files in freqs
],
label=file['name'])
else:
for i, file in enumerate(files):
matplotlib.pyplot.plot([freq_files[i] for freq_files in freqs],
label=file['name'])
matplotlib.pyplot.xlabel(label_x)
matplotlib.pyplot.xticks(
range(len(tokens)),
labels=tokens,
fontproperties=main.settings_custom['figs']['line_chart']['font'],
rotation=90)
matplotlib.pyplot.grid(True)
matplotlib.pyplot.legend()
# Word Cloud
elif settings['graph_type'] == main.tr('Word Cloud'):
if rank_max == None:
max_words = len(tokens_freq_files) - rank_min + 1
else:
max_words = rank_max - rank_min + 1
word_cloud = wordcloud.WordCloud(
width=QDesktopWidget().width(),
height=QDesktopWidget().height(),
background_color=main.settings_custom['figs']['word_cloud']
['bg_color'],
max_words=max_words)
for i, file in enumerate(files):
if file['name'] == settings['use_file']:
tokens_freq_files = wl_sorting.sorted_tokens_freq_file(
tokens_freq_files, i)
tokens_freq_file = {
token: freqs[i]
for token, freqs in tokens_freq_files[rank_min -
1:rank_max]
}
break
# Fix zero frequencies
for token, freq in tokens_freq_file.items():
if freq == 0:
tokens_freq_file[token] += 0.000000000000001
word_cloud.generate_from_frequencies(tokens_freq_file)
matplotlib.pyplot.imshow(word_cloud, interpolation='bilinear')
matplotlib.pyplot.axis('off')
# Network Graph
elif settings['graph_type'] == main.tr('Network Graph'):
for i, file in enumerate(files):
if file['name'] == settings['use_file']:
tokens_freq_files = wl_sorting.sorted_tokens_freq_file(
tokens_freq_files, i)
tokens_freq_file = {
token: freqs[i]
for token, freqs in tokens_freq_files[rank_min -
1:rank_max]
}
break
graph = networkx.MultiDiGraph()
graph.add_edges_from(tokens_freq_file)
if main.settings_custom['figs']['network_graph']['layout'] == main.tr(
'Circular'):
layout = networkx.circular_layout(graph)
elif main.settings_custom['figs']['network_graph'][
'layout'] == main.tr('Kamada-Kawai'):
layout = networkx.kamada_kawai_layout(graph)
elif main.settings_custom['figs']['network_graph'][
'layout'] == main.tr('Planar'):
layout = networkx.planar_layout(graph)
elif main.settings_custom['figs']['network_graph'][
'layout'] == main.tr('Random'):
layout = networkx.random_layout(graph)
elif main.settings_custom['figs']['network_graph'][
'layout'] == main.tr('Shell'):
layout = networkx.shell_layout(graph)
elif main.settings_custom['figs']['network_graph'][
'layout'] == main.tr('Spring'):
layout = networkx.spring_layout(graph)
elif main.settings_custom['figs']['network_graph'][
'layout'] == main.tr('Spectral'):
layout = networkx.spectral_layout(graph)
networkx.draw_networkx_nodes(graph,
pos=layout,
node_size=800,
node_color='#FFFFFF',
alpha=0.4)
networkx.draw_networkx_edges(graph,
pos=layout,
edgelist=tokens_freq_file,
edge_color=main.settings_custom['figs']
['network_graph']['edge_color'],
width=wl_misc.normalize_nums(
tokens_freq_file.values(),
normalized_min=1,
normalized_max=5))
networkx.draw_networkx_labels(graph,
pos=layout,
font_family=main.settings_custom['figs']
['network_graph']['node_font'],
font_size=main.settings_custom['figs']
['network_graph']['node_font_size'])
networkx.draw_networkx_edge_labels(
graph,
pos=layout,
edge_labels=tokens_freq_file,
font_family=main.settings_custom['figs']['network_graph']
['edge_font'],
font_size=main.settings_custom['figs']['network_graph']
['edge_font_size'],
label_pos=0.2)
import networkx as nx import matplotlib.pyplot as plt #Creamos una instancia de un grafo G = nx.DiGraph() #Agregamos las aristas en el nodo (junto con los nodos) G.add_edge(1,2) G.add_edge(1,1) G.add_edge(1,4) G.add_edge(3,4) G.add_edge(4,5) #Dibujamos el grafo nx.draw(G, pos=nx.circular_layout(G), node_color=['b','r','r','r','r'], edge_color='b', with_labels=True) #Mostramos el grafo en pantalla plt.show()
def draw(self,
method='',
h_i_shock=None,
alpha=None,
max_iter=100,
is_savefig=False,
font_size=5,
node_color='b',
seed=None,
**kwargs):
"""draw financial network.
Parameters:
---
`method`: <str>.
the optional, the color of nodes map to the important level of bank. i.e. {'dr','nldr','dc',...}. Default = 'dr'.
`h_i_shock`: <np.ndarray>.
the initial shock. see `tt.creating_initial_shock()`.
`alpha`: <float>.
optional, the parameter of Non-Linear DebtRank. Default = 0.
`t_max`: <int>.
the max number of iteration. Default = 100.
`is_savefig`: <False>.
optional, if True, it will be saved to the current work environment. otherwise, plt.show().
`font_size`: <int>.
the size of the labels of nodes. Default = 5.
`node_color`: <str or RGB>.
the color of nodes. if method is not empty, the colors reflect the importance level.
`**kwargs`:
customize your figure, see detail in networkx.draw.
"""
# initial setting
title = 'The interbank network' + '(%s)' % self._data._label_year
method = str(method)
debtrank_alias = {'dr': 'debtrank', 'nldr': 'nonlinear debtrank'}
importance_alias = {'lp': 'loss_percentile'}
centrality_alias = {
'idc': 'in-degree centrality',
'odc': 'out-degree centrality',
'dc': 'degree centrality',
'bc': 'betweenness centrality',
'cc': 'closeness(in) centrality',
'occ': 'out-closeness centrality',
'ec': 'eigenvector(in) centrality',
'oec': 'out-eigenvector centrality',
'kc': 'katz centrality',
}
# method
if method in debtrank_alias:
if h_i_shock is None:
try:
self._h_i_shock = self._data.h_i_shock
except:
raise Exception(
"ERROR: the parameter 'h_i_shock' cannot be empty.",
h_i_shock)
else:
self._h_i_shock = h_i_shock
assert isinstance(
self._h_i_shock, (list, np.ndarray)
), "ERROR: the 'h_i_shock' you provided should be a list or np.ndarray."
assert len(
self._h_i_shock
) == self._data._N, "ERROR: the length of 'h_i_shock' you provided is not equal to data."
# the node labels
self._node_labels = {}
for i, j in zip(self._nodes, self._h_i_shock):
assert j >= 0, "ERROR: the value of h_i_shock should in [0,1]"
if j == 0.0:
self._node_labels[i] = i
else:
self._node_labels[i] = i + r"$\bigstar$"
# the method of debtrant
if method == 'dr':
# the legend labels
self._legend_labels = [
'debtrank < 25%', 'debtrank > 25%', 'debtrank > 50%',
'debtrank > 75%'
]
# the color of nodes
self._nodes_color = self._run_centrality(
method='dr', h_i_shock=self._h_i_shock,
t_max=max_iter)['node color']
elif method == 'nldr':
if alpha is None:
alpha = 0
print(
"Warning: the paramater of 'alpha' is essential! Default = %.2f"
% alpha)
# rename figure title
title = 'The interbank network, ' + r'$\alpha = %.2f$' % alpha + ' (%s)' % self._data._label_year
# the legend labels
self._legend_labels = [
'nonlinear debtrank < 25%', 'nonlinear debtrank > 25%',
'nonlinear debtrank > 50%', 'nonlinear debtrank > 75%'
]
# the color of nodes
self._nodes_color = self._run_centrality(
method='nldr',
h_i_shock=self._h_i_shock,
alpha=alpha,
t_max=max_iter)['node color']
else:
pass # TODO
_legend_elements = [
Line2D([0], [0],
marker='o',
color="#6495ED",
markersize=3.5,
label=self._legend_labels[0]),
Line2D([0], [0],
marker='o',
color="#EEEE00",
markersize=3.5,
label=self._legend_labels[1]),
Line2D([0], [0],
marker='o',
color="#EE9A00",
markersize=3.5,
label=self._legend_labels[2]),
Line2D([0], [0],
marker='o',
color="#EE0000",
markersize=3.5,
label=self._legend_labels[3]),
Line2D([0], [0],
marker='*',
markerfacecolor="#000000",
color='w',
markersize=6.5,
label='the initial shock')
]
_ncol = 5
elif method in importance_alias:
# title
title = r'$x_{shock} = %.2f$' % kwargs[
'x_shock'] + ', t = %d' % kwargs[
't'] + ' (%s)' % self._data._label_year
# the node labels
self._node_labels = dict(zip(self._nodes, self._nodes))
# 'lp'
self._legend_labels = [
'importantance level < 25%', 'importantance level > 25 %',
'importantance level > 50%', 'importantance level > 75%'
]
# the color of nodes
self._nodes_color = self._run_centrality(
method='lp', t=kwargs['t'],
x_shock=kwargs['x_shock'])['node color']
_legend_elements = [
Line2D([0], [0],
marker='o',
color="#6495ED",
markersize=3.5,
label=self._legend_labels[0]),
Line2D([0], [0],
marker='o',
color="#EEEE00",
markersize=3.5,
label=self._legend_labels[1]),
Line2D([0], [0],
marker='o',
color="#EE9A00",
markersize=3.5,
label=self._legend_labels[2]),
Line2D([0], [0],
marker='o',
color="#EE0000",
markersize=3.5,
label=self._legend_labels[3])
]
_ncol = 4
elif method in centrality_alias:
# the node labels
self._node_labels = dict(zip(self._nodes, self._nodes))
# 'dc'
if method == 'idc':
# dict: dictionary. see detail in centrality.
# the legend labels
self._legend_labels = [
'in-degree centrality < 25%', 'in-degree centrality > 25%',
'in-degree centrality > 50%', 'in-degree centrality > 75%'
]
# the color of nodes
self._in_degree_centrality = ct.in_degree_centrality(self._FN)
self._nodes_color = self._run_centrality(
method='idc',
centrality=self._in_degree_centrality)['node color']
elif method == 'odc':
# dict: dictionary. see detail in centrality.
# the legend labels
self._legend_labels = [
'out-degree centrality < 25%',
'out-degree centrality > 25%',
'out-degree centrality > 50%',
'out-degree centrality > 75%'
]
# the color of nodes
self._out_degree_centrality = ct.out_degree_centrality(
self._FN)
self._nodes_color = self._run_centrality(
method='odc',
centrality=self._out_degree_centrality)['node color']
elif method == 'dc':
# dict: dictionary. see detail in centrality.
# the legend labels
self._legend_labels = [
'degree centrality < 25%', 'degree centrality > 25%',
'degree centrality > 50%', 'degree centrality > 75%'
]
# the color of nodes
self._degree_centrality = ct.degree_centrality(self._FN)
self._nodes_color = self._run_centrality(
method='dc',
centrality=self._degree_centrality)['node color']
elif method == 'bc':
# dict: dictionary. see detail in centrality.
# the legend labels
self._legend_labels = [
'betweenness centrality < 25%',
'betweenness centrality > 25%',
'betweenness centrality > 50%',
'betweenness centrality > 75%'
]
# the color of nodes
self._betweenness_centrality = ct.betweenness_centrality(
self._FN, weight='weight', seed=seed)
self._nodes_color = self._run_centrality(
method='bc',
centrality=self._betweenness_centrality)['node color']
elif method == 'cc' or method == 'icc':
# dict: dictionary. see detail in centrality.
# the legend labels
self._legend_labels = [
'in-closeness centrality < 25%',
'in-closeness centrality > 25%',
'in-closeness centrality > 50%',
'in-closeness centrality > 75%'
]
# the color of nodes
self._in_closeness_centrality = ct.closeness_centrality(
self._FN, distance='weight')
self._nodes_color = self._run_centrality(
method='cc',
centrality=self._in_closeness_centrality)['node color']
elif method == 'occ':
# dict: dictionary. see detail in centrality.
# the legend labels
self._legend_labels = [
'out-closeness centrality < 25%',
'out-closeness centrality > 25%',
'out-closeness centrality > 50%',
'out-closeness centrality > 75%'
]
# the color of nodes
self._out_closeness_centrality = ct.closeness_centrality(
self._FN.reverse(), distance='weight')
self._nodes_color = self._run_centrality(
method='occ',
centrality=self._out_closeness_centrality)['node color']
elif method == 'ec' or method == 'iec':
# dict: dictionary. see detail in centrality.
# the legend labels
self._legend_labels = [
'in-eigenvector centrality < 25%',
'in-eigenvector centrality > 25%',
'in-eigenvector centrality > 50%',
'in-eigenvector centrality > 75%'
]
# the color of nodes
self._in_eigenvector_centrality = ct.eigenvector_centrality(
self._FN, max_iter=max_iter, weight='weight')
self._nodes_color = self._run_centrality(
method='ec',
centrality=self._in_eigenvector_centrality)['node color']
elif method == 'oec':
# dict: dictionary. see detail in centrality.
# the legend labels
self._legend_labels = [
'out-eigenvector centrality < 25%',
'out-eigenvector centrality > 25%',
'out-eigenvector centrality > 50%',
'out-eigenvector centrality > 75%'
]
# the color of nodes
self._out_eigenvector_centrality = ct.eigenvector_centrality(
self._FN.reverse(), max_iter=max_iter, weight='weight')
self._nodes_color = self._run_centrality(
method='oec',
centrality=self._out_eigenvector_centrality)['node color']
elif method == 'kc': # bug
# dict: dictionary. see detail in centrality.
# the legend labels
self._legend_labels = [
'katz centrality < 25%', 'katz centrality > 25%',
'katz centrality > 50%', 'katz centrality > 75%'
]
# the color of nodes
phi, _ = np.linalg.eig(self._Ad_ij)
self._katz_centrality = ct.katz_centrality(
self._FN, alpha=1 / np.max(phi) - 0.01, weight='weight')
self._nodes_color = self._run_centrality(
method='kc',
centrality=self._katz_centrality)['node color']
else:
pass # TODO
_legend_elements = [
Line2D([0], [0],
marker='o',
color="#6495ED",
markersize=3.5,
label=self._legend_labels[0]),
Line2D([0], [0],
marker='o',
color="#EEEE00",
markersize=3.5,
label=self._legend_labels[1]),
Line2D([0], [0],
marker='o',
color="#EE9A00",
markersize=3.5,
label=self._legend_labels[2]),
Line2D([0], [0],
marker='o',
color="#EE0000",
markersize=3.5,
label=self._legend_labels[3])
]
_ncol = 4
else:
# the node labels
self._node_labels = dict(zip(self._nodes, self._nodes))
self._nodes_color = node_color # "#00BFFF"
print("Warning: the color of nodes have no special meaning.")
# draw
draw_default = {
'node_size': self._node_assets,
'node_color': self._nodes_color,
'edge_color': self._edge_color,
'edge_cmap': plt.cm.binary,
'labels': self._node_labels,
'width': 0.8,
'style': 'solid',
'with_labels': True
}
# customize your nx.draw
if 'node_size' in kwargs:
draw_default['node_size'] = kwargs['node_size']
if 'node_color' in kwargs:
draw_default['node_color'] = kwargs['node_color']
if 'edge_cmap' in kwargs:
draw_default['edge_cmap'] = kwargs['edge_cmap']
if 'labels' in kwargs:
draw_default['labels'] = kwargs['labels']
if 'style' in kwargs:
draw_default['style'] = kwargs['style']
if 'with_labels' in kwargs:
draw_default['with_labels'] = kwargs['with_labels']
draw_kwargs = draw_default
plt.rcParams['figure.dpi'] = 160
plt.rcParams['savefig.dpi'] = 400
plt.title(title, fontsize=font_size + 2)
nx.draw(self._FN,
pos=nx.circular_layout(self._FN),
font_size=font_size,
**draw_kwargs)
if method:
plt.legend(handles=_legend_elements,
ncol=_ncol,
fontsize=font_size - 1,
loc='lower center',
frameon=False)
if is_savefig:
net = "interbanknetwork"
date = parse(self._data._label_year).strftime("%Y%m%d")
plt.savefig(net + date + '.png', format='png', dpi=400)
print("save to '%s'" % os.getcwd() + ' and named as %s' %
(net + date) + '.png')
else:
plt.show()
import numpy.linalg as LA
import numpy as np
from generate import er_multi
sizes = [30,32,41,39]
probs = [[.5,.05,.05,.05],[.05,.5,.05,.05],[.05,.05,.5,.05],[.05,.05,.05,.5]]
G = nx.stochastic_block_model(sizes, probs)
n = 100
k=5
p=.15
G = er_multi(n,k,p)
pos = nx.circular_layout(nx.erdos_renyi_graph(n,p))
#pos = {x:(pos[x[0]][0],pos[x[0]][1],x[1]) for x in G.nodes()}
pos = {x:pos[x[0]] for x in G.nodes()}
LM = (nx.laplacian_matrix(G)).todense()
#LM = (nx.normalized_laplacian_matrix(G)).todense()
LMva, LMve = LA.eigh(LM)
##plt.figure()
#plt.plot(np.sort(LMva),'*')
#plt.show()
#k=5
def plot_logfile_check(logfile, state_names='original'):
# Run the check
check_res = BeWatch.db.check_logfile(logfile)
# State numbering
if state_names == 'original':
state_num2names = BeWatch.db.get_state_num2names()
elif state_names == 'debug':
state_num2names = BeWatch.db.get_state_num2names_dbg()
else:
raise ValueError("unknown state names: %r" % state_names)
## Graph
# Form the graph object
G = nx.DiGraph()
# Nodes
for arg0 in check_res['norm_stm'].index:
G.add_node(arg0)
# Edges, weighted by transition prob
for arg1, arg1_col in check_res['norm_stm'].iteritems():
for arg0, val in arg1_col.iteritems():
if not np.isnan(val):
G.add_edge(arg0, arg1, weight=val)
# Edge labels are the weights
edge_labels=dict([((u,v,), "%0.2f" % d['weight'])
for u, v, d in G.edges(data=True)])
# Draw
pos = nx.circular_layout(G)
pos[17] = np.asarray([.25, .05])
pos[9] = np.asarray([.45, .05])
pos[8] = np.asarray([0, .05])
pos[13] = np.asarray([.5, .5])
f, ax = plt.subplots(figsize=(14, 8))
nx.draw(G, pos, ax=ax, with_labels=False, node_size=3000, node_shape='s')
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=10)
nx.draw_networkx_labels(G, pos, check_res['node_labels'], font_size=8)
f.subplots_adjust(left=.01, right=.99, bottom=.01, top=.99, wspace=0, hspace=0)
## Plot hists of all durations
f, axa = my.plot.auto_subplot(len(check_res['node_all_durations']),
figsize=(14, 10))
for node_num, ax in zip(
sorted(check_res['node_all_durations'].keys()), axa.flatten()):
data = check_res['node_all_durations'][node_num]
rng = data.max() - data.min()
tit_str = "%d: %s, %0.3f" % (node_num,
state_num2names[node_num].lower(), rng)
ax.set_title(tit_str, size='small')
ax.hist(data)
if np.diff(ax.get_xlim()) < .01:
mean_ax_xlim = np.mean(ax.get_xlim())
ax.set_xlim((mean_ax_xlim - .005, mean_ax_xlim + .005))
my.plot.rescue_tick(ax=ax, x=4, y=3)
f.tight_layout()
plt.show()
old_label: new_label
for old_label, new_label in itertools.zip_longest(
sorted(g.nodes()), list_columns_names, fillvalue=1)
}
#print(mapping)
# create a dictionary with zip()
#dictionary = dict(zip(list_columns_int, list_columns_names))
#print(dictionary)
# relabel the names of the nodes from integers back to strings
nx.relabel_nodes(g, mapping, copy=False)
plt.figure(figsize=(20, 10))
pos = nx.circular_layout(g)
#nx.draw(g, pos, node_color='red', edgelist=g.edges(), edge_color=weights, arrowsize=20, with_labels=True, node_size=100, width=1.5, edge_cmap=plt.cm.Reds)
output_file('index.html')
plt.show()
# plotting
# circular layout
plot_circle = Plot(plot_width=1000,
plot_height=715,
x_range=Range1d(-1.1, 1.1),
y_range=Range1d(-1.1, 1.1))
def generateAdjacencyRCC(overlaps, labels):
PO = nx.Graph()
for x in labels:
node_x = Node([x])
if not PO.has_node(node_x):
PO.add_node(node_x)
firing_counts = {}
for l in labels:
firing_counts[l] = 0
for bin in overlaps:
nodes = [Node([x]) for x in bin]
for x in bin:
firing_counts[x] += 1
for i in range(0, len(nodes)):
for j in range(i, len(nodes)):
if not PO.has_edge(nodes[i], nodes[j]):
PO.add_edge(nodes[i], nodes[j], weight=1.0)
else:
PO[nodes[i]][nodes[j]]['weight'] = PO[nodes[i]][
nodes[j]]['weight'] + 1.0
# remove proper part nodes
# averages = {}
# for node in PO.nodes():
# weights = [w for (u,v,w) in PO.edges(node, data='weight')]
# averages[node] = np.mean(weights)
#
# for (u,v,w) in PO.edges(data='weight'):
# forward = PO[u][v]['weight'] / averages[u]
# backward = PO[v][u]['weight'] / averages[v]
# PO[u][v]['weight'] = max([forward, backward])
mix = generateAdjacency(overlaps)
PO = nx.compose(PO, mix)
# pp_nodes = []
# PP = nx.Graph()
# for node in PO.nodes() :
# node_fire_count = 0
# if not PP.has_node(node):
# PP.add_node(node)
# for bin in overlaps:
# if node not in bin:
# continue
# node_fire_count += 1
# for other in PO.nodes():
# if other in bin:
# if not PP.has_node(other):
# PP.add_node(other)
# if not PP.has_edge(node, other):
# PP.add_edge(node, other, weight=1.0)
# else:
# G[node][other]['weight'] = G[node][other]['weight'] + 1.0
# for (u,v,w) in PP.edges(data='weight') :
# if u == node and w/node_fire_count > 0.7 :
# print('{} part of {}'.format(u,v))
# if u not in pp_nodes:
# pp_nodes.append(u)
#
# PO.remove_nodes_from(pp_nodes)
# cutoff 25 for W, 140 for figure8
bad = [(u, v) for (u, v, w) in PO.edges(data='weight') if w <= 6 or u == v]
PO.remove_edges_from(bad)
outdeg = PO.degree()
to_remove = [n for n in PO.nodes() if outdeg[n] == 0]
PO.remove_nodes_from(to_remove)
edges = []
for node in PO.nodes():
if len(node.cells) > 1:
for (u, v) in PO.edges(node):
for (u2, v2) in PO.edges(node):
if not v.cells == v2.cells:
if PO.has_edge(v, v2):
if all(i in node.cells for i in v.cells) and all(
i in node.cells for i in v2.cells):
if PO[u][v]['weight'] < (
PO[v][v2]['weight'] *
(3.0 / 4.0)) and PO[u][v2]['weight'] < (
PO[v][v2]['weight'] * 3.0 / 4.0):
edges.append((v, v2))
print(edges)
PO.remove_edges_from(edges)
# for (u,v,w) in PO.edges(data='weight'):
# forward = PO[u][v]['weight'] / firing_counts[str(u)]
# backward = PO[v][u]['weight'] / firing_counts[str(v)]
# PO[u][v]['weight'] = max([forward, backward])
# adjGraph = generateAdjacencyCount(overlaps, labels)
#
# for t in range(1,len(overlaps)-1):
# nodes_nm1 = [Node(n) for n in overlaps[t-1]]
# nodes_n = [Node(n) for n in overlaps[t]]
# nodes_np1 = [Node(n) for n in overlaps[t+1]]
# for n in nodes_n:
# for nm1 in nodes_nm1:
# if PO.has_edge(nm1, n):
# for np1 in nodes_np1:
# if PO.has_edge(n, np1):
# if (not adjGraph.has_edge(n, np1)) :
# PO[nm1][n]['weight'] = PO[nm1][n]['weight'] - 1
# else :
# PO[nm1][n]['weight'] = PO[nm1][n]['weight'] + 1
#
# for (u,v,w) in PO.edges(data='weight'):
# forward = PO[u][v]['weight']
# backward = PO[v][u]['weight']
# PO[u][v]['weight'] = max([forward, backward])
#
# bad = [(u, v) for (u, v, w) in PO.edges(data='weight') if w <= 0 or u == v]
# PO.remove_edges_from(bad)
#
# outdeg = PO.degree()
# to_remove = [n for n in PO.nodes() if outdeg[n] == 0]
# PO.remove_nodes_from(to_remove)
for node in PO.nodes():
print([node, getNumComponents([node], PO)])
labels = nx.get_edge_attributes(PO, 'weight')
pos = nx.circular_layout(PO)
nx.draw(PO, pos)
nx.draw_networkx_edge_labels(PO, pos, edge_labels=labels, label_pos=0.5)
nx.draw_networkx_labels(PO, pos)
plt.show()
def show_domain(self, a=0):
s = self.state
plt.figure("Domain")
if self.networkGraph is None: # or self.networkPos is None:
self.networkGraph = nx.Graph()
# enumerate all computer_ids, simulatenously iterating through
# neighbors list and compstatus
for computer_id, (neighbors,
compstatus) in enumerate(zip(self.NEIGHBORS, s)):
# Add a node to network for each computer
self.networkGraph.add_node(computer_id, node_color="w")
for uniqueEdge in self.UNIQUE_EDGES:
self.networkGraph.add_edge(
uniqueEdge[0], uniqueEdge[1],
edge_color="k") # Add an edge between each neighbor
self.networkPos = nx.circular_layout(self.networkGraph)
nx.draw_networkx_nodes(self.networkGraph,
self.networkPos,
node_color="w")
nx.draw_networkx_edges(self.networkGraph,
self.networkPos,
edge_color="k")
nx.draw_networkx_labels(self.networkGraph, self.networkPos)
plt.show()
else:
plt.clf()
blackEdges = []
redEdges = []
greenNodes = []
redNodes = []
for computer_id, (neighbors,
compstatus) in enumerate(zip(self.NEIGHBORS, s)):
if compstatus == self.RUNNING:
greenNodes.append(computer_id)
else:
redNodes.append(computer_id)
# Iterate through all unique edges
for uniqueEdge in self.UNIQUE_EDGES:
if (s[uniqueEdge[0]] == self.RUNNING
and s[uniqueEdge[1]] == self.RUNNING):
# Then both computers are working
blackEdges.append(uniqueEdge)
else: # If either computer is BROKEN, make the edge red
redEdges.append(uniqueEdge)
# "if redNodes", etc. - only draw things in the network if these lists aren't empty / null
if redNodes:
nx.draw_networkx_nodes(
self.networkGraph,
self.networkPos,
nodelist=redNodes,
node_color="r",
linewidths=2,
)
if greenNodes:
nx.draw_networkx_nodes(
self.networkGraph,
self.networkPos,
nodelist=greenNodes,
node_color="w",
linewidths=2,
)
if blackEdges:
nx.draw_networkx_edges(
self.networkGraph,
self.networkPos,
edgelist=blackEdges,
edge_color="k",
width=2,
style="solid",
)
if redEdges:
nx.draw_networkx_edges(
self.networkGraph,
self.networkPos,
edgelist=redEdges,
edge_color="k",
width=2,
style="dotted",
)
nx.draw_networkx_labels(self.networkGraph, self.networkPos)
plt.figure("Domain").canvas.draw()
plt.figure("Domain").canvas.flush_events()
# [0, 1./5, 0, 4./5, 0, 0],
# [1./4, 1./4, 0, 0, 1./4, 1./4],
# [1./6, 1./6, 1./6, 1./6, 1./6, 1./6]])
P_1 = np.array([[1, 0, 0, 0, 0, 0], [0.5, 0, 0.5, 0, 0, 0],
[0.1, 0, 0.5, 0.3, 0, 0.1], [0, 0, 0, 0.7, 0.1, 0.2],
[1. / 3, 0, 0, 1. / 3, 1. / 3, 0], [0, 0, 0, 0, 0, 1]])
P_2 = np.array([[1, 0, 0, 0, 0, 0], [0, 3. / 4, 1. / 4, 0, 0, 0],
[0, 1. / 8, 7. / 8, 0, 0, 0],
[1. / 4, 1. / 4, 0, 1. / 8, 3. / 8, 0],
[1. / 3, 0, 1. / 6, 1. / 4, 1. / 4, 0], [0, 0, 0, 0, 0, 1]])
T_1 = make_graph(P_1)
plt.figure()
plt.title("Directed Graph of Transition Probabilties")
pos = nx.circular_layout(T_1)
nx.draw(T_1, pos, node_size=1500, node_color="white", with_labels=True)
nx.draw_networkx_edges(T_1, pos, arrows=True)
T_2 = make_graph(P_2)
plt.figure()
plt.title("Directed Graph of Transition Probabilties")
pos = nx.circular_layout(T_2)
nx.draw(T_2, pos, node_size=1500, node_color="white", with_labels=True)
nx.draw_networkx_edges(T_2, pos, arrows=True)
plt.show()
