def draw_graph(self, G, node_list=None, edge_colour='k', node_size=15, node_colour='r', graph_type='spring', back_bone=None, side_chains=None, terminators=None): # determine nodelist if node_list is None: node_list = G.nodes() # determine labels labels = {} for l_atom in G.nodes_iter(): labels[l_atom] = l_atom.symbol # draw graphs based on graph_type if graph_type == 'circular': nx.draw_circular(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) elif graph_type == 'random': nx.draw_random(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) elif graph_type == 'spectral': nx.draw_spectral(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) elif graph_type == 'spring': nx.draw_spring(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) elif graph_type == 'shell': nx.draw_shell(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) # elif graph_type == 'protein': # self.draw_protein(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, # edge_color=edge_colour, node_color=node_colour, back_bone, side_chains, terminators) else: nx.draw_networkx(G, with_labels=True, labels=labels, node_list=node_list, node_size=node_size, edge_color=edge_colour, node_color=node_colour) plt.show()
def __update_display( self, color_map={ "healthy": "green", "asymptomatic": "orange", "symptomatic": "red", "dead": "gray" }): """__update_display - handles the display with matplotlib Inputs: - (Optional) color_map: an association dictionary for status->color Outputs: - None; displays as a window """ plt.clf() plt.title( f"{self.__time_elapsed} / {self.__network_params['t']} - Number of Agents: {self.__num_agents}" ) # get list of colorations colorations = self.__generate_colorations(color_map) # get list of labels labels = self.__generate_labels() # generate the lattice drawing nx.draw_spectral(self.__lattice, node_color=colorations, labels=labels) # update the display for animation-purposes plt.pause(0.05)
def show_spectral_graph_embedding(graph): plt.figure() cmap = [purple, orange, blue] nodes = graph.nodes() colors = [cmap[graph.node[n]['label']] for n in nodes] nx.draw_spectral(graph, node_size=10, nodelist=nodes, node_color=colors) plt.show()
def tweet_flow(): global graph print "Incoming Tweets!" hashtag_edges = [] hastag_edges = get_edges_from_pairs(genereate_tags()) graph = max(nx.connected_component_subgraphs(graph), key=len) for i in hastag_edges: if i[0] != i[1] and len(i[0]) > len(i[1]): graph.add_edge(i[0],i[1]) calc_average_degree() nx.draw_spectral(graph, node_size = 300, width = 100, node_color = '#A0CBE2', #light blue edge_color = '#4169E1', #royal blue font_size = 10, with_labels = True ) plt.draw() plt.pause(0.001) time.sleep(60) graph.clear() tweet_flow()
def set_lane_direction_alternates(self): G2 = nx.DiGraph(self.g) for edge in G2.edges(): if edge != tuple(sorted(edge)): G2.remove_edge(*edge) nx.draw_spectral(G2, node_size=600, node_color='w')
def plot(self): """ function to plot the Graph :return: None """ options = { 'with_labels': True, 'node_color': 'lightblue', # blue 'node_size': 1000, 'node_shape': 's', # 'd', '^', 'o', '^', 'font_size': 20, 'font_weight': 'bold' } type_of_draw = 'kamada_kawai' # DRAW IN DIFFERENT LAYOUT if type_of_draw == 'planar': nx.draw_planar(self.Graph, **options) elif type_of_draw == 'spectral': nx.draw_spectral(self.Graph, **options) elif type_of_draw == 'kamada_kawai': nx.draw_kamada_kawai(self.Graph, **options) elif type_of_draw == 'spring': nx.draw_spring(self.Graph, **options) print("Plotting 4 You...") plt.draw() plt.show() # plt.savefig("saved_Plot4You.png") plt.clf()
def displayGraph(self, g, label=False): axon, sd = axon_dendrites(g) sizes = node_sizes(g) * 50 if len(sizes) == 0: print('Empty graph for cell. Make sure proto file has `*asymmetric` on top. I cannot handle symmetric compartmental connections') return weights = np.array([g.edge[e[0]][e[1]]['weight'] for e in g.edges()]) pos = nx.graphviz_layout(g, prog='twopi') xmin, ymin, xmax, ymax = 1e9, 1e9, -1e9, -1e9 for p in list(pos.values()): if xmin > p[0]: xmin = p[0] if xmax < p[0]: xmax = p[0] if ymin > p[1]: ymin = p[1] if ymax < p[1]: ymax = p[1] edge_widths = 10.0 * weights / max(weights) node_colors = ['k' if x in axon else 'gray' for x in g.nodes()] lw = [1 if n.endswith('comp_1') else 0 for n in g.nodes()] self.axes.clear() try: nx.draw_graphviz(g, ax=self.axes, prog='twopi', node_color=node_colors, lw=lw) except (NameError, AttributeError) as e: nx.draw_spectral(g, ax=self.axes, node_color=node_colors, lw=lw, with_labels=False, )
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 bfs(start): queue = [start] visitedVertex = [] #while stack has some value in it while queue: #poping the last element current = queue.pop() for neighbor in adjacencyList[current]: #if value is not in visitedVertex then append stack if not neighbor in visitedVertex: # inserting at first position queue.insert(0, neighbor) ### visualizing ### c = ['r'] * len(vertexList) for i in visitedVertex: c[i] = 'b' G.add_nodes_from(vertexList) G.add_edges_from(edgeList) nx.draw_spectral(G, with_labels=True, node_color=c) plt.show() else: c = ['r'] * len(vertexList) for i in visitedVertex: c[i] = 'b' G.add_nodes_from(vertexList, node_color='g') G.add_edges_from(edgeList) nx.draw_spectral(G, with_labels=True, node_color=c) plt.show() ### visualizing ended ### visitedVertex.append(current) return visitedVertex
def dfs(start): stack = [start] visitedVertex = [] #while stack has some value in it while stack: current = stack.pop() G.remove_node(current) for neighbor in adjacencyList[current]: #if value is not in visitedVertex then append stack if not neighbor in visitedVertex: stack.append(neighbor) ### visualizing ### c = ['r'] * len(vertexList) for i in visitedVertex: c[i] = 'b' G.add_nodes_from(vertexList) G.add_edges_from(edgeList) nx.draw_spectral(G, with_labels=True, node_color=c) plt.show() else: c = ['r'] * len(vertexList) for i in visitedVertex: c[i] = 'b' G.add_nodes_from(vertexList, node_color='g') G.add_edges_from(edgeList) nx.draw_spectral(G, with_labels=True, node_color=c) plt.show() ### visualizing ended ### visitedVertex.append(current) return visitedVertex
def displayGraph(self, g, label=False): axon, sd = axon_dendrites(g) sizes = node_sizes(g) * 50 if len(sizes) == 0: print( 'Empty graph for cell. Make sure proto file has `*asymmetric` on top. I cannot handle symmetric compartmental connections' ) return node_colors = ['k' if x in axon else 'gray' for x in g.nodes()] lw = [1 if n.endswith('comp_1') else 0 for n in g.nodes()] self.axes.clear() try: nx.draw_graphviz(g, ax=self.axes, prog='twopi', node_color=node_colors, lw=lw) except (NameError, AttributeError) as e: nx.draw_spectral( g, ax=self.axes, node_color=node_colors, lw=lw, with_labels=False, )
def ministro_ministro(G): """ Cria um grafo de ministros conectados de acordo com a sobreposição de seu uso da legislação Construido a partir to grafo ministro_lei """ GM = nx.Graph() for m in G: try: int(m) except ValueError:# Add only if node is a minister if m != "None": GM.add_node(m.decode('utf-8')) # Add edges for n in GM: for m in GM: if n == m: continue if GM.has_edge(n,m) or GM.has_edge(m,n): continue # Edge weight is the cardinality of the intersection each node neighbor set. w = len(set(nx.neighbors(G,n.encode('utf-8'))) & set(nx.neighbors(G,m.encode('utf-8')))) #encode again to allow for matches if w > 5: GM.add_edge(n,m,{'weight':w}) # abreviate node names GMA = nx.Graph() GMA.add_weighted_edges_from([(o.replace('MIN.','').strip(),d.replace('MIN.','').strip(),di['weight']) for o,d,di in GM.edges_iter(data=True)]) P.figure() nx.draw_spectral(GMA) nx.write_graphml(GMA,'ministro_ministro.graphml') nx.write_gml(GMA,'ministro_ministro.gml') nx.write_pajek(GMA,'ministro_ministro.pajek') nx.write_dot(GMA,'ministro_ministro.dot') return GMA
def start_graph(Nomserie, type_graph): print(type_graph) options = { 'node_color': 'red', 'node_size': 200, 'width': 3, } if Nomserie == "Game of Thrones": G1 = nx.read_graphml("data/got/GoT_S05E09_1039.graphml") print(G1) if Nomserie == "Breaking Bad": G1 = nx.read_graphml("data/bb/BB_S03E11_598.graphml") if Nomserie == "House of Card": G1 = nx.read_graphml("data/hoc/HoC_S02E13_879.graphml") G1.remove_nodes_from(nx.isolates(G1)) if type_graph == "Classical": nx.draw_networkx(G1, pos=nx.spring_layout(G1)) if type_graph == "Random": nx.draw_random(G1, **options, with_labels=True, font_weight='bold') if type_graph == "Circular": nx.draw_circular(G1, **options, with_labels=True, font_weight='bold') if type_graph == "Spectral": nx.draw_spectral(G1, **options, with_labels=True, font_weight='bold') if type_graph == "Shell": nx.draw_shell(G1, **options, with_labels=True, font_weight='bold') plt.savefig("images/" + Nomserie + "_" + type_graph + ".jpg") plt.close('all')
def plot_graph(graph, type="shell", layout=None): cols = list() for n in graph.nodes: if graph.nodes[n]['state'] == "S": cols.append("blue") elif graph.nodes[n]['state'] == "I": cols.append("red") else: cols.append("green") options = { 'node_color': cols, 'node_size': 50, 'width': 2, } if not layout is None: nx.draw(graph, pos=layout, **options) elif type == "shell": nx.draw_shell(graph, **options) elif type == "spectral": nx.draw_spectral(graph, **options) elif type == "spring": nx.draw_spring(graph, **options) else: nx.draw(graph, **options) return
def affiche(self): #Je recupere une liste de fitness des 20% meilleurs graphe listeBestFitness = [] for i in range(len(self.listGraph)): #creation d'une liste de tuples listeBestFitness.append( (self.listGraph[i].ID, self.listGraph[i].fitness)) listeBestFitness = sorted(listeBestFitness, key=self.getFitness) IDmemory = [] f = open('bestfitness.txt', 'w') f.write('ID\tfitness\n') for j in range(1, int(len(listeBestFitness) * 20.0 / 100) + 1): IDmemory.append(listeBestFitness[-j][0]) f.write('%i\t%f\n' % listeBestFitness[-j]) f.close() #Liste des graphes correspondant aux 20% aillant la meilleure fitness BestListGraph = [] for i in self.listGraph: if i.ID in IDmemory: BestListGraph.append(i) #print('best fitness :' + str(len(BestListGraph))) #Affichage de tous les graphes for k in BestListGraph: fig = plt.figure() deg = nx.degree(k.graph).values() nx.draw_spectral(k.graph, node_size=10, with_labels=False, width=0.5, node_color=deg, cmap=plt.cm.Blues) plt.savefig('graphe_%i' % k.ID, format='png') plt.close(fig)
def graph_statistics(g: nx.Graph, artifact_path: str): clustering_coeff = nx.average_clustering(g) density = nx.density(g) summary = io.StringIO() summary.write(f"{nx.info(g)}\n") summary.write(f"Clustering Coefficient: {clustering_coeff}\n") summary.write(f"Density: {density}\n") with open(f"{artifact_path}/summary.txt", "w") as f: f.write(summary.getvalue()) print(summary.getvalue()) plt.clf() nx.draw(g) plt.savefig(f"{artifact_path}/force_directed.png") plt.clf() nx.draw_spectral(g) plt.savefig(f"{artifact_path}/spectral.png") plt.clf() buckets = nx.degree_histogram(g) degrees = list(range(len(buckets))) plt.loglog(degrees, buckets) plt.savefig(f"{artifact_path}/degree_histogram.png")
def draw_spectral_communities(self): partition = self.find_partition()[1] node_color=[float(partition[v]) for v in partition] labels = self.compute_labels() nx.draw_spectral(self.G,node_color=node_color, labels=labels) plt.show() plt.savefig("C:\\Users\\Heschoon\\Dropbox\\ULB\\Current trends of artificial intelligence\\Trends_project\\graphs\\graph_spectral.pdf")
def graph_trajectory(trajectory): """ plots unique state changes for input trajectory """ source = trajectory.shift() target = trajectory # add subscripts so transitions are unique for i, r in source.iteritems(): if r is not np.nan: source[i] = f'{r}$_{{{i-1}}}$' for i, r in target.iteritems(): target[i] = f'{r}$_{{{i}}}$' df = pd.concat( [source, target], axis=1, ).reset_index(drop=True) df.columns = ['source', 'target'] df = df.iloc[1:] # drop first row with nan G = nx.from_pandas_edgelist(df, 'source', 'target', create_using=nx.DiGraph()) plt.figure(figsize=(20, 10), dpi=80, facecolor='w') nx.draw_spectral(G, with_labels=True, node_color='#d3d3d3') plt.show()
def draw_graph(g, out_filename): nx.draw(g) nx.draw_random(g) nx.draw_circular(g) nx.draw_spectral(g) plt.savefig(out_filename)
def visualize_graph(adj_mat, burned, defended): g = nx.convert_matrix.from_numpy_matrix(adj_mat) node_color = np.where(burned, 1.0, 0.2) node_color = np.where(defended, 0.6, node_color) nx.draw_spectral(g, node_color=node_color.tolist()) plt.plot() plt.show()
def drawgraph(self, G): nx.draw(G) plt.savefig(self.opts.o[0] + ".cluster_graph.png") nx.draw_random(G) plt.savefig(self.opts.o[0] + ".cluster_graph_random.png") nx.draw_circular(G) plt.savefig(self.opts.o[0] + ".cluster_graph_circular.png") nx.draw_spectral(G) plt.savefig(self.opts.o[0] + ".cluster_graph_spectral.png")
def draw_graph_spectral(y, clusters='blue', ns=30): G = nxG(y) pos = graphviz_layout(G, prog='twopi', args='') plt.figure() nx.draw_spectral(G, cmap=plt.get_cmap('jet'), node_color=clusters, node_size=30, with_labels=False)
def test_pop(): import matplotlib.pyplot as plt G = nx.DiGraph() search_query = sch.search_pubs_query('10.1109/THS.2013.6698999') P = search_query.next() P = P.fill() populate_graph(P, G) nx.draw_spectral(G) plt.show()
def draw_spectral_communities(self): partition = self.find_partition()[1] node_color = [float(partition[v]) for v in partition] labels = self.compute_labels() nx.draw_spectral(self.G, node_color=node_color, labels=labels) plt.show() plt.savefig( "C:\\Users\\Heschoon\\Dropbox\\ULB\\Current trends of artificial intelligence\\Trends_project\\graphs\\graph_spectral.pdf" )
def visualisation(chain, pairs): G = nx.Graph() a = range(len(chain)) G.add_edges_from([(i, i + 1) for i in a[:-1]]) G.add_edges_from(pairs) nx.draw_spectral(G) plt.show()
def demo_save_fig(): """demo_save_fig""" g = nx.Graph() g.add_edges_from([(1, 2), (1, 3)]) g.add_node('sparm') nx.draw(g) nx.draw_random(g) nx.draw_circular(g) nx.draw_spectral(g) plt.savefig("g.png")
def _save_graph(graph, path): plt.figure(figsize=(10, 10)) nx.draw_spectral( graph, node_color=(list(graph.nodes())), node_size=400, cmap=plt.cm.Blues, with_labels=True, ) plt.savefig(path)
def main(): print("Graphing!") G = nx.Graph() G.add_nodes_from([1 - 3]) G.add_edge(1, 2) nx.draw_random(G) nx.draw_circular(G) nx.draw_spectral(G) plt.show()
def main(): print("Graphing!") G = nx.Graph() G.add_nodes_from([1-3]) G.add_edge(1, 2) nx.draw_random(G) nx.draw_circular(G) nx.draw_spectral(G) plt.show()
def drawGraph(): time.sleep(15) log.info("Network's topology graph:") nx.draw_spectral(g) nx.draw_networkx_edge_labels(g,pos=nx.spectral_layout(g)) #nx.draw_circular(g) #nx.draw_networkx_edge_labels(g,pos=nx.circular_layout(g)) #nx.draw_shell(g) #nx.draw_networkx_edge_labels(g,pos=nx.shell_layout(g)) plt.show()
def demo_write_doc(): """demo_write_doc""" g = nx.Graph() g.add_edges_from([(1, 2), (1, 3)]) g.add_node('sparm') nx.draw(g) nx.draw_random(g) nx.draw_circular(g) nx.draw_spectral(g) nx.draw_graphviz(g) nx.write_dot(g, 'g.dot')
def test_draw(self): # hold(False) N = self.G nx.draw_spring(N) pylab.savefig("test.png") nx.draw_random(N) pylab.savefig("test.ps") nx.draw_circular(N) pylab.savefig("test.png") nx.draw_spectral(N) pylab.savefig("test.png")
def test_draw(self): # hold(False) N=self.G nx.draw_spring(N) pylab.savefig("test.png") nx.draw_random(N) pylab.savefig("test.ps") nx.draw_circular(N) pylab.savefig("test.png") nx.draw_spectral(N) pylab.savefig("test.png")
def vis_graph(graph, image_path, mode='circular'): plt.figure(num=None, figsize=(20, 20), dpi=80) plt.axis('off') fig = plt.figure(1) if mode == 'spectral': nx.draw_spectral(graph) if mode == 'spring': nx.draw_spring(graph) if mode == 'circular': nx.draw_circular(graph) #plt.show() plt.savefig(image_path)
def _create_dependency_graph(self): dot = self.workflow.get_dot() dot_file = StringIO() dot_file.write(dot.source) dot_file.seek(0) graph = nx.drawing.nx_pydot.read_dot(dot_file) image = BytesIO() nx.draw_spectral(graph, with_labels=True) plt.savefig(image, format='png') return b64encode(image.getvalue()).decode()
def drawGraph(): time.sleep(15) log.info("Network's topology graph:") log.info(' -> ingress switches: {}'.format(list(ingress))) log.info(' -> egress switches: {}'.format(list(egress))) nx.draw_spectral(graph) nx.draw_networkx_edge_labels(graph, pos=nx.spectral_layout(graph)) #nx.draw_circular(graph) #nx.draw_networkx_edge_labels(graph, pos=nx.circular_layout(graph)) #nx.draw_shell(graph) #nx.draw_networkx_edge_labels(graph, pos=nx.shell_layout(graph)) plt.show()
def show(self, mode=None): if not mode: nx.draw(self) elif mode == 'random': nx.draw_random(self) elif mode == 'circular': nx.draw_circular(self) elif mode == 'spectral': nx.draw_spectral(self) plt.show()
def displayGraph(self, g, label=False): axon, sd = axon_dendrites(g) sizes = node_sizes(g) * 50 if len(sizes) == 0: print('Empty graph for cell. Make sure proto file has `*asymmetric` on top. I cannot handle symmetric compartmental connections') return node_colors = ['k' if x in axon else 'gray' for x in g.nodes()] lw = [1 if n.endswith('comp_1') else 0 for n in g.nodes()] self.axes.clear() try: nx.draw_graphviz(g, ax=self.axes, prog='twopi', node_color=node_colors, lw=lw) except (NameError, AttributeError) as e: nx.draw_spectral(g, ax=self.axes, node_color=node_colors, lw=lw, with_labels=False, )
def test_draw(self): N=self.G nx.draw_spring(N) plt.savefig("test.ps") nx.draw_random(N) plt.savefig("test.ps") nx.draw_circular(N) plt.savefig("test.ps") nx.draw_spectral(N) plt.savefig("test.ps") nx.draw_spring(N.to_directed()) plt.savefig("test.ps") os.unlink('test.ps')
def GirvanNewman(G): no_component = nx.number_connected_components(G) #number of components print("Number of components: ", no_component) number_comp = no_component while number_comp <= no_component: #while loop to partition graph into separate components betweenness = nx.edge_betweenness_centrality(G) #edge betweenness highest = max(betweenness.values()) #highest betweenness print("Highest betweenness: ", highest) for key, value in betweenness.items(): if float(value) == highest: print("Edge removed ", key[0],key[1]) G.remove_edge(key[0],key[1]) #remove the edge with highest betweenness nx.draw_spectral(G) #draw graph after edge removed plt.show() number_comp = nx.number_connected_components(G) #recalculate number of components print("\nNumber of components: ", number_comp) #print number of components
def to_nx_graph(self, aut): nx_graph = nx.MultiDiGraph( autosize=False, size="5.75,7.25", ranksep="0.9", splines=True, sep="+5, 5", overlap="false", nodesep="0.2", labelfontcolor="blue", labelloc="t", label=self.title_name, ) nx_graph.add_nodes_from( list(aut.states), height="0.4", width="0.4", color="pink", style="filled", fixedsize=False, fontsize="11" ) for k in aut.transitions.keys(): for key, value in aut.transitions[k].items(): for v in value: nx_graph.add_edge( k, v, color=(self.color_set[2]) if (key == "#") else (self.color_set[list(aut.char_set).index(key) % len(list(aut.char_set))]), arrowsize=0.5, labeldistance=2.5, penwidth="0.8", ) nx.draw_spectral(nx_graph) gv_graph = to_agraph(nx_graph) gv_graph.layout(prog="dot") # prog=neato|dot|twopi|circo|fdp|nop # set start & end states for node in gv_graph.nodes(): if int(node.get_name()) in aut.e_states: node.attr["color"] = "green" node.attr["shape"] = "doublecircle" elif int(node.get_name()) in aut.s_states: node.attr["color"] = "blue" node.attr["shape"] = "diamond" gv_graph.draw("pics/" + str(self.pic_name) + ".png") return gv_graph
def test_draw(self): try: N = self.G nx.draw_spring(N) plt.savefig('test.ps') nx.draw_random(N) plt.savefig('test.ps') nx.draw_circular(N) plt.savefig('test.ps') nx.draw_spectral(N) plt.savefig('test.ps') nx.draw_spring(N.to_directed()) plt.savefig('test.ps') finally: try: os.unlink('test.ps') except OSError: pass
def __draw_dual_pivot__(G, pos, width, height, pivot, mapping, node_size, pivot_color, pivot_label): """ Given a pivot, annotate it with color and label (handling duplicate if necessary) in dual. :param G: Graph. :param pos: position in canvas. :param pivot: pivot dart. :param mapping: :param node_size: size of nodes in drawing. :param pivot_color: pivot dart color. :param pivot_label: :return: Nothing. """ # Use different color for pivot dart (Handle boundary duplication if necessary). pivot_dups = resolve_boundary_darts( mapping[pivot.dual.tail.name], mapping[pivot.dual.head.name]) if pivot != None else [] pivot_dups = __remove_boundary_to_boundary_darts__(pivot_dups, width, height) nx.draw_spectral(G,node_size=node_size,edgelist=pivot_dups,width=3,edge_color=pivot_color,node_color='white') # Label pivot dart with pivot_label. nx.draw_networkx_edge_labels(G, pos, edge_labels=__pivot_labels__(pivot_dups, pivot_label), label_pos=0.5)
def __draw_primal_pivot__(G, pos, pivot, mapping, node_size, pivot_color, pivot_label): """ Given a pivot, annotate it with color and label (handling duplicate if necessary). :param G: Graph. :param pos: position in canvas. :param pivot: pivot dart. :param mapping: :param node_size: size of nodes in drawing. :param pivot_color: pivot dart color. :param pivot_label: :return: Nothing. """ # Use different color for pivot dart (Handle boundary duplication if necessary). pivot_in_dups = resolve_boundary_darts(mapping[pivot.tail.name], mapping[pivot.head.name]) if \ pivot is not None else [] nx.draw_spectral(G,node_size=node_size,edgelist=pivot_in_dups,width=3,edge_color=pivot_color,arrows=True) # Annotate pivot dart label with "in". nx.draw_networkx_edge_labels(G, pos, edge_labels=__pivot_labels__(pivot_in_dups, pivot_label), label_pos=0.5,arrows=True)
def plot_graph(self, file_name: str='graph.png', label_nodes: bool=True, label_edges: bool=True): import matplotlib.pyplot as plt # pos = nx.spring_layout(self.graph) pos = nx.shell_layout(self.graph, dim=1024, scale=0.5) # pos = nx.random_layout(self.graph, dim=1024, scale=0.5) if label_edges: edge_labels = { (edge[0], edge[1]): edge[2]['object'] for edge in self.graph.edges(data=True) } nx.draw_networkx_edge_labels(self.graph, pos, edge_labels, font_size=5) if label_nodes: labels = {node[0]: node[1] for node in self.graph.nodes(data=True)} nx.draw_networkx_labels(self.graph, pos, labels, font_size=5, alpha=0.8) # nx.draw(self.graph, with_labels=True, arrows=True, node_size=80) nx.draw_spectral(self.graph, with_labels=True, arrows=True, node_size=80) plt.savefig(file_name, dpi=1024)
def draw_all(graph): """ Draw all different layout types for graph """ nx.draw(graph) plt.savefig(path + 'draw.png') plt.close() nx.draw_circular(graph) plt.savefig(path + 'draw_circular.png') plt.close() nx.draw_random(graph) plt.savefig(path + 'draw_random.png') plt.close() nx.draw_spectral(graph) plt.savefig(path + 'draw_spectral.png') plt.close() nx.draw_spring(graph) plt.savefig(path + 'draw_spring.png') plt.close() nx.draw_shell(graph) plt.savefig(path + 'draw_shell.png') plt.close()
def try_different_layouts(graph): layout_dir = 'graph_layout' if not os.path.exists(layout_dir): os.mkdir('graph_layout') nx.draw_random(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey') plt.axis('off') plt.savefig(layout_dir + os.sep + 'rand.png', bbox_inches='tight', pad_inches=0, transparent=True) plt.show() nx.draw_circular(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey') plt.axis('off') plt.savefig(layout_dir + os.sep + 'circular.png', bbox_inches='tight', pad_inches=0, transparent=True) plt.show() nx.draw_spectral(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey') plt.axis('off') plt.savefig(layout_dir + os.sep + 'spectral.png', bbox_inches='tight', pad_inches=0, transparent=True) plt.show() nx.draw_networkx(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey') plt.axis('off') plt.savefig(layout_dir + os.sep + 'networkx.png', bbox_inches='tight', pad_inches=0, transparent=True) plt.show() nx.draw(graph, pos=graphviz_layout(graph), with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey') plt.axis('off') plt.savefig(layout_dir + os.sep + 'graphviz.png', bbox_inches='tight', pad_inches=0, transparent=True) plt.show() nx.draw_shell(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey') plt.axis('off') plt.savefig(layout_dir + os.sep + 'shell.png', bbox_inches='tight', pad_inches=0, transparent=True) plt.show() nx.draw_spring(graph, with_labels=True, font_size=16, node_size=500, alpha=0.8, width=4, edge_color='grey') plt.axis('off') plt.savefig(layout_dir + os.sep + 'spring.png', bbox_inches='tight', pad_inches=0, transparent=True) plt.show()
def show(self): edges = self.getEdges(self.networkTopology) nodes = self.getNodes(self.networkTopology) G=nx.Graph() G.add_nodes_from(nodes) G.add_edges_from(edges) #print G.nodes() #print G.edges() pos=nx.graphviz_layout(G,prog='twopi',args='') #plt.figure(figsize=(8,8)) # >>> nx.draw(G) # >>> nx.draw_random(G) # >>> nx.draw_circular(G) # >>> nx.draw_spectral(G) nx.draw_spectral(G) #,pos,node_size=300,alpha=0.5,node_color="blue", with_labels=True) #plt.axis('equal') #plt.savefig('circular_tree.png') plt.show()
def nx_plot(r_graph, cols_names, simple=True, labels=None, 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'): #G = nx.Graph() dg = nx.DiGraph() edges = [] np_amat = np.asarray(bnlearn.amat(r_graph)) for ri in range(np_amat.shape[0]): for ci in range(np_amat.shape[1]): if np_amat[ri,ci] == 1: #G.add_edge(cols_names[ri],cols_names[ci]) dg.add_edge(cols_names[ri],cols_names[ci]) edges.append((cols_names[ri],cols_names[ci])) #import pdb;pdb.set_trace() if simple: if graph_layout=='spectral': nx.draw_spectral(dg,font_size=node_text_size) elif graph_layout=='random': nx.draw_random(dg,font_size=node_text_size) elif graph_layout=='circular': nx.draw_circular(dg,font_size=node_text_size) elif graph_layout=='spring': nx.draw_spring(dg,font_size=node_text_size) else: nx.draw(dg,font_size=node_text_size) else: draw_graph(edges,directed=True, labels=labels, graph_layout=graph_layout, node_size=node_size, node_color=node_color, node_alpha=node_alpha, node_text_size=node_text_size, edge_color=edge_color, edge_alpha=edge_alpha, edge_tickness=edge_tickness, edge_text_pos=edge_text_pos, text_font=text_font)
def main(): print "input_net module is the main code." EDGE_FILE = 'net-edges.dat' NODE_FILE = 'net-nodes.dat' # Asks user if network has been damaged. damage = raw_input("Type in 1 for DNA damage and 0 for no damage: ") # These input calls are for the presence of damage to the system in the form of node or edge deletion. node_delete = str(raw_input("Type in node for deletion or none for no deletion: ")) u = str(raw_input("Type in upstream node of edge for deletion or none for no deletion: ")) if u != 'none': v = str(raw_input("Type in downstream node of edge for deletion: ")) edge_delete = u,v else: edge_delete = u # Reads in the network given any damage to nodes or edges. net = read_network_from_file(EDGE_FILE, NODE_FILE, node_delete, edge_delete) nodes_list = build_nodes_list(NODE_FILE, node_delete) # Prints edge list with corresponding weights. for u, v in net.edges(): print u, v, net[u][v]['weight'] # Prints node list print nodes_list #nx.draw(net) #nx.draw_random(net) #nx.draw_circular(net) nx.draw_spectral(net) plt.show()
def graph_pedigree(self, pedigree=None): """ Method that graphs the given pedigree. Parameters ---------- pedigree : {literal -> [literal]} (optional) Dictionary rep (adj. list) of pedigree graph. If none is provided, self.pedigree will be used. """ if not pedigree: pedigree = self.pedigree G = self._construct_graph() # change drawing method to change the shape of the graph pos = nx.draw_spectral(G) nx.draw(G, pos) plt.show()
def dependency_map(self): r""" Create a graph of the dependency graph in a decent format See Also -------- dependency_graph dependency_list """ dtree = self.dependency_graph() fig = nx.draw_spectral(dtree, with_labels=True, arrowsize=50, node_size=2000, edge_color='lightgrey', width=3.0, font_size=32, font_weight='bold') return fig
edges.append((a,b)) edges = sorted(list(set(edges))) faces = {} for i in range(60): faces[i] = [] for i in range(len(edges)): a,b = edges[i] point1 = verticies[edges[i][0]] point2 = verticies[edges[i][1]] # pltEdges(point1, point2) faces[edges[i][0]].append(edges[i][1]) G.add_edge(a,b) nx.draw_spectral(G,with_labels=True, edge_color=range(90), edge_cmap=plt.cm.cool) plt.show() pent_nodes = [ (9,27,55,58,33), (0,12,37,40,18), (6,24,43,46,30), (1,13,38,41,19), (7,25,44,47,31), (10,34,59,56,28), (45,42,26,8,32), (4,16,50,53,22), (5,23,51,48,17), (2,14,36,39,20), (3,15,49,52,21), (11,29,54,57,35)