def main(): G_igraph, G_nx, nodes_vector = generate_data() aca0, aca1 = separate_data_by_academy(nodes_vector, G_nx) print aca0.nodes() print aca1.nodes() plt.subplot(121) nx.draw_networkx( G=aca0, pos=nx.spring_layout(aca0), with_labels=True, node_color='g', edge_color='b', alpha=1) plt.axis('off') plt.subplot(122) nx.draw_networkx( G=aca1, pos=nx.spring_layout(aca1), with_labels=True, node_color='g', edge_color='b', alpha=1) plt.axis('off') plt.show()
def 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 test_layouts(): G =nx.gnm_random_graph(10,15) rand = [nx.random_layout(G)] circ = [nx.circular_layout(G)] #shell = [nx.shell_layout(G)] #same as circular layout... spectral = [nx.spectral_layout(G)] tripod = [tripod_layout(G)] layouts = [rand,circ,spectral, tripod] regimes = ["random","circular","spectral", "tripod"] for layout in layouts: layout.append(nx.spring_layout(G,2,layout[0])) layout.append(iterate_swaps(G,layout[0])) layout.append(nx.spring_layout(G,2,layout[2])) layout.append(greedy_swapper(G,layout[0])) # Now have list of lists... Find lengths of edgecrossings... num_crossings = [] for layout in layouts: for sublayout in layout: num_crossings.append(count_crosses(G,sublayout)) names = [] for regime in regimes: names.append(regime) names.append(regime + "-spring") names.append(regime + "-swap") names.append(regime + "-swap-spr") names.append(regime + "-greedy") return G, layouts, names, num_crossings
def main(): ### Undirected graph ### # Initialize model using the Petersen graph model=gmm.gmm(nx.petersen_graph()) old_graph=model.get_base() model.set_termination(node_ceiling) model.set_rule(rand_add) # Run simualation with tau=4 and Poisson density for motifs gmm.algorithms.simulate(model,4) # View results new_graph=model.get_base() print(nx.info(new_graph)) # Draw graphs old_pos=nx.spring_layout(old_graph) new_pos=nx.spring_layout(new_graph,iterations=2000) fig1=plt.figure(figsize=(15,7)) fig1.add_subplot(121) #fig1.text(0.1,0.9,"Base Graph") nx.draw(old_graph,pos=old_pos,node_size=25,with_labels=False) fig1.add_subplot(122) #fig1.text(0.1,0.45,"Simulation Results") nx.draw(new_graph,pos=new_pos,node_size=20,with_labels=False) fig1.savefig("undirected_model.png") ### Directed graph ### # Initialize model using random directed Barabasi-Albert model directed_base=nx.barabasi_albert_graph(25,2).to_directed() directed_model=gmm.gmm(directed_base) directed_model.set_termination(node_ceiling) directed_model.set_rule(rand_add) # Run simualation with tau=4 and Poisson density for motifs gmm.algorithms.simulate(directed_model,4) # View results new_directed=directed_model.get_base() print(nx.info(new_directed)) # Draw directed graphs old_dir_pos=new_pos=nx.spring_layout(directed_base) new_dir_pos=new_pos=nx.spring_layout(new_directed,iterations=2000) fig2=plt.figure(figsize=(7,10)) fig2.add_subplot(211) fig2.text(0.1,0.9,"Base Directed Graph") nx.draw(directed_base,pos=old_dir_pos,node_size=25,with_labels=False) fig2.add_subplot(212) fig2.text(0.1,0.45, "Simualtion Results") nx.draw(new_directed,pos=new_dir_pos,node_size=20,with_labels=False) fig2.savefig("directed_model.png") # Export files nx.write_graphml(model.get_base(), "base_model.graphml") nx.write_graphml(directed_model.get_base(), "directed_model.graphml") nx.write_graphml(nx.petersen_graph(), "petersen_graph.graphml")
def getpositions(nodes, links, fixeditem=None): if nx_available: G = nx.Graph() G.add_nodes_from(nodes) G.add_edges_from(links) # print G.number_of_nodes() # print G.number_of_edges() # for line in nx.generate_adjlist(G): # print(line) if fixeditem: # so this currently doesnt appear to work # the node now seems to fix into centre pos = {1: (0, 0)} fixlist = [1] return nx.spring_layout(G, 2, 0.8, pos=pos, fixed=fixlist) else: # print nx.spring_layout(G, 2, 1.5, iterations=50) # TO DO set above to 0,0 for all - object of this is to avoid failure but # probably will make calling optional shortly return nx.spring_layout(G, 2, 1.5, iterations=50) else: # lets assign 0,0 for now - might move to random nodedict = {} for node in nodes: nodedict[node] = (0, 0) return nodedict
def draw_networkx_ex(): G = nx.dodecahedral_graph() nx.draw(G) plt.show() nx.draw_networkx(G, pos=nx.spring_layout(G)) limits = plt.axis('off') plt.show() nodes = nx.draw_networkx_nodes(G, pos=nx.spring_layout(G)) plt.show() edges = nx.draw_networkx_edges(G, pos=nx.spring_layout(G)) plt.show() labels = nx.draw_networkx_labels(G, pos=nx.spring_layout(G)) plt.show() edge_labels = nx.draw_networkx_edge_labels(G, pos=nx.spring_layout(G)) plt.show() print("Circular layout") nx.draw_circular(G) plt.show() print("Random layout") nx.draw_random(G) plt.show() print("Spectral layout") nx.draw_spectral(G) plt.show() print("Spring layout") nx.draw_spring(G) plt.show() print("Shell layout") nx.draw_shell(G) plt.show() print("Graphviz")
def draw_figures(problem, clique_collection, probability): """ function to draw figure :param problem: input problem :param clique_collection: all collection lists of cliques :param probability: input probability :return: show and save the out figure from origin to k-cliques graph with probability """ pos = nx.spring_layout(problem.G) pl.figure(1) pl.title("original figure with probability {p}".format(p=probability)) nx.draw(problem.G, pos=pos) nx.draw_networkx_labels(problem.G, pos, font_size=10, font_family='sans-serif') pl.savefig("origin_with_prob_{p}.png".format(p=probability)) # pl.show() for i in range(len(clique_collection)): new_nodes = [] for n in problem.G.nodes(): for li in clique_collection[i]: if n in li: new_nodes.append(n) subgraph = problem.G.subgraph(new_nodes) pos = nx.spring_layout(problem.G) pl.figure() pl.title('{k} cliques with probability {p}'.format(k=i+3, p=probability)) nx.draw(subgraph, pos=pos) nx.draw_networkx_labels(subgraph, pos, font_size=10, font_family='sans-serif') pl.savefig("{k}_cliq_with_prob_{p}.png".format(k=i+3, p=probability))
def drawSprings(corrMatrix, kclusters, initialPosFileName, mult=1.1): """drawSprings draws two figures, one of the spring evolution at 9 timepoints, one of the initial vs. final. :param corrMatrix: a data object generated by kmeans cluster - has the correlations between objects. :type corrMatrix: dict - must have 'data' and 'proteins' :param kclusters: the number of kclusters used in the analysis (what was passed to kmeans) :type kclusters: int :param initialPosFileName: a string pointing to the initial positions of each node - see nierhausPositions.txt :type initialPosFileName: string :param mult: a float of the base of the exponent to exapand on in each spring interation :type mult: float :returns: an array of figures - first is the evolution, second is the start and end. """ G = nx.Graph() positions = readDataFile(initialPosFileName) initialNodePos = {positions['proteins'][i]: [float(positions['data'][i,0])/4.0, float(positions['data'][i,1])/5.0] for i in range(len(positions['proteins']))} [G.add_node(x) for x in corrMatrix['proteins']] connection = (lambda x,y: corrMatrix['data'][x][y]) [G.add_edge(corrMatrix['proteins'][x],corrMatrix['proteins'][y], weight=connection(x,y)) for x in range(len(corrMatrix['proteins'])) for y in range(len(corrMatrix['proteins'])) if (connection(x,y)!=0)] weights = [G.get_edge_data(x[0],x[1])['weight'] for x in G.edges()] notes = pylab.figure() ax = notes.add_subplot(1,2,1, title="nierhaus positions_kclusters=" + str(kclusters)) drawNodePos = initialNodePos yDiff = [initialNodePos[x][1] - drawNodePos[x][1] for x in drawNodePos.keys()] nx.draw_networkx(G, pos = drawNodePos, node_size=600, node_color = yDiff, cmap = pylab.cm.RdBu, vmin=-1, vmax=1, edge_color=weights, edge_vmin = 0, edge_vmax = kMeansRuns, edge_cmap = pylab.cm.autumn_r, width=2, font_size=10, font_weight='bold') iters = int(mult**8) ax = notes.add_subplot(1,2,2, title="spring iteration=" + str(iters) + "_kclusters=" + str(kclusters)) drawNodePos = nx.spring_layout(G, pos=initialNodePos, iterations=iters) yDiff = [initialNodePos[x][1] - drawNodePos[x][1] for x in drawNodePos.keys()] nx.draw_networkx(G, pos = drawNodePos, node_size=600, node_color = yDiff, cmap = pylab.cm.RdBu, vmin=-1, vmax=1, edge_color=weights, edge_vmin = 0, edge_vmax = kMeansRuns, edge_cmap = pylab.cm.autumn_r, width=2, font_size=10, font_weight='bold') cb1ax = notes.add_axes([0.025, 0.1, 0.05, 0.8]) pylab.colorbar(cmap=pylab.cm.autumn_r, cax=cb1ax) cb2ax = notes.add_axes([0.925, 0.1, 0.05, 0.8]) norm = mpl.colors.Normalize(vmin=-1, vmax=1) cb2 = mpl.colorbar.ColorbarBase(cb2ax, cmap=pylab.cm.RdBu_r, norm=norm, orientation='vertical') notes2 = pylab.figure() drawNodePos = initialNodePos for i in range(9): ax = notes2.add_subplot(3,3,i+1, title="iterations=" + str(int(mult**i)) + "_k=" + str(kclusters)) drawNodePos = nx.spring_layout(G, pos=drawNodePos, iterations=int(mult**i)) yDiff = [initialNodePos[x][1] - drawNodePos[x][1] for x in drawNodePos.keys()] nx.draw_networkx(G, pos = drawNodePos, node_size=600, node_color = yDiff, cmap = pylab.cm.RdBu, vmin=-1, vmax=1, edge_color=weights, edge_vmin = 0, edge_vmax = kMeansRuns, edge_cmap = pylab.cm.autumn_r, width=2, font_size=10, font_weight='bold')
def paint_clusters(G1, G2, beacons_G1, beacons_G2, kmeans_labels1, kmeans_labels2): accent_colors = brewer2mpl.get_map('Accent', 'qualitative',8).mpl_colors plt.subplot(121) plt.axis('off') plt.title('$G_1$') (labels, node_colors, node_sizes) = visualize_beacons(G1, beacons_G1) clustered_colors = cluster_colors(G1, beacons_G1, kmeans_labels1, accent_colors) pos = nx.spring_layout(G1, weight=None) nx.draw_networkx_nodes(G1, pos, node_color=clustered_colors, node_size=node_sizes, font_size=18) nx.draw_networkx_labels(G1, pos, font_size=17, labels=labels, font_color = '#262626') nx.draw_networkx_edges(G1, pos, width=2, alpha=0.3) plt.subplot(122) plt.axis('off') plt.title('$G_2$') (labels, node_colors, node_sizes) = visualize_beacons(G2, beacons_G2) clustered_colors = cluster_colors(G2, beacons_G2, kmeans_labels2, accent_colors) pos2_init= {key:value for (key, value) in zip(beacons_G2,[pos[beacon] for beacon in beacons_G1])} pos2 = nx.spring_layout(G2, weight=None, pos = pos2_init) nx.draw_networkx_nodes(G2, pos=pos2, node_color=clustered_colors, node_size=node_sizes, font_size=18) nx.draw_networkx_labels(G2, pos=pos2, font_size=17, labels=labels, font_color = '#262626') nx.draw_networkx_edges(G2, pos=pos2, width=2, alpha=0.3)
def OnLocalPerturbation(self,e): k=0 dlg=wx.NumberEntryDialog(self,message='The Number of nodes in cluster, default 3!',prompt='k:',caption='k-anonymity parameter',value=3,min=2,max=40) if (dlg.ShowModal() == wx.ID_OK): k=dlg.GetValue() else: return self.rtb.SetValue("") self.PushStatusText("Starting Local Perturbation", SB_INFO) self.ShowPos() if len(self.g.node)!=0: origin_g=self.g.copy() result=lp.LocalPerturbation(self.g,k)#perturbation and get the clusters and new graph self.g=result[1] OutStr="the clusters:\n" for c in result[0]: OutStr=OutStr+str(tuple(c))+"\n" self.rtb.SetValue(OutStr) plt.figure("comparison") plt.subplot(211) plt.title ("original graph") nx.draw(origin_g,with_labels=True,pos=nx.spring_layout(origin_g)) plt.subplot(212) plt.title("new graph") nx.draw(self.g,with_labels=True,pos=nx.spring_layout(self.g)) plt.show() else: print 'Grap is empty!! Please load data!' wx.MessageBox("No data was selected. Please load data!","Data Error")
def Asymmetric_Networks(): G_asymmetric = nx.DiGraph() G_asymmetric.add_edge('A', 'B') G_asymmetric.add_edge('A', 'D') G_asymmetric.add_edge('C', 'A') G_asymmetric.add_edge('D', 'E') nx.spring_layout(G_asymmetric) nx.draw_networkx(G_asymmetric)
def add_ndex_spring_layout_with_attractors(g, node_width, attractor_map, iterations=None, use_degree_edge_weights=False): fixed = [] initial_pos = {} g_simple = _create_simple_graph(g) next_node_id = max(g_simple.nodes()) + 1 cc = sorted(nx.connected_components(g_simple), key = len, reverse=True) if len(cc) > 1: print("%s disconnected subgraphs: adding centerpoint attractor with edges to one of the least connected nodes in each subgraph" % len(cc)) anchor_node_ids = [] for c in cc: cl = list(c) min_degree = min(cl) min_index = cl.index(min_degree) node_id = cl[min_index] anchor_node_ids.append(node_id) attractor_id = next_node_id g_simple.add_node(next_node_id) next_node_id = next_node_id + 1 fixed.append(attractor_id) initial_pos[attractor_id] = (0.5, 0.5) for node_id in anchor_node_ids: g_simple.add_edge(node_id, attractor_id) for attractor in attractor_map: attractor_id = next_node_id g_simple.add_node(next_node_id) next_node_id = next_node_id + 1 fixed.append(attractor_id) initial_pos[attractor_id] = attractor["position"] for node_id in attractor["node_ids"]: g_simple.add_edge(node_id, attractor_id) # , {"weight":2.5}) if use_degree_edge_weights: _add_degree_edge_weights(g_simple) scaled_pos = {} scale_factor = 4 * node_width * math.sqrt(g.number_of_nodes()) for node in g_simple.nodes(): x_pos = random.random() * scale_factor y_pos = random.random() * scale_factor scaled_pos[node] = (x_pos, y_pos) for node_id in initial_pos: position = initial_pos[node_id] scaled_pos[node_id] = (scale_factor * position[0], scale_factor * position[1]) if len(fixed) > 0: final_positions = nx.spring_layout(g_simple, fixed=fixed, pos=scaled_pos, iterations=iterations) for node_id in fixed: final_positions.pop(node_id) else: final_positions = nx.spring_layout(g_simple, pos=scaled_pos, iterations=iterations) g.pos = final_positions
def test_algo_euler4(self): fLOG (__file__, self._testMethodName, OutputPrint = __name__ == "__main__") folder = os.path.join(os.path.abspath(os.path.dirname(__file__)),"temp_rues5") if not os.path.exists(folder) : os.mkdir(folder) edges = get_data(whereTo=folder) edges = edges[:3] vertices = { } for e in edges : for i in range(0,2): _ = e[i] p = e[i+3] vertices[_] = p connex = connected_components(edges) v = [ v for k,v in connex.items() ] mi,ma = min(v), max(v) while mi != ma : edges.append( (mi, ma, 2, vertices[mi], vertices[ma], distance_haversine( * (vertices[mi] + vertices[ma]) ) ) ) connex = connected_components(edges) v = [ v for k,v in connex.items() ] mi,ma = min(v), max(v) if __name__ == "__main__": import matplotlib.pyplot as plt import networkx as nx fig = plt.figure() G = nx.Graph() for e in edges : a,b = e[:2] G.add_edge(a,b) pos = nx.spring_layout(G) nx.draw(G,pos,node_color='#A0CBE2') plt.savefig(os.path.join(folder, "graph1.png")) added = eulerien_extension( edges, fLOG=lambda *l : None, distance = distance_paris) if __name__ == "__main__": for e in added : a,b = e[:2] G.add_edge(a,b) fig = plt.figure() pos = nx.spring_layout(G) deg = graph_degree(edges + added) #labels={ v:"{0}".format(deg[v]) for v in G.nodes() } nx.draw(G,pos,node_color='#A0CBE2'#,labels=labels ) plt.savefig(os.path.join(folder, "graph2.png")) path = euler_path(edges, added) all = edges + added fLOG(len(all),len(path))
def display(Y): weight = 0.03 node_size = 50 node_alpha = 0.5 node_color = "blue" edge_tickness = 0.5 edge_alpha = 0.5 edge_color = "black" scores = get_histogram(Y) F = plt.figure() ax1 = F.add_subplot(2,2,1) ax1.hist(scores,bins=30, color="green", edgecolor="white") ax1.set_xlabel("Pearons Correlation Coefficient") ax1.set_ylabel("Frequency") ax2 = F.add_subplot(2,2,2) G = make_network(Y,threshold=0.95,weight=weight) pos = nx.spring_layout(G) nx.draw(G, pos,ax=ax2,node_size=15) nx.draw_networkx_nodes(G,pos,node_size=node_size, alpha=node_alpha, node_color=node_color) nx.draw_networkx_edges(G,pos,width=edge_tickness, alpha=edge_alpha,edge_color=edge_color) ax2.set_title("Network Thresholded, > 0.95") ax3 = F.add_subplot(2,2,3) ax3.set_title("Network Thresholded, > 0.55") G = make_network(Y,threshold=0.55,weight=weight) pos = nx.spring_layout(G) nx.draw(G, pos,ax=ax3,node_size=15) nx.draw_networkx_nodes(G,pos,node_size=node_size, alpha=node_alpha, node_color=node_color) nx.draw_networkx_edges(G,pos,width=edge_tickness, alpha=edge_alpha,edge_color=edge_color) ax4 = F.add_subplot(2,2,4) penalties = np.linspace(0.0, 1.0,20) counts = [len([x for x in nx.connected_components(make_network(Y,threshold=p, weight=1,add=True))]) for p in penalties] ax4.plot(penalties, counts) ax4.scatter(penalties, counts) ax4.set_xlabel("Pearon's Treshold") ax4.set_ylabel("Number of Connected Components") plt.tight_layout() plt.show()
def create_plot1(g, df=None, dedirect=False, flatten=False, edgelabels = True, nodelabels=True, fsize=None, K=None, save=False): """Creates a graph from a figure returns/shows a figure. Args: g - (networkx graph object) df - pandas dataframe object. Default is None dedirect - converts networkx DiGraph to Graph. Default is False flatten - manipultes a graph by replacing nodes that have only two edges with straighforward edge. Also, groups these kind of edges if it is possible edgelabels . Default is None nodelables . Default is None fsize K Save Returns: matplotlib figure """ if dedirect==True: g = nx.Graph(g) if fsize != None: plt.figure(1, figsize=fsize) pos = nx.spring_layout(g, dim=2, scale=1) if flatten == True: g = flatten_graph(g) pos = nx.spring_layout(g, dim=2, scale=1) pos = nx.spring_layout(g, dim=2, scale=10, k=K) node_colors = get_node_colors(g.nodes(), df) nx.draw_networkx_nodes(g, pos, alpha=0.3, node_size=300, node_color=node_colors) edge_colors = get_edge_colors(g.edges(), df) nx.draw_networkx_edges(g, pos, alpha=0.1, edge_color='b') if nodelabels == True: nx.draw_networkx_labels(g, pos) if edgelabels == True: nx.draw_networkx_edge_labels(g, pos) if save == True: mpld3.save_html(figure(1), 'graph.html') return plt.figure(1)
def test_plot(image): graph = nx.from_numpy_matrix(image) plt.subplot2grid((9, 3), (0, 0), rowspan=3, colspan=3) nx.draw(graph, nx.spring_layout(graph)) plt.hold(True) plt.subplot2grid((9, 3), (3, 0), rowspan=3, colspan=3) nx.draw(graph, nx.spring_layout(graph)) plt.hold(True) plt.subplot2grid((9, 3), (6, 0), rowspan=3, colspan=3) nx.draw(graph, nx.spring_layout(graph)) plt.axis('tight') plt.show()
def plot_graph(graph, fixed=None, positions=None, show_plot=True, fpath=None): """Plot graph. Parameters ---------- graph : networkx.MultiDiGraph Output from `make_graph` fixed : {None}, list, optional Node around which to fix graph. Overrides `positions`. Example: fixed=['mod1'] positions : {None}, dict, optional ``dict`` of ``list`` output from `make_positions_dict`. Requires `fixed` is ``None``, otherwise overridden. show_plot : {True, False}, bool, optional Flag to display plot in window. fpath : {None}, string, optional Path for plotting graph. Returns ------- None See Also -------- CALLS : {} CALLED_BY : {} RELATED : {make_positions_dict, make_graph} """ # TODO: Space out points. Scale to larger image? # TODO: make relationships different colors # Check input and define positions. if fixed is None: if positions is None: pos = nx.spring_layout(graph, fixed=fixed) else: pos = positions else: if positions is not None: warnings.warn( ("\n" + "`fixed` overrides `positions`:\n" + "fixed = {fixed}").format( fixed=fixed)) pos = nx.spring_layout(graph, fixed=fixed) # Draw graph and save. nx.draw(graph, pos=pos) nx.draw_networkx_labels(graph, pos=pos) if fpath is not None: plt.savefig(fpath, bbox_inches='tight') plt.show() return None
def autoCoordinates(meshEntry,srcdesConnection): #for cmpt,memb in meshEntry.items(): # print memb xmin = 0.0 xmax = 1.0 ymin = 0.0 ymax = 1.0 G = nx.Graph() for cmpt,memb in meshEntry.items(): for enzObj in find_index(memb,'enzyme'): G.add_node(enzObj.path) for cmpt,memb in meshEntry.items(): for poolObj in find_index(memb,'pool'): G.add_node(poolObj.path) for cplxObj in find_index(memb,'cplx'): G.add_node(cplxObj.path) G.add_edge((cplxObj.parent).path,cplxObj.path) for reaObj in find_index(memb,'reaction'): G.add_node(reaObj.path) for inn,out in srcdesConnection.items(): if (inn.className =='ZombieReac'): arrowcolor = 'green' elif(inn.className =='ZombieEnz'): arrowcolor = 'red' else: arrowcolor = 'blue' if isinstance(out,tuple): if len(out[0])== 0: print inn.className + ':' +inn[0].name + " doesn't have input message" else: for items in (items for items in out[0] ): G.add_edge(element(items[0]).path,inn.path) if len(out[1]) == 0: print inn.className + ':' + inn[0].name + "doesn't have output mssg" else: for items in (items for items in out[1] ): G.add_edge(inn.path,element(items[0]).path) elif isinstance(out,list): if len(out) == 0: print "Func pool doesn't have sumtotal" else: for items in (items for items in out ): G.add_edge(element(items[0]).path,inn.path) nx.draw(G,pos=nx.spring_layout(G)) #plt.savefig('/home/harsha/Desktop/netwrokXtest.png') xcord = [] ycord = [] position = nx.spring_layout(G) for y in position.values(): xcord.append(y[0]) ycord.append(y[1]) return(min(xcord),max(xcord),min(ycord),max(ycord),position)
def main(G): """draw the input graph and the colored out put graph determine the centroides and clusters """ try: val_map = {'A': 1.0, 'D': 0.5714285714285714, 'H': 0.0} values = [val_map.get(node, 0.45) for node in G.nodes()] edge_colors = 'k' edge_labels=dict([((u,v,),d['weight']) for u,v,d in G.edges(data=True)]) pos=nx.spring_layout(G) # positions for all nodes nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels) nx.draw(G,pos, node_color = values, node_size=15,edge_color=edge_colors,edge_cmap=plt.cm.Reds) pylab.show() km = BKM.KMeans(G, n_clusters, max_iter=100) pos=nx.spring_layout(G) # positions for all nodes node_colors = ['b','g','r','y','c','k','m'] for i in range(len(G)): node_colors.append('w') # nodes Clust = km.fit_predict(G)[1] for item in range(n_clusters): for group in Clust[item]: nx.draw_networkx_nodes(G,pos, nodelist = Clust[item], node_color=node_colors[item], node_size=80, alpha=0.8) edge_colors = 'k' 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) nx.draw(G,pos, node_color = values, node_size=1,edge_color=edge_colors,edge_cmap=plt.cm.Reds) pylab.show() print(km.__str__()) except BKM.KMeansError: print( "Got an imput error, please change the input and try it again." )
def main(G): """draw the input graph and the colored out put graph determine the clusters after each level of merging """ try: val_map = {'A': 1.0, 'D': 0.5714285714285714, 'H': 0.0} values = [val_map.get(node, 0.45) for node in G.nodes()] edge_colors = 'k' edge_labels=dict([((u,v,),d['weight']) for u,v,d in G.edges(data=True)]) pos=nx.spring_layout(G) # positions for all nodes nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels) nx.draw(G,pos, node_color = values, node_size=15,edge_color=edge_colors,edge_cmap=plt.cm.Reds) pylab.show() for ite in range(len(G.nodes())): Iterations = ite AL = AVG.Average_linkage(G, Iterations) #print(AL.__str__()) pos=nx.spring_layout(G) # positions for all nodes node_colors = ['b','g','r','y','c','k','m'] for i in range(len(G)): node_colors.append('w') # nodes C_list = AL.fit_predict(G)[-1,:] for Clust in range(C_list.shape[1]): nx.draw_networkx_nodes(G,pos, nodelist = list(C_list[0,Clust]), node_color=node_colors[Clust], node_size=80, alpha=0.8) # edges nx.draw_networkx_edges(G,pos,width=1.0,alpha=0.5) nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels) plt.axis('off') plt.savefig("labels_and_colors.png") # save as png plt.show() # display print "in level :",ite print AL.__str__() except AVG.Average_linkage_Error: print( "Got an imput error, please change the input and try it again." )
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 main(G): """draw the input graph and the colored out put graph determine the clusters after each level of merging """ try: val_map = {'A': 1.0, 'D': 0.5714285714285714, 'H': 0.0} values = [val_map.get(node, 0.45) for node in G.nodes()] edge_colors = 'k' edge_labels=dict([((u,v,),d['weight']) for u,v,d in G.edges(data=True)]) pos=nx.spring_layout(G) # positions for all nodes nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels) nx.draw(G,pos, node_color = values, node_size=15,edge_color=edge_colors,edge_cmap=plt.cm.Reds) pylab.show() SC = SCl.SpecClust(G, n_cluster) pos=nx.spring_layout(G) # positions for all nodes node_colors = ['b','g','r','y','c','k','m'] for i in range(len(G)): node_colors.append('w') Cluster_for_index = SC.fit_predict(G) for i in range(n_cluster): Nodes = [] for j in Cluster_for_index[i]: Nodes.append(G.nodes()[j]) nx.draw_networkx_nodes(G,pos, nodelist = Nodes, node_color=node_colors[i], node_size=80, alpha=0.8) edge_colors = 'k' 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) nx.draw(G,pos, node_color = values, node_size=1,edge_color=edge_colors,edge_cmap=plt.cm.Reds) pylab.show() print (SC.__str__()) except SCl.SpecClust_error: print( "Got an imput error, please change the input and try it again." )
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 getpositions(nodes, links, fixeditem=None): if nx_available: G = nx.Graph() G.add_nodes_from(nodes) G.add_edges_from(links) if fixeditem: #so this currently doesnt appear to work #the node now seems to fix into centre pos = {1:(0,0)} fixlist = [1] return nx.spring_layout(G, 2, 0.7, pos=pos, fixed=fixlist) else: return nx.spring_layout(G, 2, 0.7) else: return dict(bla='bla')
def plot(self, **kwargs): """Plots the underlying graph.""" plt.figure(facecolor='#fefefe', dpi=80, frameon=True) plt.axis('off') try: positions = nx.graphviz_layout(self.graph) except ImportError as err: log.info('Graphviz not available: error=%s', err) log.info('Falling back to spring layout...') positions = nx.spring_layout(self.graph) #FIXME: Caused by bin/coffea in some cases except TypeError as err: log.warn('Graphviz layout failed: error=%s', err) log.warn('Falling back to spring layout...') positions = nx.spring_layout(self.graph) if 'calc_node_size' in kwargs and kwargs['calc_node_size']: node_size = self._node_size_vector if node_size is None: node_size = 300 else: node_size = 300 log.debug('Drawing nodes...') nx.draw_networkx_nodes(self.graph, positions, node_color=self.node_colors, node_size=node_size, alpha=0.8) log.debug('Drawing edges...') nx.draw_networkx_edges(self.graph, positions, edge_color='#666666', alpha=0.75) log.debug('Drawing labels...') nx.draw_networkx_labels(self.graph,positions, font_color='#222222', font_family='courier new', font_weight='bold') log.debug('Plotting graph...') try: filename = kwargs['filename'] plt.savefig(filename, bbox_inches='tight') except KeyError: plt.show()
def drawFactorGraph(self,var_color='w',factor_color=(.2,.2,.8),**kwargs): """Draw a factorgraph using networkx function calls Args: var_color (str, tuple): networkx color descriptor for drawing variable nodes factor_color (str, tuple): networkx color for drawing factor nodes var_labels (dict): variable id to label string for variable nodes factor_labels (dict): factor id to label string for factor nodes ``**kwargs``: remaining keyword arguments passed to networkx.draw() Example: >>> model.drawFactorGraph( var_labels={0:'0', ... } ) # keyword args passed to networkx.draw() """ # TODO: specify var/factor shape,size, position, etc.; return G? silent mode? import networkx as nx G = nx.Graph() vNodes = [v.label for v in self.X if v.states > 1] # list only non-trivial variables fNodes = [-i-1 for i in range(len(self.factors))] # use negative IDs for factors G.add_nodes_from( vNodes ) G.add_nodes_from( fNodes ) for i,f in enumerate(self.factors): for v1 in f.vars: G.add_edge(v1.label,-i-1) pos = nx.spring_layout(G) # so we can use same positions multiple times... kwargs['var_labels'] = kwargs.get('var_labels',{n:n for n in vNodes}) kwargs['labels'] = kwargs.get('var_labels',{}) nx.draw_networkx(G,pos, nodelist=vNodes,node_color=var_color,**kwargs) kwargs['labels'] = kwargs.get('factor_labels',{}) # TODO: need to transform? nx.draw_networkx_nodes(G,pos, nodelist=fNodes,node_color=factor_color,node_shape='s',**kwargs) nx.draw_networkx_edges(G,pos,**kwargs) return G
def display_retweet_network(network, outfile=None, show=False): """ Take a DiGraph (retweet network?) and display+/save it to file. Nodes must have a 'color' property, represented literally and indicating their type Edges must have a 'weight' property, represented as edge width """ import networkx as nx import matplotlib.pyplot as plt # Create a color list corresponding to nodes. node_colors = [ n[1]["color"] for n in network.nodes(data=True) ] # Get edge weights from graph edge_weights = [ e[2]["weight"] for e in network.edges(data=True) ] # Build up graph figure #pos = nx.random_layout(network) pos = nx.spring_layout(network) nx.draw_networkx_edges(network, pos, alpha=0.3 , width=edge_weights, edge_color='m') nx.draw_networkx_nodes(network, pos, node_size=400, node_color=node_colors, alpha=0.4) nx.draw_networkx_labels(network, pos, fontsize=6) plt.title("Retweet Network", { 'fontsize': 12 }) plt.axis('off') if outfile: print "Saving network to file: {0}".format(outfile) plt.savefig(outfile) if show: print "Displaying graph. Close graph window to resume python execution" plt.show()
def main(): G=nx.Graph() G.add_edge('a','b',weight=0.6) G.add_edge('a','c',weight=0.2) G.add_edge('c','d',weight=0.1) G.add_edge('c','e',weight=0.7) G.add_edge('c','f',weight=0.9) G.add_edge('a','d',weight=0.3) elarge=[(u,v) for (u,v,d) in G.edges(data=True) if d['weight'] >0.5] esmall=[(u,v) for (u,v,d) in G.edges(data=True) if d['weight'] <=0.5] pos=nx.spring_layout(G) # positions for all nodes # nodes nx.draw_networkx_nodes(G,pos,node_size=700) # edges nx.draw_networkx_edges(G,pos,edgelist=elarge,width=6) nx.draw_networkx_edges(G,pos,edgelist=esmall,width=6,alpha=0.5,edge_color='b',style='dashed') # labels nx.draw_networkx_labels(G,pos,font_size=20,font_family='sans-serif') plt.axis('off') #plt.savefig("weighted_graph.png") # save as png plt.show() # display return
def draw(inF): G = nx.Graph() inFile = open(inF) S = set() for line in inFile: line = line.strip() fields = line.split('\t') for item in fields: S.add(item) inFile.close() L = list(S) G.add_nodes_from(L) LC = [] for x in L: if x == 'EGR1' or x == 'RBM20': LC.append('r') else: LC.append('w') inFile = open(inF) for line in inFile: line = line.strip() fields = line.split('\t') for i in range(len(fields)-1): G.add_edge(fields[i], fields[i+1]) inFile.close() nx.draw_networkx(G,pos=nx.spring_layout(G), node_size=800, font_size=6, node_color=LC) limits=plt.axis('off') plt.savefig(inF + '.pdf')
def test_labels_and_colors(self): G = nx.cubical_graph() pos = nx.spring_layout(G) # positions for all nodes # nodes nx.draw_networkx_nodes(G, pos, nodelist=[0, 1, 2, 3], node_color='r', node_size=500, alpha=0.8) nx.draw_networkx_nodes(G, pos, nodelist=[4, 5, 6, 7], node_color='b', node_size=500, alpha=0.8) # edges nx.draw_networkx_edges(G, pos, width=1.0, alpha=0.5) nx.draw_networkx_edges(G, pos, edgelist=[(0, 1), (1, 2), (2, 3), (3, 0)], width=8, alpha=0.5, edge_color='r') nx.draw_networkx_edges(G, pos, edgelist=[(4, 5), (5, 6), (6, 7), (7, 4)], width=8, alpha=0.5, edge_color='b') # some math labels labels = {} labels[0] = r'$a$' labels[1] = r'$b$' labels[2] = r'$c$' labels[3] = r'$d$' labels[4] = r'$\alpha$' labels[5] = r'$\beta$' labels[6] = r'$\gamma$' labels[7] = r'$\delta$' nx.draw_networkx_labels(G, pos, labels, font_size=16) plt.show()
import matplotlib.pyplot as plt import networkx as nx G = nx.binomial_graph(10, 0.3, directed=True) layout = nx.spring_layout(G) plt.figure(1) nx.draw(G, pos=layout, node_color='y') pr = nx.pagerank(G, alpha=0.85) print(pr) for node, pageRankValue in pr.items(): print("%d,%.4f" % (node, pageRankValue)) plt.figure(2) nx.draw(G, pos=layout, node_size=[x * 6000 for x in pr.values()], node_color='m', with_labels=True) plt.show()
], ] for x in range(20): name = datasetNamesB[x][0] listTables.insert( 'end', datasetNamesB[x][0] ) #If you want nodes without [cost] replace all file datasetNamesB with datasetNamesA i = 0 for y in datasetCost[x]: if y != -1: DG.add_weighted_edges_from([(name, datasetNamesB[i][0], y)], pos=(53.5672, 10.0285)) i += 1 pos = nx.spring_layout(DG) nx.draw_networkx_edge_labels(DG, pos, edge_labels=nx.get_edge_attributes( DG, 'weight'), font_color='red', ax=a) nx.draw_networkx(DG, pos, font_size=16, with_labels=False, edge_color='b', ax=a) # for p in pos: # raise text positions # pos[p][1] += 0.07 nx.draw_networkx_labels(DG, pos, font_size=10, ax=a)
Gd = nx.davis_southern_women_graph() Ad = AntiGraph(nx.complement(Gd)) Gk = nx.karate_club_graph() Ak = AntiGraph(nx.complement(Gk)) pairs = [(Gnp, Anp), (Gd, Ad), (Gk, Ak)] # test connected components for G, A in pairs: gc = [set(c) for c in nx.connected_components(G)] ac = [set(c) for c in nx.connected_components(A)] for comp in ac: assert comp in gc # test biconnected components for G, A in pairs: gc = [set(c) for c in nx.biconnected_components(G)] ac = [set(c) for c in nx.biconnected_components(A)] for comp in ac: assert comp in gc # test degree for G, A in pairs: node = list(G.nodes())[0] nodes = list(G.nodes())[1:4] assert G.degree(node) == A.degree(node) assert sum(d for n, d in G.degree()) == sum(d for n, d in A.degree()) # AntiGraph is a ThinGraph, so all the weights are 1 assert sum(d for n, d in A.degree()) == sum(d for n, d in A.degree(weight="weight")) assert sum(d for n, d in G.degree(nodes)) == sum(d for n, d in A.degree(nodes)) pos = nx.spring_layout(G, seed=268) # Seed for reproducible layout nx.draw(Gnp, pos=pos) plt.show()
def draw_graph(G, size=7): global plot plt.figure(plot, (size, size)) pos = nx.spring_layout(G) nx.draw_networkx(G, with_labels=True, pos=pos) plot += 1
def choose_identifier_MST(attribute_1,path_dic_identifier,U): search_attribute_1=first_function(attribute_1,path_dic_identifier) sub_1=U.subgraph(search_attribute_1) labels={} for i in nx.nodes(sub_1): labels[i] = i plt.figure() pos = nx.spring_layout(U) nx.draw_networkx_nodes(U, pos, nodelist=search_attribute_1, node_color='b') nx.draw_networkx_nodes(U, pos, nodelist=list(set(nx.nodes(U))-set(search_attribute_1)), node_color='r') nx.draw_networkx_labels(U, pos, labels, font_size=10) nx.draw_networkx_edges(U, pos, edgelist=nx.edges(U)) plt.axis('off') plt.legend((str(attribute_1),'others')) print("degree of",attribute_1,":") print("\n") degree_nodes=nx.degree(U) degree={} for i in labels.keys(): degree[i]=degree_nodes[i] degree_nodes_sorted= sorted(degree,key=degree.get, reverse=True) for r in degree_nodes_sorted: print(r,degree[r]) print("\n") print("betweeness centrality of",attribute_1,":") print("\n") centrality_nodes=nx.betweenness_centrality(U) centrality={} for i in labels.keys(): centrality[i]=centrality_nodes[i] centrality_nodes_sorted= sorted(centrality,key=centrality.get, reverse=True) for r in centrality_nodes_sorted: print(r,centrality[r]) print("\n") print ('graphical representation:') plt.figure() degree_nodes=nx.degree(U) centrality_nodes=nx.betweenness_centrality(U) x=list(degree_nodes.keys()) z=list(centrality_nodes.values()) y=list(degree_nodes.values()) y_sort = sorted(y, key=int, reverse=False) fig, ax = plt.subplots(figsize=(30, 15)) #ax1=plt.subplots() #ax2=ax1.twinx() ax.plot(x,y_sort, c='b') ax1=ax.twinx() #df.sort() ax1.plot(x,z, c='r') red_patch = mpatches.Patch(color='red', label='betweeness centrality') blue_patch = mpatches.Patch(color='blue', label='degree') plt.legend(handles=[red_patch, blue_patch]) return(plt.show())
def graph(self): # from random import random IEfamilies = [] IEs = [] try: try: with open (self.minimapOut,'r') as file1: for line in file1: line = line.rstrip() sp = line.split('\t') query1 = sp[0].split('_') coords1 = query1[3].split('-') starta = coords1[0] stopa = coords1[1] length1 = int(stopa) - int(starta) # query2 = sp[1].split('_') # coords2 = query2[3].split('-') # startb = coords2[0] # stopb = coords2[1] # length2 = int(stopb) - int(startb) # print(float(int(sp[3])/length1)) if length1 > 0: if float(int(sp[3])/length1) > 0.8: with open('./Data_{0}/final_introns.tsv'.format(self.NAME), 'a') as file2: file2.write('{0}\n'.format(line)) # else: # # if float(int(sp[3])/length1) > 0.7: # with open('./Data_{0}/final_introns.tsv'.format(self.NAME), 'a') as file2: # file2.write('{0}\n'.format(line)) # else: # print(float(int(sp[3])/length2)) # if length2 > 180: # if float(int(sp[3])/length2) > 0.6: # with open('./Data_{0}/final_introns.tsv'.format(self.NAME), 'a') as file2: # file2.write('{0}\n'.format(line)) # else: # if float(int(sp[3])/length2) > 0.7: # with open('./Data_{0}/final_introns.tsv'.format(self.NAME), 'a') as file2: # file2.write('{0}\n'.format(line)) data = pd.read_csv('./Data_{0}/final_introns.tsv'.format(self.NAME), sep='\t', header=None) df = nx.from_pandas_edgelist(data, source=0, target=1, edge_attr=True) communities_generator = community.girvan_newman(df) top_level_communities = next(communities_generator) IEfam = sorted(map(sorted, top_level_communities)) for fam in IEfam: if len(fam) > 5: IEfamilies.append(fam) else: IEs = IEs + fam for fam in IEs: df.remove_node(fam) print(len(IEfamilies)) pos = nx.spring_layout(df) plt.figure(figsize=(20,20)) # colors = [(random(), random(), random()) for _i in range(10)] nx.draw_networkx(df, pos, with_labels=False) #plt.title('{0}'.format(self.NAME)) #print(IEfamilies) colorListTwo = ['Red', 'Lime', 'Blue', 'Yellow', 'Cyan', 'Magenta', 'Maroon', 'Olive', 'Green', 'Purple', 'Teal', 'Navy', 'darkgoldenrod', 'cadetblue', 'aqua', 'darkseagreen', 'lightblue', 'deeppink', 'mediumslateblue', 'gold', 'coral', 'slategrey', 'indigo', 'lawngreen', 'beige', 'rosybrown', 'mediumspringgreen', 'mediumblue', 'orchid', 'aliceblue', 'darkmagenta', 'darkseagreen', 'limegreen', 'powderblue', 'whitesmoke', 'navajowhite', 'oldlace', 'mediumpurple', 'mediumturquoise', 'peru', 'plum', 'wheat', 'thistle', 'sienna', 'linen', 'lemonchiffon', 'khaki', 'darkorchid', 'cornsilk', 'cadetblue' ] count = 0 for fam in IEfamilies: # print(fam) nx.draw_networkx_nodes(df, pos, with_labels=False, nodelist = fam, node_color = colorListTwo[count]) count += 1 os.system("rm -r ./Data_{0}/final_introns.tsv".format(self.NAME)) plt.savefig('./Data_{0}/Blast_fig.png'.format(self.NAME)) except EmptyDataError: pass except NameError: IEfamilies = 'None' return IEfamilies
def draw_graph(G): pos = nx.spring_layout(G) nx.draw_networkx_nodes(G, pos,cluster_0, node_color='r') nx.draw_networkx_nodes(G, pos,cluster_1, node_color='b') nx.draw_networkx_labels(G, pos,font_size=10) nx.draw_networkx_edges(G, pos, width=1.0, alpha=0.5)
def drawjrsr(jrsrpeers, jrsrnodes, jrsredges, jrsrdevnodes): usernodes = list() useredges = list() useredegestemp = set() JRSRG = nx.MultiGraph() JRSRG.add_edges_from(jrsrpeers) #所有节点和边都从这里进入图,对节点和边的操作是与节点和边为索引对应的。 usernodes = list(set(JRSRG.nodes()) - jrsrnodes) #分离出用户节点。这些工作可以在上一个数据库处理函数里完成。 #for n in usernodes: # print n, for ed in set(jrsrpeers): #分离局与局间的连线和用户与局之间连线。 useredegestemp.add(ed) useredges = list(useredegestemp - jrsredges) #useredges = list(set(JRSRG.edges())-jrsredges) pos = nx.spring_layout(JRSRG) nx.draw_networkx_nodes(JRSRG, pos, list(jrsrnodes), node_color='g', node_size=3000, alpha=0.5, node_shape='s') #操作局节点颜色和形状大小。shape=>'o':圆,'s':方。 nx.draw_networkx_nodes(JRSRG, pos, usernodes, node_color='y', node_size=2000, alpha=1, node_shape='o') #操作用户节点颜色和形状大小。shape=>'o':圆,'s':方。 nx.draw_networkx_nodes( JRSRG, pos, list(jrsrdevnodes), node_color='b', node_size=1000, alpha=0.5, node_shape='o') #在有设备的节点上加画节点颜色和大小。shape=>'o':圆,'s':方。 nx.draw_networkx_edges(JRSRG, pos, width=1.0, alpha=0.5) #缺省画的细边。 nx.draw_networkx_edges(JRSRG, pos, list(jrsredges), width=8, alpha=0.5, edge_color='r') #局间的边,加画红色。 nx.draw_networkx_edges(JRSRG, pos, useredges, width=8, alpha=0.4, edge_color='b') #用户到局的边,加画蓝色。 ''' nx.draw_networkx_nodes(JRSRG,pos,node_color='g',node_shape='s',alpha=0.5,node_size=3000) # shape=>'o':圆,'s':方. nx.draw_networkx_edges(JRSRG,pos,alpha=0.5,width=6) ''' #font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=15) nx.draw_networkx_labels(JRSRG, pos, font_size=15, font_weight='bold', font_family='sans-serif') #plt.title(jrsrname) #nx.draw(JRSRG) plt.show()
g.add_edge("Hillary", "Clinton") g.add_edge("Trump", "Ivanka") g.add_edge("Trump", "Clinton") g.add_edge("Obama", "Mitt") g.add_edges_from([("Hillary", "Clinton"), ("Obama", "Trump"), ("Obama", "Clinton"), ("Michelle", "Mitt")]) g.nodes() g.edges() nx.info(g) nx.draw(g) nx.draw(g, with_labels=True) nx.draw_networkx(g) nx.spring_layout(g) nx.degree(g, "Trump") nx.degree(g, "Obama") nx.degree(g, "Clinton") print(nx.degree_centrality(g)) nx.eigenvector_centrality(g) print(nx.eigenvector_centrality(g)) nx.betweenness_centrality(g) print(nx.betweenness_centrality(g)) plt.show()
node_colors.append(cols[0]) elif (i[1] == levels[1]): node_colors.append(cols[1]) elif (i[1] == levels[2]): node_colors.append(cols[2]) else: node_colors.append(cols[3]) """ print(levels) print(node_colors) print(node_centre) sorted_node_centre """ #labels of edges pos = nx.spring_layout(g) nx.draw(g, pos, node_color=node_colors, node_size=900, with_labels=True) labels = nx.get_edge_attributes(g, 'weight') nx.draw_networkx_edge_labels(g, pos, edge_labels=labels) plt.savefig("degree centrality") print("///////////DEGREE CENTRALITY////////////") print(g.degree(g.nodes)) plt.show() #degree centrality closness = [] close_colors = [] for node in node_centre: closness.append((node[0], nx.closeness_centrality(g, node[0], 'weight'))) sorted_node_close = sorted(closness, key=itemgetter(1), reverse=True)
def graphNetwork(edgesfile, nodesfile, layout='spring', graphfile='network_grpah.png', title="", show_labels=False, constant_node_size=False): import networkx as nx import matplotlib.pyplot as plt import pandas as pd # Declare graph object G = nx.Graph() # Read network data inputedges = pd.read_csv(edgesfile) inputnodes = pd.read_csv(nodesfile) node_sizes = [] node_colours = [] node_labels = [] for i, r in inputnodes.iterrows(): if r['college_code'] == "DSC": G.add_node(r['ID'], color='red', size=r['student_pop'], label='DSC') elif r['college_code'] == "BUS": G.add_node(r['ID'], color='blue', size=r['student_pop'], label='BUS') elif r['college_code'] == "SEH": G.add_node(r['ID'], color='green', size=r['student_pop'], label='SEH') else: G.add_node(r['ID'], color='black', size=r['student_pop'], label='NA') node_labels.append(r['ID']) for i, r in inputedges.iterrows(): #if r['Weight'] > 300: # G.add_edge(r['Source'], r['Target'], weight=int(300)) #else: G.add_edge(r['Source'], r['Target'], weight=int(r['Weight'])) # assign layout if layout == 'shell': pos = nx.shell_layout(G) elif layout == 'spectral': pos = nx.spectral_layout(G) elif layout == 'random': pos = nx.random_layout(G) else: pos = nx.spring_layout(G, iterations=200, scale=5000) # set nodes to positions nx.set_node_attributes(G, 'pos', pos) try: color_map = [] size_map = [] edge_colors = [] for n in G.nodes(): color_map.append(G.node[n]['color']) size_map.append(G.node[n]['size']) for e in G.edges(data=True): edge_colors.append(e[2]['weight']) labels = {k: k for k in node_labels} plt.figure(figsize=(12.0, 9.0)) plt.title(title) if constant_node_size: nodes = nx.draw_networkx_nodes(G, pos=pos, labels=labels, node_size=8, node_color=color_map) else: nodes = nx.draw_networkx_nodes(G, pos=pos, labels=labels, node_size=size_map, node_color=color_map) edges = nx.draw_networkx_edges(G, pos=pos, edge_color=edge_colors, edge_cmap=plt.cm.copper_r) plt.colorbar(edges) plt.axis('off') if show_labels: nx.draw_networkx_labels(G, pos, labels, font_size=12) print "Nodes:\t%i" % G.number_of_nodes() print "Edges:\t%i" % G.number_of_edges() plt.savefig(graphfile, dpi=500) plt.clf() plt.close() except Exception as e: print e pass
def genesis(G, arguments): pylab.ion() # input params N = int(arguments['N']) E = int(arguments['E']) M = int(arguments['M']) alpha = float(arguments['alpha']) generations = int(arguments['gens']) node_positions = nx.spring_layout(G) #(***) for t in range(1, generations + 1): N = len(G.nodes()) E = len(G.edges()) G, node_positions = evolve(G, N, E, M, alpha, t, node_positions) if GRAPHICS and not PYLAB: nx.draw_networkx_nodes(G, pos=node_positions, node_color='grey', label=True, node_size=200) nx.draw_networkx_edges(G, pos=node_positions, edge_color='grey', label=True) nx.draw_networkx_labels(G, pos=node_positions, font_size=10) plt.show() pause(FRAMERATE * 0.00066) if DEBUG: print(color.GREEN + "finished evolution: " + str(t)) if GRAPHICS and PYLAB: graph = get_graph(G, node_positions) graph.canvas.draw() pylab.draw() pause(0.5) pylab.close(graph) if DEBUG: print(color.RED + color.BOLD + "at time " + str(t) + ": ") if DEBUG and False: a = open("error_log_after_evolve.txt", "w") a.write(str(node_positions) + "\n") a.write(str(G.nodes()) + "\n \n" + str(G.edges())) a.close() if DEBUG and False: f = open("error_log_before_evolve.txt", "w") f.write(str(node_positions) + "\n") f.write(str(G.nodes()) + "\n \n" + str(G.edges())) f.close() if DEBUG: print(color.GREEN + "finished generation: " + str(t)) else: print(G) if False: print(color.RED + "Node " + color.BOLD + str(n) + " added at time " + color.BLUE + str(t) + color.END) print(color.GREEN + color.BOLD + "local(n)" + color.END + ": " + str(local_world))
def create_graph(input_path, input_file, output_path, output_file, min_freq): # Create empty graph: G = nx.Graph() # Populate the graph with the keywords/clusters as nodes: id_response = "" keyword_nodes = list() kw2response = dict() # maps a kw to the list of responses containing it with open(os.path.join(input_path, input_file), 'rb') as csv_file: next(csv_file) res_reader = csv.reader(csv_file, delimiter=',') my_count = 0 for row in res_reader: id_response = row[0] kw = row[2] keyword_nodes.append(kw) if kw in kw2response: responses_for_kw = kw2response[kw] responses_for_kw.append(id_response) kw2response[kw] = responses_for_kw else: kw2response[kw] = [id_response] keyword_nodes = list(set(keyword_nodes)) keyword_nodes.sort() # only keep keywords that occur in more than min_response response: for kw in keyword_nodes: if len(kw2response[kw]) < min_freq + 1: keyword_nodes.remove(kw) for kw in keyword_nodes: G.add_node(kw) #print(str(G.nodes())) # Add edges to graph: # two nodes (keywords) are connected if they appear in the same response: for kw1 in keyword_nodes: responses_kw1 = kw2response[kw1] for kw2 in keyword_nodes: responses_kw2 = kw2response[kw2] overlap = len(list(set(responses_kw1).intersection(responses_kw2))) if overlap > 0: G.add_edge(kw1, kw2, weight = overlap^2) #print(str(G.edges())) # Plot graph: pos = nx.spring_layout(G) # positions for all nodes edges = G.edges() weights = [G[u][v]['weight'] for u,v in edges] nx.draw(G, pos, edges = edges, width=weights, with_labels = True) #plt.show() plt.savefig(os.path.join(output_path, output_file))
def choose_identifier(attribute_1,attribute_2,path_dic_identifier,U_degree6,): search_attribute_1=first_function(attribute_1,path_dic_identifier) sub_1=U_degree6.subgraph(search_attribute_1) path_dic_identifier_new = {k: path_dic_identifier[k] for k in search_attribute_1} search_attribute_2=first_function(attribute_2,path_dic_identifier_new) sub_2=U_degree6.subgraph(search_attribute_2) sub=nx.nodes(sub_1)+nx.nodes(sub_2) sub_new=U_degree6.subgraph(sub) labels={} for i in nx.nodes(sub_new): labels[i] = i plt.figure() pos = nx.spring_layout(sub_new) nx.draw_networkx_nodes(sub_new, pos, nodelist=search_attribute_1, node_color='r') nx.draw_networkx_nodes(sub_new, pos, search_attribute_2, node_color='b') nx.draw_networkx_labels(sub_new, pos, labels, font_size=10) nx.draw_networkx_edges(sub_new, pos, edgelist=nx.edges(sub_new)) plt.legend((str(attribute_1),str(attribute_2))) plt.axis('off') plt.show() degree_nodes=nx.degree(sub_new) degree_nodes_sorted= sorted(degree_nodes,key=degree_nodes.get, reverse=True) print ('degree:') print("\n") for r in degree_nodes_sorted: print(r,degree_nodes[r]) centrality_nodes=nx.betweenness_centrality(sub_new) centrality_nodes_sorted= sorted(centrality_nodes,key=centrality_nodes.get, reverse=True) print("\n") print ('betweeness centrality:') print("\n") for r in centrality_nodes_sorted: print(r,centrality_nodes[r]) print("\n") print ('graphical representation:') plt.figure() degree_nodes=nx.degree(sub_new) centrality_nodes=nx.betweenness_centrality(sub_new) x=list(degree_nodes.keys()) z=list(centrality_nodes.values()) y=list(degree_nodes.values()) y_sort = sorted(y, key=int, reverse=False) fig, ax = plt.subplots(figsize=(20, 10)) #ax1=plt.subplots() #ax2=ax1.twinx() ax.plot(x,y_sort, c='b') ax1=ax.twinx() #df.sort() ax1.plot(x,z, c='r') red_patch = mpatches.Patch(color='red', label='betweeness centrality') blue_patch = mpatches.Patch(color='blue', label='degree') plt.legend(handles=[red_patch, blue_patch]) return(plt.show())
def main(): G = nx.Graph() pos = nx.spring_layout(G) #################################################################################################### # nodes (territories) separated by their region on the board # Arnor arnor_nodes = [ "Angmar", "Borderlands", "Buckland", "Eastern Angmar", "Fornost", "Forodwaith", "North Downs", "Old Forest", "Rhudaur", "South Downs", "Weather Hills" ] nx.draw_networkx_nodes(G, pos, nodelist=arnor_nodes, node_color='black', node_size=500, alpha=0.8) # Rhovanion rhovanion_nodes = [ "Brown Lands", "Dead Marshes", "Emyn Muil", "Gladden Fields", "Lorien", "Moria", "Rhun Hills", "The Wold" ] nx.draw_networkx_nodes(G, pos, nodelist=rhovanion_nodes, node_color='grey', node_size=500, alpha=0.8) # Rohan rohan_nodes = [ "Dunland", "Enedwaith", "Eregion", "Fangorn", "Gap of Rohan", "Minhiriath", "West Rohan" ] nx.draw_networkx_nodes(G, pos, nodelist=rohan_nodes, node_color='brown', node_size=500, alpha=0.8) # Mirkwood mirkwood_nodes = [ "Anduin Valley", "Carrock", "Eastern Mirkwood", "North Mirkwood", "South Mirkwood" ] nx.draw_networkx_nodes(G, pos, nodelist=mirkwood_nodes, node_color='red', node_size=500, alpha=0.8) # Eriador eriador_nodes = [ "Evendim Hills", "Forlindon", "Harlindon", "Lune Valley", "Mithlond", "The Shire", "Tower Hills" ] nx.draw_networkx_nodes(G, pos, nodelist=eriador_nodes, node_color='darkorange', node_size=500, alpha=0.8) # Rhun rhun_nodes = ["Esgaroth", "North Rhun", "South Rhun", "Weathered Heath"] nx.draw_networkx_nodes(G, pos, nodelist=rhun_nodes, node_color='yellow', node_size=500, alpha=0.8) # Gondor gondor_nodes = [ "Andrast", "Anfalas", "Belfalas", "Druwaith Iaur", "Ithilien", "Lamedon", "Lebennin", "Minas Tirith", "South Ithilien", "Vale of Erech" ] nx.draw_networkx_nodes(G, pos, nodelist=gondor_nodes, node_color='seagreen', node_size=500, alpha=0.8) # Mordor mordor_nodes = [ "Barad-dur", "Gorgoroth", "Minas Morgul", "Mount Doom", "Nurn", "Udun Vale" ] nx.draw_networkx_nodes(G, pos, nodelist=mordor_nodes, node_color='deeppink', node_size=500, alpha=0.8) # Haradwaith haradwaith_nodes = [ "Deep Harad", "Harad", "Harondor", "Khand", "Near Harad", "Umbar" ] nx.draw_networkx_nodes(G, pos, nodelist=haradwaith_nodes, node_color='blue', node_size=500, alpha=0.8) #################################################################################################### # edges (borders) on the board # self-contained edges, i.e. edges that are between two nodes in the same region # Arnor edges_1 = [("Eastern Angmar", "Forodwaith"), ("Forodwaith", "Angmar"), ("Forodwaith", "Borderlands"), ("Angmar", "Borderlands"), ("Borderlands", "North Downs"), ("Borderlands", "Fornost"), ("Borderlands", "Weather Hills"), ("North Downs", "Fornost"), ("Fornost", "Buckland"), ("Fornost", "Old Forest"), ("Fornost", "Weather Hills"), ("Buckland", "Old Forest"), ("Buckland", "South Downs"), ("Old Forest", "South Downs"), ("Old Forest", "Weather Hills"), ("Weather Hills", "South Downs"), ("Weather Hills", "Rhudaur")] # Rhovanion edges_2 = [("Moria", "Gladden Fields"), ("Gladden Fields", "Lorien"), ("Lorien", "The Wold"), ("The Wold", "Emyn Muil"), ("Emyn Muil", "Dead Marshes"), ("Emyn Muil", "Brown Lands"), ("Brown Lands", "Dead Marshes"), ("Brown Lands", "Rhun Hills")] # Rohan edges_3 = [("Eregion", "Dunland"), ("Dunland", "Minhiriath"), ("Dunland", "Enedwaith"), ("Enedwaith", "Minhiriath"), ("Enedwaith", "Gap of Rohan"), ("Gap of Rohan", "West Rohan"), ("Gap of Rohan", "Fangorn")] # Mirkwood edges_4 = [("Carrock", "North Mirkwood"), ("Carrock", "Anduin Valley"), ("North Mirkwood", "Eastern Mirkwood"), ("Eastern Mirkwood", "Anduin Valley"), ("Eastern Mirkwood", "South Mirkwood"), ("South Mirkwood", "Anduin Valley")] # Eriador edges_5 = [("Forlindon", "Mithlond"), ("Mithlond", "Lune Valley"), ("Mithlond", "Tower Hills"), ("Mithlond", "Harlindon"), ("Lune Valley", "Evendim Hills"), ("Lune Valley", "Tower Hills"), ("Evendim Hills", "Tower Hills"), ("Tower Hills", "The Shire")] # Rhun edges_6 = [("North Rhun", "Weathered Heath"), ("North Rhun", "South Rhun"), ("Weathered Heath", "Esgaroth")] # Gondor edges_7 = [("Druwaith Iaur", "Anfalas"), ("Anfalas", "Andrast"), ("Anfalas", "Vale of Erech"), ("Vale of Erech", "Lamedon"), ("Lamedon", "Belfalas"), ("Lamedon", "Lebennin"), ("Lebennin", "Belfalas"), ("Lebennin", "Minas Tirith"), ("Minas Tirith", "Ithilien"), ("Ithilien", "South Ithilien")] # Mordor edges_8 = [("Udun Vale", "Mount Doom"), ("Mount Doom", "Barad-dur"), ("Mount Doom", "Gorgoroth"), ("Gorgoroth", "Barad-dur"), ("Gorgoroth", "Minas Morgul"), ("Gorgoroth", "Nurn")] # Haradwaith edges_9 = [("Harondor", "Harad"), ("Harad", "Deep Harad"), ("Harad", "Near Harad"), ("Deep Harad", "Umbar"), ("Near Harad", "Khand")] # edges between different nodes (territories) in different regions edges_misc = [("Forodwaith", "Mithlond"), ("Forodwaith", "North Rhun"), ("Forodwaith", "Weathered Heath"), ("Eastern Angmar", "Carrock"), ("Borderlands", "Lune Valley"), ("Borderlands", "Evendim Hills"), ("Buckland", "The Shire"), ("South Downs", "Minhiriath"), ("Rhudaur", "Eregion"), ("Rhudaur", "Carrock"), ("Moria", "Eregion"), ("Gladden Fields", "Anduin Valley"), ("Lorien", "Fangorn"), ("The Wold", "Fangorn"), ("The Wold", "Gap of Rohan"), ("Emyn Muil", "Anduin Valley"), ("Emyn Muil", "South Mirkwood"), ("Brown Lands", "South Mirkwood"), ("Brown Lands", "Eastern Mirkwood"), ("Brown Lands", "South Rhun"), ("Dead Marshes", "Ithilien"), ("Dead Marshes", "Udun Vale"), ("Minhiriath", "Mithlond"), ("Minhiriath", "Belfalas"), ("Minhiriath", "Umbar"), ("West Rohan", "Druwaith Iaur"), ("Gap of Rohan", "Minas Tirith"), ("North Mirkwood", "Esgaroth"), ("Ithilien", "Minas Morgul"), ("South Ithilien", "Harondor"), ("Belfalas", "Umbar")] # all of the edges in the game all_edges = edges_1 + edges_2 + edges_3 + edges_4 + edges_5 + edges_6 + edges_7 + edges_8 + edges_9 + edges_misc nx.draw_networkx_edges(G, pos, edgelist=all_edges, width=8, alpha=0.5) #################################################################################################### # show the graph of the game nx.draw_kamada_kawai(G) plt.show()
print('clee', clee) # clee print('valeur', clee) # value for cle, valeur in clee.items(): print('valeur', valeur) print('cle', cle) G = nx.DiGraph() G.add_edges_from([('A', 'B')], weight=2) G.add_edges_from([('D', 'E'), ('E', 'F'), ('G', 'H')], weight=3) G.add_edges_from([('B', 'E'), ('C', 'E'), ('E', 'G')], weight=4) G.add_edges_from([('A', 'D'), ('D', 'F'), ('F', 'H')], weight=5) G.add_edges_from([('C', 'G')], weight=6) G.add_edges_from([('A', 'E')], weight=7) G.add_edges_from([('C', 'G')], weight=9) edge_labels = dict([((u, v,), d['weight']) for u, v, d in G.edges(data=True)]) red_edges = [('C', 'D'), ('D', 'A')] edge_colors = ['black' if not edge in red_edges else 'red' for edge in G.edges()] pos = nx.spring_layout(G) nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels) nx.draw_networkx(G, pos, node_size=2500, edge_color=edge_colors, edge_cmap=plt.cm.Reds) # pylab.show() """ Réponse : Plus court chemin ex3 : ['e', 'c', 'f', 's'] de longueur : 10 Plus court chemin ex4 : ['a', 'b', 'e', 'g', 'h'] de longueur : 13 """
def network(self, figsize=(14, 9), fig=True): """ Display information about the container's object relationships. Nodes correspond to data objects. The size of the node corresponds to the size of the table in memory. The color of the node corresponds to its fundamental data type. Nodes are labeled by their container name; class information is listed below. The color of the connections correspond to the type of relationship; either an index of one table corresponds to a column in another table or the two tables share an index. Args: figsize (tuple): Tuple containing figure dimensions fig (bool): Generate the figure (default true) Returns: graph: Network graph object containing data relationships """ conn_types = ['index-index', 'index-column'] conn_colors = mpl.sns.color_palette('viridis', len(conn_types)) conn = dict(zip(conn_types, conn_colors)) def get_node_type_color(obj): """Gets the color of a node based on the node's (sub)type.""" cols = mpl.sns.color_palette('viridis', len(conn_types)) for col in cols: if isinstance(obj, (pd.DataFrame, pd.Series, pd.SparseSeries, pd.SparseDataFrame)): typ = type(obj) return '.'.join((typ.__module__, typ.__name__)), col return 'other', 'gray' def legend(items, name, loc, ax): """Legend creation helper function.""" proxies = [] descriptions = [] for label, color in items: if label == 'column-index': continue if name == 'Data Type': line = mpl.sns.mpl.lines.Line2D([], [], linestyle='none', color=color, marker='o') else: line = mpl.sns.mpl.lines.Line2D([], [], linestyle='-', color=color) proxies.append(line) descriptions.append(label) lgnd = ax.legend(proxies, descriptions, title=name, loc=loc, frameon=True) lgnd_frame = lgnd.get_frame() lgnd_frame.set_facecolor('white') lgnd_frame.set_edgecolor('black') return lgnd, ax info = self.info() info = info[info['type'] != '-'] info['size'] *= 13000 / info['size'].max() info['size'] += 2000 node_size_dict = info['size'].to_dict() # Can pull all nodes from keys node_class_name_dict = info['type'].to_dict() node_type_dict = {} # Values are tuple of "underlying" type and color node_conn_dict = {} # Values are tuple of connection type and color items = self._data().items() for k0, v0 in items: n0 = k0[1:] if k0.startswith('_') else k0 node_type_dict[n0] = get_node_type_color(v0) for k1, v1 in items: if v0 is v1: continue n1 = k1[1:] if k1.startswith('_') else k1 for name in v0.index.names: # Check the index of data object 0 against the index if name is None: # and columns of data object 1 continue if name in v1.index.names: contyp = 'index-index' node_conn_dict[(n0, n1)] = (contyp, conn[contyp]) node_conn_dict[(n1, n0)] = (contyp, conn[contyp]) for col in v1.columns: # Catches index "atom", column "atom1"; does not catch atom10 if name == col or (name == col[:-1] and col[-1].isdigit()): contyp = 'index-column' node_conn_dict[(n0, n1)] = (contyp, conn[contyp]) node_conn_dict[(n1, n0)] = ('column-index', conn[contyp]) g = nx.Graph() g.add_nodes_from(node_size_dict.keys()) g.add_edges_from(node_conn_dict.keys()) node_sizes = [node_size_dict[node] for node in g.nodes()] node_labels = { node: ' {}\n({})'.format(node, node_class_name_dict[node]) for node in g.nodes() } node_colors = [node_type_dict[node][1] for node in g.nodes()] edge_colors = [node_conn_dict[edge][1] for edge in g.edges()] # Build the figure and legends if fig: fig, ax = plt.subplots(1, figsize=figsize) ax.axis('off') pos = nx.spring_layout(g) nx.draw_networkx_nodes(g, pos=pos, ax=ax, alpha=0.7, node_size=node_sizes, node_color=node_colors) nx.draw_networkx_labels(g, pos=pos, labels=node_labels, font_size=17, font_weight='bold', ax=ax) nx.draw_networkx_edges(g, pos=pos, edge_color=edge_colors, width=2, ax=ax) l1, ax = legend(set(node_conn_dict.values()), 'Connection', (1, 0), ax) _, ax = legend(set(node_type_dict.values()), 'Data Type', (1, 0.3), ax) fig.gca().add_artist(l1) g.edge_types = { node: value[0] for node, value in node_conn_dict.items() } # Attached connection information to network graph return g
print(seen_lemma) labels = {} keys = list(seen_lemma.keys()) for i in range(len(seen_lemma)): labels[i] = keys[i][0].lower() labels #%matplotlib inline import matplotlib.pyplot as plt fig = plt.figure(figsize=(9, 9)) pos = nx.spring_layout(lemma_graph) nx.draw(lemma_graph, pos=pos, with_labels=False, font_weight="bold") nx.draw_networkx_labels(lemma_graph, pos, labels) ranks = nx.pagerank(lemma_graph) ranks for node_id, rank in sorted(ranks.items(), key=lambda x: x[1], reverse=True): print(node_id, rank, labels[node_id]) def collect_phrases(chunk, phrases, counts): chunk_len = chunk.end - chunk.start + 1 sq_sum_rank = 0.0 non_lemma = 0
''' Draw Facebook Ego Network Using SNAP dataset and using NetworkX Library ''' import networkx as nx import matplotlib.pyplot as plt g = nx.read_edgelist('facebook_combined.txt', create_using=nx.Graph(), nodetype=int) print(nx.info(g)) sp = nx.spring_layout(g) plt.axis('off') nx.draw_networkx(g, pos=sp, with_labels=False, node_size=35) plt.show()
#plt.show() if __name__ == '__main__': config_parser.read(config_file) graph_name = config_parser.get('TOPO', 'topoloogy') graph_path = '../annotated_topo/' + graph_name + '.graphml' #print graph_path caps = json.loads(config_parser.get('CONSTRAINTS', 'linkbandwidth')) G = nx.read_graphml(graph_path, node_type=int) pos = nx.spring_layout(G) # positions for all nodes #print pos rstPath = config_parser.get('PATHS', 'resultpath') for cap in caps: file_path = '../placement_alg/' + rstPath + str( cap) + '/' + graph_name + '/' affinix = 'fl' save_name = '../graphes/' + graph_name + '_' + str(cap) + '.pdf' #print save_name plot(G, pos, graph_name, file_path, affinix, save_name) rst_directory = '../placement_alg/' + rstPath
def thanks(): if request.args: id = request.args['id'] f = open('post_comment.txt', 'w') try: offsets = [0, 20] for off in offsets: stroka1 = 'https://api.vk.com/method/wall.get?owner_id=' + str( id ) + '&count=20&v=5.73&access_token=4e4390334e4390334e439033504e21bc6044e434e4390331552d00d82502b3b1e852732&offset=' + str( off) req = urllib.request.Request(stroka1) response = urllib.request.urlopen(req) result = response.read().decode('utf-8') #print(result) if off == 0: data = json.loads(result) else: data1 = json.loads(result) needed_data = data1['response']['items'] for n in needed_data: data['response']['items'].append(n) #print(len(data['response']['items'])) #print(type(data)) for m in range(39): f.write(data["response"]["items"][m]["text"]) f.write('\n') post = data["response"]["items"][m]["id"] for off in offsets: stroka = 'https://api.vk.com/method/wall.getComments?owner_id=' + str( id ) + '&access_token=4e4390334e4390334e439033504e21bc6044e434e4390331552d00d82502b3b1e852732&post_id=' + str( post) + '&count=100&v=5.73&offset=' + str(off) requ = urllib.request.Request(stroka) response1 = urllib.request.urlopen(requ) result1 = response1.read().decode('utf-8') if off == 0: data2 = json.loads(result1) for r in range(len(data2['response']['items'])): f.write(data2['response']['items'][r]['text']) f.write('\n') else: data3 = json.loads(result1) for z in range(len(data3['response']['items'])): f.write(data3['response']['items'][z]['text']) f.write('\n') #print(data3) f.close() except KeyError: return render_template('wrong.html') m = open('post_comment.txt', 'r') m = m.read() m = m.replace('!', '.') m = m.replace('?', '.') m = m.replace('\n', '.') m = m.lower() m = m.split('.') regPunct = re.compile('[^\w]*$', re.DOTALL) regOther = re.compile('[a-zA-Z0-9_#;,\>%&/\№|=\{\}:\.\[\]"\?\(\)\@«»]', re.DOTALL) regTire = re.compile(' — ', re.DOTALL) all_elems = [] for i in m: new_words = [] clean_i = regPunct.sub("", i) clean_i = regOther.sub("", clean_i) clean_i = regTire.sub(" ", clean_i) new_words.append(clean_i.split()) all_elems.append(new_words) g = open('stopwords.txt', 'r') g = g.read() g = g.split() for elem in all_elems: for i in elem: for word in i: ana = morph.parse(word) first = ana[0] for stop in g: if first.normal_form == stop: try: #print(first.normal_form) index_w = i.index(word) del i[index_w] except ValueError: pass for elem in all_elems: for i in elem: if len(i) == 0: try: all_elems.remove(elem) except ValueError: pass N = nx.Graph() for elem in all_elems: for i in elem: dict = {} for word in i: dict[i.index(word)] = word for elem1 in all_elems: for i1 in elem1: dict1 = {} for word1 in i1: dict1[i1.index(word1)] = word1 #if len(N.nodes()) <= 50: if word == word1: N.add_node(word) N.add_node(dict.get(i.index(word) + 1)) N.add_node(dict.get(i.index(word) - 1)) N.add_node(dict1.get(i1.index(word1) + 1)) N.add_node(dict1.get(i1.index(word1) - 1)) N.add_edge(word, dict1.get(i.index(word) + 1)) N.add_edge(word, dict1.get(i.index(word) - 1)) N.add_edge(word, dict1.get(i1.index(word1) + 1)) N.add_edge(word, dict1.get(i1.index(word1) - 1)) N.remove_node(None) pos = nx.spring_layout(N) nx.draw_networkx_nodes(N, pos, node_color='red', node_size=10) nx.draw_networkx_edges(N, pos, edge_color='blue') nx.draw_networkx_labels(N, pos, font_size=8, font_family='Arial') plt.axis('off') plt.savefig('static/graph.png', dpi=300, format='png') nodes = N.number_of_nodes() edges = N.number_of_edges() return render_template('thanks.html', nodes=nodes, edges=edges) #plt.show() return redirect(url_for(''))
import networkx as nx import matplotlib.pyplot as plot A = nx.Graph() A.add_edges_from([('R1', 'Sw1'), ('Sw1', 'Sw2'), ('Sw1', 'Sw3'), ('Sw2', 'Pc2'), ('Sw2', 'Pc3'), ('Sw3', 'Pc4'), ('Sw3', 'Pc5')]) posicion = nx.spring_layout(A) nx.draw_networkx_nodes(A, posicion, node_size=800) nx.draw_networkx_edges(A, posicion, width=2) nx.draw_networkx_labels(A, posicion, font_size=11, font_family='arial') plot.axis('off') plot.savefig("Graf1.eps") plot.show(A)
def draw_graph(graph, labels=None, node_color='blue', node_size=1600, graph_layout='shell', 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'): # create networkx graph G = nx.Graph() # add edges for edge in graph: G.add_edge(edge[0], edge[1]) # these are different layouts for the network you may try # shell seems to work best if graph_layout == 'spring': graph_pos = nx.spring_layout(G) elif graph_layout == 'spectral': graph_pos = nx.spectral_layout(G) elif graph_layout == 'random': graph_pos = nx.random_layout(G) else: graph_pos = nx.shell_layout(G) nx.draw_networkx_nodes(G, graph_pos, node_size=node_size, alpha=node_alpha, node_color=node_color) nx.draw_networkx_edges(G, graph_pos, width=edge_tickness, alpha=edge_alpha, edge_color=edge_color) nx.draw_networkx_labels(G, graph_pos, font_size=node_text_size, font_family=text_font) if labels is None: labels = range(len(graph)) edge_labels = dict(zip(graph, labels)) nx.draw_networkx_edge_labels(G, graph_pos, edge_labels=edge_labels, label_pos=edge_text_pos) grafito = {} # show graph for conta in xrange(len(graph)): grafito[graph[conta][0]] = G.degree(graph[conta][0]) grafito = list(grafito.items()) return grafito
def drawNetwork(Gx=None, Gxu=None, nodes=None, edges=None, forceiter=100, grphtype='undirected', dx=10, dy=10, colormap='jet', scale=1.0, layout='force', drawlabels=True, giant=False, equi=False, res=0.5, k=None, edge_labels=False, font=12): if grphtype == 'directed': if Gx == None and Gxu == None: Gx = nx.from_pandas_edgelist(edges, 'Source', 'Target', ['Weight'], create_using=nx.DiGraph()) Gxu = nx.from_pandas_edgelist(edges, 'Source', 'Target', ['Weight']) if giant: print('not implemented') else: if Gx == None: Gx = nx.from_pandas_edgelist(edges, 'Source', 'Target', ['Weight']) if giant and not nx.is_connected(Gx): S = [Gx.subgraph(c).copy() for c in nx.connected_components(Gx)] size = [] for s in S: size.append(len(s)) idsz = np.argsort(size) print('found ', np.array(size)[idsz], ' connected components') index = int(input('enter index ')) Gx = S[idsz[index]] if layout == 'force' or layout == None: pos = nx.spring_layout(Gx, k=1, iterations=forceiter) elif layout == 'spiral': pos = nx.spiral_layout(Gx, equidistant=equi, resolution=res) df = np.array(nodes) if len(df.shape) == 1: df = np.reshape(df, (len(df), 1)) nodelabel = dict( zip(np.linspace(0, len(df[:, 0]) - 1, len(df[:, 0]), dtype=int), df[:, 0])) labels = {} for idx, node in enumerate(Gx.nodes()): labels[node] = nodelabel[int(node)] if grphtype == 'directed': part = cm.best_partition(Gxu) values = [part.get(node) for node in Gxu.nodes()] else: part = cm.best_partition(Gx) values = [part.get(node) for node in Gx.nodes()] d = nx.degree(Gx) dsize = [(d[v] + 1) * 100 * scale for v in Gx.nodes()] plt.figure(figsize=(dx, dy)) if edge_labels: edge_labels = nx.get_edge_attributes(Gx, 'Label') nx.draw_networkx_edge_labels(Gx, pos, edge_labels, font_size=font) nx.draw_networkx(Gx, pos=pos, labels=labels, with_labels=drawlabels, cmap=plt.get_cmap(colormap), node_color=values, node_size=dsize) plt.show()
# figure out total collaborations collabMat_sen = np.zeros((len(connMat_sen), len(connMat_sen))) billThresh = 15 for i in range(0, len(connMat_sen)): for j in range(0, len(connMat_sen)): totalAppearances = connMat_sen[i, j] + connMat_sen[j, i] if totalAppearances > billThresh: collabMat_sen[i, j] = 1 collabMat_sen[j, i] = collabMat_sen[i, j] ########################################################### # create network from connectivity matrix for House of Reps G = nx.from_numpy_matrix(collabMat_rep) # get node positions pos = nx.spring_layout(G, dim=3) # get x and y coordinates of nodes Xn = [pos[k][0] for k in range(0, G.number_of_nodes())] # x-coordinates of nodes Yn = [pos[k][1] for k in range(0, G.number_of_nodes())] # y-coordinates Zn = [pos[k][2] for k in range(0, G.number_of_nodes())] # y-coordinates # populate node edges Edges = G.edges() Xe = [] Ye = [] Ze = [] for e in Edges: Xe += [pos[e[0]][0], pos[e[1]][0], None] # x-coordinates of edge ends Ye += [pos[e[0]][1], pos[e[1]][1], None]
import numpy as np import csv import networkx as nx # 导入建网络模型包,命名ne import matplotlib.pyplot as mp # 导入科学绘图包,命名mp # BA scale-free degree network graphy L = 100 BA = nx.barabasi_albert_graph(L, 1) #1000个节点,初始m0=2 ps = nx.spring_layout(BA) # 布置框架 nx.draw(BA, ps, with_labels=None, node_size=20) mp.show() G = [] for i in range(0, L): # 记录所有节点的邻居节点 G.append(list(BA.neighbors(i))) links = [] #link = np.zeros(L) for i in range(0, L): link = np.zeros(L) linklist = link.tolist() for j in range(0, L): if j in G[i]: linklist[j] = 1 links.append(linklist) print(links) np.savetxt('links.csv', links, delimiter=',') for i in range(0, L): #将各个节点的额lable(ID)插入到表格的第一列 degree = len(G[i])
net=net, colors='pairwise_sharp', sizes='neighborhood_watch_sharp') sharp_sizes = [] for s in sizes: if s <= 5: sharp_sizes.append(1) elif s <= 13: sharp_sizes.append(2) else: sharp_sizes.append(3) sizes = [s * 2000 for s in sharp_sizes] pos_spring = nx.spring_layout(net) pos_circular = nx.circular_layout(net) print(net) network_visualization.draw_network(net, node_labels, color_map=color_map, draw_edges=False, draw_labels=False, name=folder_path + '/network_pictures/' + pdb_id + '_color', figsize=(50, 50), pos=pos_spring) network_visualization.draw_network(net, node_labels, sizes=sizes, draw_labels=False,
def drawGraph(G): plt.figure() pos = nx.spring_layout(G) nx.draw_networkx(G, pos) plt.savefig("graph.pdf") plt.show()
def draw_graph_centrality2(G, Subsets=[], h=15, v=10, deltax=0, deltay=0, fontsize=18, k=0.2, arrows=False, node_alpha=0.3, l_alpha=1, node_color='blue', centrality=nx.degree_centrality, font_color='black', threshold=0.01, multi=3000, edge_color='olive', colstart=0.2, coldark=0.5): from pylab import rcParams import matplotlib.pyplot as plt from matplotlib import colors as mcolors colors = dict(mcolors.BASE_COLORS, **mcolors.CSS4_COLORS) node_dict = centrality(G) subnodes = dict( {x: node_dict[x] for x in node_dict if node_dict[x] >= threshold}) #print(subnodes) x, y = rcParams['figure.figsize'] rcParams['figure.figsize'] = h, v ax = plt.subplot() ax.set_xticks([]) ax.set_yticks([]) #G = G.subgraph(subnodes) glob_col = sns.hls_palette(len(G), h=colstart, l=coldark)[0] pos = nx.spring_layout(G, k=k) labelpos = dict({k: (pos[k][0] + deltax, pos[k][1] + deltay) for k in pos}) #print(labelpos) #print(pos) if l_alpha <= 1: nx.draw_networkx_labels(G, labelpos, font_size=fontsize, alpha=l_alpha, font_color=font_color) sub_color = 0 if Subsets != []: i = 0 colpalette = sns.hls_palette(len(Subsets), h=colstart, l=coldark) #print(colpalette) for Sub in Subsets: sublist = dict({x: subnodes[x] for x in subnodes if x in Sub}) #print(sublist) #sub_col = list(colors.values())[np.random.randint(20,100)] sub_col = colpalette[i] #print(i, sub_col, sublist.keys()) #print(i, sub_col) nx.draw_networkx_nodes( G, pos, alpha=node_alpha, node_color=[sub_col], nodelist=[x for x in sublist.keys()], node_size=[v * multi for v in sublist.values()]) i += 1 else: nx.draw_networkx_nodes( G, pos, alpha=node_alpha, node_color=glob_col, nodelist=subnodes.keys(), node_size=[v * multi for v in subnodes.values()]) True nx.draw_networkx_edges(G, pos, alpha=0.1, arrows=arrows, edge_color=edge_color) rcParams['figure.figsize'] = x, y return
def test_spring_fixed_without_pos(self): G = nx.path_graph(4) pytest.raises(ValueError, nx.spring_layout, G, fixed=[0]) pos = {0: (1, 1), 2: (0, 0)} pytest.raises(ValueError, nx.spring_layout, G, fixed=[0, 1], pos=pos) nx.spring_layout(G, fixed=[0, 2], pos=pos) # No ValueError