def navigate(self, node: Node): chds = node.childrens for n in chds: self.graph.edge(str(node.ev_id), str(n.ev_id), None, dir='forward') if n.validity == Validity.INVALID: self.graph.node(str(n.ev_id), self.name_for_node(n), fillcolor=self.INVALID_COLOR, style='filled') elif n.validity == Validity.VALID: self.graph.node(str(n.ev_id), self.name_for_node(n), fillcolor=self.VALID_COLOR, style='filled') elif n.validity == Validity.UNKNOWN: self.graph.node(str(n.ev_id), self.name_for_node(n)) elif n.validity is Validity.NOT_IN_PROV: self.graph.node(str(n.ev_id), self.name_for_node(n), fillcolor=self.PROV_PRUNED_NODE_COLOR, style='filled') if len(chds) > 0: g = Graph() for c in chds: g.node(str(c.ev_id)) g.graph_attr['rank'] = 'same' self.graph.subgraph(g) for n in chds: self.navigate(n)
def main(): """ Main """ print("Content-type: text/html\r\n\r\n") personnages = retreive_personnnages() groupes = retreive_groupes() trames = retreive_trames() geographies = retreive_geographie() materiels = retreive_materiels() link_to_nomgraph = build_link_to_nom_graph_dict(personnages, groupes, trames, geographies, materiels) dot = Graph(name='Dragons', filename='./tmp/derniersDragons.gv', comment='Les Derniers Dragons', strict=True) add_nodes_types_shape(dot, personnages) add_nodes_types_shape(dot, groupes) add_nodes_types_shape(dot, trames) add_nodes_types_shape(dot, geographies) add_nodes_types_shape(dot, materiels) add_link_personnages(dot, link_to_nomgraph, personnages) add_link_groupes(dot, link_to_nomgraph, groupes) add_link_trames(dot, link_to_nomgraph, trames) add_link_geographie(dot, link_to_nomgraph, geographies) add_link_materiels(dot, link_to_nomgraph, materiels) dot.save() print("done")
def visual_decoding(sent, saveto='tmp'): """ Visualize multiple translation from machine translation. Example: >>> sentence = ['I have a apple', 'I have a dream', 'H have an egg'] >>> visual_decoding(sent=sentence, saveto='demo') Args: sent: a list of str Multiple translations. saveto: str Graph will be saved as 'saveto.png'. Returns: None """ graph = Graph(format='png', node_attr={'shape':'box'}, graph_attr={'splines':'polyline'}, edge_attr={'dir':'forward'}) graph.body.extend(['rankdir=LR']) for i,s in enumerate(sent): graph = _plot_sent(graph, s, flag=str(i)) graph.render(filename=saveto, view=True)
def __init__(self): self._graph = Graph('equation') self._subgraph_terms = Graph('terms') self._terms = {} self._graph.attr(rankdir='BT', ordering='out') #, splines='false') self._subgraph_terms.attr(rank='same', rankdir='LR')
def newBlock(self, value, dataObj=None): ''' ### Function Description Create new block diagram. This is the main function to create a new block diagram object. This module use Graph for visualiztion. There's no direction edge in this method. ### Parameters Description * value: * type: str, int * description: text for block diagram. Identifier for user to name the node * id: * type: int * description: serial number for each node * dataObj: * type: object * description: store object item in node for advanced application ''' if self.rootNode == None: self.rootNode = Node(value, self.nodeIDCount, dataObj) self.nodeIDCount += 1 self.rootNode.isRootNode = True self.currNodePtr = self.rootNode self.newNodePtr = self.rootNode self.add2NodeListPtr(self.rootNode) print('*Block Diagram is created. The root node ID is %d' % self.currNodePtr.id) self.graph = Graph(name='BlockDiagram', filename='BlockDiagram.gv', engine='dot') self.addGraphvizNode()
def make_graph_mst(): g = Graph(format='png', comment='undirected graph that contains no negative weight path') g.attr('node', shape='circle') n = 9 for i in range(n): g.node(str(i), label=str(i)) edges = ((0, 1), (0, 7), (1, 2), (1, 7), (2, 3), (2, 5), (2, 8), (3, 4), (3, 5), (4, 5), (5, 6), (6, 7), (6, 8), (7, 8)) edge_labels = [4, 8, 8, 11, 7, 4, 2, 9, 14, 10, 2, 1, 6, 7] for i, e in enumerate(edges): g.edge(str(e[0]), str(e[1]), label=str(edge_labels[i])) g.render('graph_mst', view=True, cleanup=True)
def make_graph_dijkstra(): g = Graph(format='png', comment='undirected graph that contains no negative weight path') g.attr('node', shape='circle') n = 10 for i in range(n): g.node(str(i), label=str(i)) edges = ((0, 1), (2, 0), (2, 3), (1, 4), (4, 5), (5, 2), (3, 6), (4, 7), (5, 8), (8, 9)) edge_labels = [5, 6, 2, 2, 3, 4, 1, 7, 1, 1, 1] for i, e in enumerate(edges): g.edge(str(e[0]), str(e[1]), label=str(edge_labels[i])) g.render('graph_dijkstra', view=True, cleanup=True)
def make_bipartite_graph(): g = Graph(format='png', comment='undirected graph that contains no negative weight path', engine='dot') g.attr('node', shape='circle') n = 10 with g.subgraph(name='cluster_0') as c: c.attr(label='process #1') for i in range(0, n, 2): c.node(str(i), label=str(i), color='blue') with g.subgraph(name='cluster_1') as c: c.attr(label='process #2') for i in range(1, n, 2): c.node(str(i), label=str(i), color='red') edges = ((0, 1), (1, 2), (1, 4), (2, 9), (3, 4), (4, 5), (4, 9), (5, 6), (6, 7), (6, 9), (8, 9)) for e in edges: g.edge(str(e[0]), str(e[1])) g.render('graph_bipartite', view=True, cleanup=True)
def graph_data(pkg_name): if not pkg_name: abort(404) filepath = os.path.join(cache_dir, pkg_name.lower()) if not os.path.exists(filepath + '.png'): nodes, edges = reqs_graph(pkg_name) if not nodes: return redirect(url_for('static', filename='img/blank.png')) dot = Graph() dot.format = 'png' dot.node('0', nodes[0], fillcolor='#fbb4ae', style='filled', shape='box') for i, pkg_name in enumerate(nodes[1:]): dot.node(str(i+1), pkg_name, fillcolor='#ccebc5', style='filled') dot.edges([ [str(i[0]), str(i[1])] for i in edges ]) dot.render(filepath) return send_file(filepath + '.png')
def dump_graph(self, dot: Graph, fid=''): """Dump the subtree. """ sid = str(id(self)) dot.node(sid, str(self), shape='box') if fid: dot.edge(fid, sid)
def change_graph(self, cnt, indices, restore_flg=False): g = Graph(format='png') for nnm in self.rc_name: g.node(nnm) if restore_flg: indices = sorted(indices, reverse=True) self.graph_matrix[indices[0]][indices[1]] = 1 print('Graph Matrix : ', self.graph_matrix) for i in range(self.graph_matrix.shape[0]): for j in range(self.graph_matrix.shape[1]): if i > j and self.graph_matrix[i][j] == 1: g.edge(self.rc_name[i], self.rc_name[j]) file_name = './graph_restored_' + str( cnt) # 保存する画像のファイル名を指定(拡張子(.png)を除く) else: indices = sorted(indices, reverse=True) self.graph_matrix[indices[0]][indices[1]] = 0 print('Graph Matrix : ', self.graph_matrix) for i in range(self.graph_matrix.shape[0]): for j in range(self.graph_matrix.shape[1]): if i > j and self.graph_matrix[i][j] == 1: g.edge(self.rc_name[i], self.rc_name[j]) file_name = './graph_' + str(cnt) # 保存する画像のファイル名を指定(拡張子(.png)を除く) g.render(filename=file_name, format='png', cleanup=True, directory=None) im = Image.open(file_name + '.png') im.show()
def graphs(file,deleted_node):#methodos gia to proairetiko meros from graphviz import Graph dot = Graph(node_attr={'color': 'lightblue2', 'style': 'filled'},format='jpg',engine='fdp') visited={} adjList=create_graph(file) deleted=False for x in adjList: visited[x]=False for key in adjList: for erased in deleted_node: if key==erased: dot.node(str(key),str(key),color='lightgrey') deleted=True if not deleted: dot.node(str(key),str(key)) deleted=False for i in adjList[key]: if not visited[i]: for erased in deleted_node:#elegxei an exoun diagraftei oi komvoi i kai key if erased==i or erased==key: deleted=True if not deleted:#den exoun diagraftei ara tous enono dot.edge(str(key),str(i)) deleted=False visited[key]=True dot.view()
def color(self): # Dict to save color color = defaultdict(list) for node in self.graph: if (len(color) == 0): color[0].append(node) continue else: for i in range(len(color)): temp = 0 for colored_node in color[i]: if (node in self.graph[colored_node]): temp = 1 break if (temp == 1): continue else: color[i].append(node) break if (node not in color[i]): color[len(color)].append(node) # Out put file output_file = Graph('Coloring graph', filename='Greedy Coloring Graph.gv',strict="True") output_file.attr( shape="circle", size='1') list_color=["red","blue", "yellow","green","gray","snow","DarkOrange1","MediumPurple1","khaki4","orchid", "cyan2", "blue violet", "GreenYellow", "HotPink", "LightGoldenrod4","DarkSeaGreen", "sienna","brown"] for i in range (len(color)): for node in color[i]: output_file.node(str(node),fillcolor=list_color[i],style="filled") for opp_node in self.graph[node]: output_file.edge(str(node),str(opp_node)) output_file.view()
def printLinked(self): dl = Graph('doublylinked', node_attr={'shape': 'record'}) if self.isEmpyty(): pass else: self._draw(self.sentinel.next, dl) dl.render('doublylinked.gv', view=True)
def update_root(self, position, board, is_my_move): ''' Update the root as the selected child node ''' del self.g self.g = Graph(format='png', graph_attr={'fixed_size': 'false'}, node_attr={'fontsize': '13'}) if self.root.child[position] is None or self.root.child[ position].is_my_move != is_my_move: self.root = self.build_node(board) else: self.root = self.root.child[position] del self.root.parent self.root.parent = None # change name in graph self.root.node = self.root.node.split("label=" + str(self.root.position))[0] + "label=" + str('root') + \ self.root.node.split("label=" + str(self.root.position))[1] self.root.edge = None for c in self.root.child: if c is not None: c.node = c.node.split("label=\"\"")[0] + "label=" + str( c.position) + c.node.split("label=\"\"")[1] self.recycle_tree(self.root)
def printQueue(self): sl = Graph('singlylinked', node_attr={'shape': 'record'}) if self.stack_empty(): pass else: self._draw(self.sentinel.next, 0, sl) sl.render('singlylinked.gv', view=True)
def _topology_graph(): g = Graph(engine='dot', graph_attr={ 'ratio': '0.41', 'pad': '0.7 ', 'newrank': 'false', 'splines': 'compound' }) for isd in ISD.objects.iterator(): g_isd = _make_isd_graph(isd) # hard-coding backbone ISDs to be at the top if isd.isd_id in [16, 26]: g_isd.attr(rank='source') # putting core ASes into a subgraph, laid out at the top with g_isd.subgraph() as s: s.attr(rank='min') for as_ in isd.ases.filter(owner=None, is_core=True): _add_as_node(s, as_) # putting non-core ASes into a subgraph, without rank with g_isd.subgraph() as s: s.attr(rank='none') for as_ in isd.ases.filter(owner=None, is_core=False): _add_as_node(s, as_) g.subgraph(g_isd) for link in Link.objects.filter(interfaceA__AS__owner=None, interfaceB__AS__owner=None): _add_link(g, link) return g
def draw_clusters(_json_data, _graph): """ Function to generate cluster in cluster graph based on DOT language. """ sub_graph = None if type(_json_data) is dict: for dict_name in _json_data: if check_hidden(dict_name): if check_status(_json_data, _graph): if type(_json_data[dict_name]) is dict: # determine if a dict as dict child # if the dict include other dict, it is a cluster if check_dict_child(_json_data[dict_name]): sub_graph = Graph('cluster_' + dict_name) sub_graph.attr( label='<<B>' + dict_name + '</B>>', color='black', style='filled', #~ ranktype = 'min', #~ rankdir = 'TB', fillcolor=rand_color()) draw_clusters(_json_data=_json_data[dict_name], _graph=sub_graph) _graph.subgraph(sub_graph) # if the dict as no child, it is a node else: _graph.attr('node', shape='record') # shape='box' _graph.node(dict_name) return 0
def visual_decoding(sent, saveto='tmp'): """ Visualize multiple translation from machine translation. Example: >>> sentence = ['I have a apple', 'I have a dream', 'H have an egg'] >>> visual_decoding(sent=sentence, saveto='demo') Args: sent: a list of str Multiple translations. saveto: str Graph will be saved as 'saveto.png'. Returns: None """ graph = Graph(format='png', node_attr={'shape': 'box'}, graph_attr={'splines': 'polyline'}, edge_attr={'dir': 'forward'}) graph.body.extend(['rankdir=LR']) for i, s in enumerate(sent): graph = _plot_sent(graph, s, flag=str(i)) graph.render(filename=saveto, view=True)
def visaoSemantica(no): if(no): grafico = Graph('G', filename='Tree.gv', strict=True) desenhagrafico(no, grafico) grafico.node_attr.update(color='lightblue2', style='filled') grafico.view()
def __init__(self, name='DecisionTree', weights=[.5, 1.5]): self.total_depth = args.depth self.metric = args.metric self.name = name self.weights = weights self.graph = Graph(name=name, format='png') self.total_loss = 0
def create_graph(self): self.dot = Graph(comment='Musicians',node_attr={'width':'0.5'}, engine="fdp") for member in self._network.get_members().values(): self.dot.node(member.__str__().decode('utf8')) for neigh in member.get_outgoing_neighbours(): self.dot.node(neigh.__str__().decode('utf8')) self.dot.edge(member.__str__().decode('utf8'), neigh.__str__().decode('utf8'), constraint='true')
def program(self): self.g = Graph() self.g.format = 'png' self.index = 0 while self.index < len(self.token): if self.stmt() == False: return False self.g.view()
def __init__(self, save_name, start, end): self.args = args self.m_end = end self.m_start = start self.dot = Graph(name='diagram-' + save_name, strict=True) self.dot.graph_attr['rankdir'] = 'LR' self.dot.node_attr['shape'] = 'box'
def __init__(self, tree): self.aux_node_list = [] self.second_aux = [] self.parser_tree = tree self.count = 0 self.dot = Graph('AST') self.shape_parser_tree(self.parser_tree)
def dump_graph(self, dot: Graph, fid=''): """Dump the subtree. """ sid = str(id(self)) dot.node(sid, 'NULL', style='invis') if fid: dot.edge(fid, sid, style='invis') pass
def draw_link(g: Graph, networks: typing.Dict[str, Network], link: Link): try: g.edge(f"container_{link.container_id}:{link.endpoint_id}", f"network_{link.network_name}", color=networks[link.network_name].color ) except KeyError: # FIX: need to fix this later (problem comes from links) pass
def geraArvoreGraph(no, Erros, bol): if(bol): if not Erros : printArvore(no) if(no) : grafico = Graph('G', filename='Tree.gv', strict=True) desenhagrafico(no, grafico) grafico.node_attr.update(color='lightblue2', style='filled') grafico.view()
def export(self, path='out/network'): """Exports graphviz version of the graph""" from graphviz import Graph as Vizgraph g = Vizgraph('Network', engine='sfdp') for i, j in self.get_edges(): g.edge(str(i), str(j), constraint='false') g.render(path, view=False)
def dump_graph(self, dot: Graph, fid=''): """Dump the subtree. """ sid = str(id(self)) dot.node(sid, str(self)) if fid: dot.edge(fid, sid) self.left.dump_graph(dot, sid) self.right.dump_graph(dot, sid)
def dump_graph(self): """ Use graphviz to dump into an image. Return the base64-encoded string of a png file. """ dot = Graph(format='png') self.root.dump_graph(dot) return b64encode(dot.pipe()).decode('utf-8')
class WeiGraph(): ''' 带权图 ''' def __init__(self, nodes, edges): ''' nodes 结点集 edges 边集 graph 邻接表 G Graphviz.Graph 用于可视化图 ''' self.nodes = nodes self.edges = edges self.graph = [] for node in nodes: self.graph.append([(node, 0)]) for (x, y, w) in edges: for n in self.graph: if n[0][0] == x: n.append((y, w)) if n[0][0] == y: n.append((x, w)) self.G = None def adjs(self, node): ''' 返回邻接表, 用于 Prim 算法 param node : 需要寻找邻接点的结点 return : 邻接结点表 ''' return list(filter(lambda n: n[0][0] == node, self.graph))[0][1:] #返回以 node 开始的邻接结点表 def draw(self, color_filter=None): ''' 可视化所生成的图 ''' if color_filter is None: color_filter = lambda edge: 'black' #全部为黑色 settings = dict(name='Graph', engine='circo', node_attr=dict(shape='circle')) self.G = Graph(**settings) for node in self.nodes: self.G.node(str(node), str(node)) for (x, y, w) in self.edges: self.G.edge(str(x), str(y), label=str(w), color=color_filter((x, y, w))) return self.G
def __str__(self): A = Graph() for vertice in self.meuGrafo.nodes_iter(data=False): A.node(vertice.encode("utf8")) for aresta_A, aresta_B, dados_aresta in self.meuGrafo.edges_iter(data=True): peso_aresta = dict((chave, str(valor)) for chave, valor in dados_aresta.items()) peso_aresta['label'] = peso_aresta['weight'] del peso_aresta['weight'] A.edge(aresta_A.encode("utf8"), aresta_B.encode("utf8"), **peso_aresta) return A.source
def model_to_dot(model): g = Graph(name=model.name) for comp in model.compartments: gcomp = compartment_to_dot(comp) gcomp.subgraph = True gcomp.tag('::'+comp.id) g.add(gcomp) if model.get_param('FORCE_LABELS'): g.add(AttrStmt('graph',forcelabels="true")) return g
def subsystem_to_dot(subsystem): clone_links = clone_mets(subsystem) g = Graph(name=subsystem.id) if subsystem.get_param('CLUSTER_SUBSYSTEMS'): g.cluster = True style = subsystem.get_param('SUBSYSTEM_BORDER_STYLE') g.add(AttrStmt('graph',style=style)) for rxn in subsystem.reactions: g.add(reaction_to_dot(rxn)) g.add(AttrStmt('graph',label=subsystem.name, fontsize=subsystem.get_param('SUBSYSTEM_FONTSIZE'))) if clone_links: g.add(clone_links) return g
def graphUpdate(self): if self.aType == "tw": self.graph = Digraph() elif self.aType == "fb": self.graph = Graph() else: exit("Invalid Analyze Type") for key in self.nameIndex.keys(): self.graph.node(self.nameIndex[key], key) for key in self.network.keys(): for friend in self.network[key]: if friend != "": self.graph.edge(self.nameIndex[key],self.nameIndex[friend])
def visualize_countries_together_in_item(data, start_time_str=None, end_time_str=None, newspaper_str='*'): countries_together_dict = _get_countries_together_in_items(data) # print 'countries_together_dict:', countries_together_dict dot = Graph(comment='Countries together in item graph', engine='sfdp') seen_countries = set() edges_between_countries = defaultdict(int) ## Building the graph for ID_and_feed, countries in countries_together_dict.iteritems(): countries_list = list(countries) for country in countries_list: if country != '' and country not in seen_countries: dot.node(country, label=country) seen_countries.add(country) for i in xrange(len(countries)): for j in xrange(i+1, len(countries)): fst = min(countries_list[i], countries_list[j]) snd = max(countries_list[i], countries_list[j]) edges_between_countries[(fst, snd)] += 1 for edge_endpoints, edge_weight in edges_between_countries.iteritems(): dot.edge(edge_endpoints[0], edge_endpoints[1], weight=str(edge_weight)) print 'seen_countries:', seen_countries print 'edges_between_countries:', edges_between_countries dot = _apply_styles(dot, styles) # print dot.source out_dirname = newspaper_str.replace('*', '').replace('!', '').replace('[', '').replace(']', '') out_filename = ('countries_together_in_item_%s_%s.gv' % (start_time_str, end_time_str)).replace(':', '-') dot.render(os.path.join('images', out_dirname, out_filename), view=False)
def visualize(self): l = len(self.top_result) connections = dict() tags = dict() for i in range(l - 1): for j in range(1, l): if i != j: key = (i, j) message_list = self.get_message_list_between(self.top_result[i], self.top_result[j]) tag_cloud = self.subject.calculate_tag_cloud(message_list) tags[key] = self.get_top_tag_cloud(tag_cloud, 5) # DOT language dot = GraphV(comment = "Information Flow - Enron") for i in range(l): dot.node(str(i), self.top_result[i] + " - " + self.company.get_role(self.top_result[i])) for (edge, tag) in tags.iteritems(): node_1 = edge[0] node_2 = edge[1] note = ", ".join(tag) print note dot.edge(str(node_1), str(node_2), label=note) dot.render('test-output/round-table.gv', view=False)
def create_interactions_graph(clauses, f): dot = GGraph(comment='Interactions graph', engine='sfdp') seen_vars = set() edges_between_vars = defaultdict(int) for clause in clauses: for lit in clause: var = f(lit) if var not in seen_vars: seen_vars.add(var) dot.node(str(var), label=str(var)) for clause in clauses: l = len(clause) for i in xrange(l): for j in xrange(i+1, l): edges_between_vars[(str(f(clause[i])), str(f(clause[j])))] += 1 for interacting_vars, weight in edges_between_vars.iteritems(): dot.edge(interacting_vars[0], interacting_vars[1], weight=str(weight)) print edges_between_vars dot = _apply_styles(dot, styles) # print dot.source dot.render(os.path.join('images', 'interactions_graph.gv'), view=True)
def draw_graph(self, form, name='sample'): """the method for drawing a graph of the tree, name is the file name under which we want to save it""" self.dot = Graph(comment='Tree of our form')#Digraph(comment='Tree of our form') self.edges = [] self.comp = 0 self._create_graph(form) namefile='drawing/'+name+'.gv' self.dot.render(namefile, view=True)
def __init__(self): self.handler_dict = {Form.OperatorForm:(self.func_op_fo,{Form.D: (self.diff, {})\ , Form.Wedge: (self.wed, {}), Form.Add: (self.add,{}), \ Form.Hodge: (self.hod, {}),Form.Pullback: (self.pull, {}) }),\ Form.TerminalForm:(self.func_term_fo,{})} self.dot = Graph(comment='Tree of our form')#Digraph(comment='Tree of our form') #to store the dot for vizgraph self.edges = [] #to store the edge for the graph self.post = [] #to store the post order traversal self.pre = [] # to store the pre order traversal self.comp = 0 #to differentiate the edge
def graph_draw(nodes, edges, name): g = Graph(name, format="png") for node in nodes: g.node(str(node)) for edge in edges: x = edge.split(' ')[0] y = edge.split(' ')[1] g.edge(x, y) g.view()
def renderiza_grafo(self, lugar_para_gerar, nome_grafo): A = Graph(comment=nome_grafo, filename=(lugar_para_gerar + '/Grafo.gv'), engine='dot') for vertice in self.meuGrafo.nodes_iter(data=False): A.node(vertice.encode("utf8")) for aresta_A, aresta_B, dados_aresta in self.meuGrafo.edges_iter(data=True): peso_aresta = dict((chave, str(valor)) for chave, valor in dados_aresta.items()) peso_aresta['label'] = peso_aresta['weight'] del peso_aresta['weight'] A.edge(aresta_A, aresta_B, **peso_aresta) A.view()
def plot(graph, engine='dot', filename='output/test'): """Possible engines: dot, neato, fdp, sfdp, twopi, circo""" g = Graph(format='png', engine=engine) for v in graph: g.node(str(index(v))) for v, w in graph.edges: g.edge(str(index(v)), str(index(w))) g.render(filename)
class render: def __init__(self,our_graph,wt_dist,colour_list,tup=[-1,-1]): self.G = Graph(format='png') self.edgeList = [] #i=0 for vertex in our_graph.vertList: self.G.node(str(vertex),label='INF' if wt_dist[vertex]==10000000 else str(wt_dist[vertex]),color='red' if colour_list[vertex] else 'black') for adjvertices in our_graph.vertList[vertex].connectedTo: if tup==[vertex,adjvertices] or tup==[adjvertices,vertex]: cl='green' else: cl='black' #print vertex.connectedTo[adjvertices] if our_graph.vertList[vertex].connectedTo[adjvertices][1] in self.edgeList: pass else: self.G.edge(str(vertex),str(adjvertices),str(our_graph.vertList[vertex].connectedTo[adjvertices][0]),color=cl) self.edgeList.append(our_graph.vertList[vertex].connectedTo[adjvertices][1]) #self.G.edge(str(vertex),str((vertex+1)%10),label='edge',color='green') self.G.view()
def getDot(self, color): dot = Graph(graph_attr = {'size':'3.5'}) for node in self.G: if not node in color: dot.node(node) else: dot.node(node, style = 'filled', color = color[node]) for n1 in self.G: for n2 in self.G[n1]: if n1 < n2: dot.edge(n1, n2) return dot
def draw_SCION_topology(topology_dict, n_labels, l_labels, desc_labels): """ Draws the Scion topology from a topology dictionary returned by parse_gen_folder. :param dictionary topology_dict: dictionary returned by parse_gen_folder, boolean ip_addresses: indicates if node labels are drawn, boolean edge_labels: indicates if edge labels are drawn dict desc_labels: Dictionary containing labels for ISDs and ASes :return Dot graph: graph of the SCION topology """ isd_graphs = {} dot = Graph(name='topology', filename='topology.gv', comment='SCION-net') ISDs = topology_dict["ISD"] # draw each ISD graph for ISD in ISDs: isd_graphs[ISD] = draw_isd_graph( ISD, ISDs[ISD]["AS"], n_labels, l_labels, desc_labels) # put all isd graphs into the same graph for ISD in isd_graphs: dot.subgraph(isd_graphs[ISD]) # add edges between ISDs dot = draw_inter_ISD_edges(dot, ISDs, n_labels) return dot
def plot(graph, engine='dot', filename='output/test', vertex_names={}): """ Possible engines: dot, neato, fdp, sfdp, twopi, circo Vertex_names is an optional dict from vertices to strings. """ g = Graph(format='png', engine=engine) def vertex_to_string(v): return (vertex_names[v] if v in vertex_names else '') + ' ({})'.format(str(index(v))) for v in graph: g.node(vertex_to_string(v)) for v, w in graph.edges: g.edge(vertex_to_string(v), vertex_to_string(w)) g.render(filename)
def render(self, filename): """ Renders the graph to a file. Args: filename (str): Filename of the map file. """ dot = Graph(comment='ISTravel graph', engine='fdp') for city in self.cities: dot.node(str(city)) ploted = [] for node in self.connections: for edge in self.connections[node]: if edge not in ploted: ploted.append(edge) dot.edge( str(edge.nodes[0]), str(edge.nodes[1]), label=edge.transport[:2] ) dot.render(filename[:filename.rfind('.')]+".gv")
def create_conflicts_graph(clauses): dot = GGraph(comment='Conflicts graph', engine='sfdp') for i in xrange(len(clauses)): dot.node(str(i), label=str(i)) for i in xrange(len(clauses)): for j in xrange(i+1, len(clauses)): clause_i = clauses[i] clause_j = clauses[j] edge_labels = [] for lit in clause_i: if -lit in clause_j: var = abs(lit) edge_labels.append(str(var)) if len(edge_labels) > 0: dot.edge(str(i), str(j), label=','.join(edge_labels)) dot = _apply_styles(dot, styles) dot.render(os.path.join('images', 'conflicts_graph.gv'), view=True)
def visualize_topics(quora_data): dot = Graph(comment='Topics graph', engine='sfdp') seen_topics = set() for document in quora_data: question = _get_question(document) topics = document[question]['topics'] # Iterating over topics and adding nodes for topics if necessary for topic in topics: if topic not in seen_topics: dot.node(topic, label=topic) seen_topics.add(topic) # Iterating over topics and adding edges between topics belonging to the same question for i in xrange(len(topics)): for j in xrange(i+1, len(topics)): dot.edge(topics[i], topics[j]) # topic1, topic2 in product(topics, topics): # dot.edge(topic1, topic2) dot = _apply_styles(dot, styles) # print dot.source dot.render(os.path.join('images', 'topics.gv'), view=True)
def main(): source = sys.argv[1] with open(source, 'r') as infile: regions = json.load(infile) g = Graph('chroma', filename='chroma.graphview', format='png') for region in regions: name = region['name'] style = {"style": "filled"} if "owner" in region: owner = region["owner"] if owner == 0: style["color"] = "orange" else: style["color"] = "blue" style["fontcolor"] = "white" g.node(name, **style) for conn in region['connections']: g.edge(name, conn) g.render()
def save_nodes(self, filename="graph", nodes = None): print "Saving graph..." from graphviz import Graph dot = Graph(comment='Dungeon Example') if nodes == None: nodes = self.linear_nodes(self.nodes) #else: #max_appeared = appeared.values() #if max_appeared == []: start = 0 #else: start = max(max_appeared) + 1 #print start #for node in nodes: # if node.id not in appeared: # appeared[node.id] = start for node in nodes: name = node.name if hasattr(node, "replace_on_room_clear"): replace = node.replace_on_room_clear[0] name += "\n" try: name += replace.name except AttributeError: name += replace amount = 255 #60+(appeared[node.id]*64) fill = "#%02x%02xFF"%(amount, amount) #print fill shape = "oval" if node is self.entrance: shape = "box" dot.node(str(node.id), name, style="filled", fillcolor=fill, shape=shape) done_edges = [] for node in nodes: for edge in node.connections: if sorted([node.id, edge.id]) in done_edges: continue dot.edge(str(node.id), str(edge.id)) done_edges.append(sorted([node.id, edge.id])) dot.render(filename) print "Graph saved"
def create_graph(topology_array, link_a): dot = Graph(node_attr={'shape': 'record'}) for topo in topology_array: hostname = topo.keys()[0] if topo[hostname]["root"] == True: dot.node(hostname, build_graph_label(topo), URL="ssh://" + str(topo[hostname]["ip_address"]), style="filled", fillcolor="lightgreen") elif topo[hostname]["stp_active"] != "enabled": dot.node(hostname, build_graph_label(topo), URL="ssh://" + str(topo[hostname]["ip_address"]), xlabel="STP Disabled", style="filled", fillcolor="darkgray") else: dot.node(hostname, build_graph_label(topo), URL="ssh://" + str(topo[hostname]["ip_address"])) # dot.source are the nodes, and ends with a }, so we limit that # using create links we're able to put together the links and attributes # in the graphviz format, which are unsupported by the Graph library graphtext = dot.source[:-1] + create_links(link_a) + "}" return graphtext
#!/usr/bin/env python # process.py - http://www.graphviz.org/content/process from graphviz import Graph g = Graph('G', filename='process.gv', engine='sfdp') g.edge('run', 'intr') g.edge('intr', 'runbl') g.edge('runbl', 'run') g.edge('run', 'kernel') g.edge('kernel', 'zombie') g.edge('kernel', 'sleep') g.edge('kernel', 'runmem') g.edge('sleep', 'swap') g.edge('swap', 'runswap') g.edge('runswap', 'new') g.edge('runswap', 'runmem') g.edge('new', 'runmem') g.edge('sleep', 'runmem') g.view()
def compartment_to_dot(compartment): g = Graph(name=compartment.id,cluster=True,subgraph=True) for subsystem in compartment.subsystems: gsub = subsystem_to_dot(subsystem) gsub.subgraph = True gsub.tag('::'+subsystem.id) g.add(gsub) for comp in compartment.compartments: gcomp = compartment_to_dot(comp) gcomp.subgraph = True gcomp.tag('::'+comp.id) g.add(gcomp) label = AttrStmt('graph',label=compartment.name, fontsize=compartment.get_param('COMPARTMENT_FONTSIZE')) g.add(label) SHOW_EXCHANGES = compartment.get_param('SHOW_EXCHANGES') if SHOW_EXCHANGES and compartment.local_exchanges: gex = Graph(name=compartment.id+"::EX",cluster=True) gex.add(g) gex.add(AttrStmt('graph',style="dotted")) for ex in compartment.local_exchanges: gex.add(exchange_to_dot(ex)) return gex else: return g
class VisitorGraph(Visitor): """this class implement a tree visitor for our form""" def __init__(self): self.handler_dict = {Form.OperatorForm:(self.func_op_fo,{Form.D: (self.diff, {})\ , Form.Wedge: (self.wed, {}), Form.Add: (self.add,{}), \ Form.Hodge: (self.hod, {}),Form.Pullback: (self.pull, {}) }),\ Form.TerminalForm:(self.func_term_fo,{})} self.dot = Graph(comment='Tree of our form')#Digraph(comment='Tree of our form') #to store the dot for vizgraph self.edges = [] #to store the edge for the graph self.post = [] #to store the post order traversal self.pre = [] # to store the pre order traversal self.comp = 0 #to differentiate the edge #D form def diff(self, form, children=None): """function when a diff operation is made""" if form.scalar == 1: return( 'd') elif form.scalar == -1: return( "-d" ) else: return( "{}d ".format(form.scalar) ) #Wedge def wed(self, form, children=None): """function when a wedge operation is made""" if form.scalar == 1: return( '^') elif form.scalar == -1: return( "-^" ) else: return( "{}^ ".format(form.scalar) ) #Add def add(self, form, children=None): """function when a add operation is made""" if form.scalar == 1: return( '+') elif form.scalar == -1: return( "-+" ) else: return( "{}+ ".format(form.scalar) ) #Hodge def hod(self, form, children=None): """function when a hodge star operation is made""" if form.scalar == 1: return( '*') elif form.scalar == -1: return( "-*" ) else: return( "{}* ".format(form.scalar) ) #Pullback def pull(self, form, children=None): """function when a hodge star operation is made""" if form.scalar == 1: return("phi") else: return( "{}phi ".format(form.scalar) ) #TerminalForm def func_term_fo(self, form): """function that print a terminal Form""" if form.scalar == 1: return( form.name) elif form.scalar == -1: return( "-{} ".format(form.name) ) else: return( "{}{} ".format(form.scalar, form.name) ) def _visit_preorder(self, form): """the intern preorder method for visiting the tree""" if not isinstance(form,Form.TerminalForm): children=form.forms inter = self.find_method(form)(form) self.pre.append(inter) for fo in children: self._visit_preorder(fo) #in post order the find_method will be there else: inter = self.find_method(form)(form) self.pre.append(inter) def visit_preorder(self, form): """the preorder method for visiting the tree""" self.pre=[] self._visit_preorder(form) return self.pre def _visit_postorder(self, form): """the intern postorder method for visiting the tree""" if not isinstance(form,Form.TerminalForm): children=form.forms for fo in children: self._visit_postorder(fo) inter = self.find_method(form)(form) self.post.append(inter) else: inter = self.find_method(form)(form) self.post.append(inter) def visit_postorder(self, form): """the postorder method for visiting the tree""" self.post=[] self._visit_postorder(form) return self.post def _create_graph(self, form, parent_name=""): """the method for creating a graph of the tree, the edges are store inside the edges attribute""" if not isinstance(form,Form.TerminalForm): children = form.forms node = (self.find_method(form)(form)) nbr1 = str(self.comp) self.comp+=1 name = nbr1 self.dot.node(name, node) if parent_name is not "": inter=parent_name+name self.edges.append(inter) self.dot.edge(parent_name, name) parent_name=name for fo in children: self._create_graph(fo,parent_name) else: node = (self.find_method(form)(form)) nbr1 = str(self.comp) self.comp+=1 name = nbr1 #~ print(name) self.dot.node(name,node) if parent_name is not "": inter = parent_name+name self.edges.append(inter) self.dot.edge(parent_name, name) def draw_graph(self, form, name='sample'): """the method for drawing a graph of the tree, name is the file name under which we want to save it""" self.dot = Graph(comment='Tree of our form')#Digraph(comment='Tree of our form') self.edges = [] self.comp = 0 self._create_graph(form) namefile='drawing/'+name+'.gv' self.dot.render(namefile, view=True)
def old_reaction_to_dot(rxn): if not rxn.get_param('SHOW_MINORS') or rxn.get_param('MAX_MINORS') == 0: return reaction_to_dot_simple(rxn) INVISIBLE_NODE_ATTRS = rxn.get_param('INVISIBLE_NODE_ATTRS') EDGE_ATTRS = rxn.get_param('EDGE_ATTRS') MET_ATTRS = rxn.get_param('MET_ATTRS') CURR_MET_ATTRS = rxn.get_param('CURR_MET_ATTRS') ADD_MAJOR_LINKS = rxn.get_param('ADD_MAJOR_LINKS') if rxn.has_param("MAX_MINORS"): max_minors = rxn.get_param("MAX_MINORS") if (len(rxn.minor_reactants) > max_minors or len(rxn.minor_products) > max_minors): # prevent this change from existing effecting the original rxn rxn = copy.deepcopy(rxn) rxn.consolidate_minors(max_minors) def make_id(): curr = 0 while True: yield "$" + rxn.id + "::" + str(curr) curr += 1 ids = make_id() LINK_EDGE_ATTRS = dict(len=0.5,weight=2.0,style="invisible") MINOR_EDGE_ATTRS = dict(len=0.5,weight=2.0) PULL_EDGE_ATTRS = dict(len=0.5,weight=0.1,style="invisible") n_major_react = len(rxn.major_reactants) n_minor_react = len(rxn.minor_reactants) n_major_prod = len(rxn.major_products) n_minor_prod = len(rxn.minor_products) compact = rxn.get_param("COMPACT") statements = [] statements.append(AttrStmt("edge",**EDGE_ATTRS)) if (n_major_react == n_major_prod == 1 and n_minor_react == n_minor_prod == 0): statements.append(AttrStmt("node",**MET_ATTRS)) statements.append(Edge(rxn.major_reactants[0].id, rxn.major_products[0].id, dir="forward",id=ids.next())) return statements out_r_cent,r_cent,p_cent,out_p_cent = ["${0}::{1}".format(x,rxn.id) for x in ("or","r","p","op")] if n_major_react + n_minor_react == 1: out_r_cent = r_cent = p_cent if n_major_prod + n_minor_prod == 1: out_p_cent = p_cent = r_cent if compact or (n_major_react + n_minor_react <= 2): out_r_cent = r_cent if compact or (n_major_prod + n_minor_prod <= 2): out_p_cent = p_cent curr_name = lambda name: name + "@" + rxn.id cluster = Graph(name="cluster_"+rxn.id,subgraph=True) cluster.add(AttrStmt("graph",color="transparent",ordering="in")) cluster.add(AttrStmt("node",**INVISIBLE_NODE_ATTRS)) for center in set((out_r_cent,r_cent,p_cent,out_p_cent)): cluster.add(Node(center,**INVISIBLE_NODE_ATTRS)) cluster.add(AttrStmt("node",**CURR_MET_ATTRS)) for minor in rxn.minor_reactants: cluster.add(Edge(curr_name(minor.id),r_cent, id=ids.next(),**MINOR_EDGE_ATTRS)) if ADD_MAJOR_LINKS and out_r_cent != r_cent: # pin the node cluster.add(Edge(curr_name(minor.id),out_r_cent, **LINK_EDGE_ATTRS)) if out_r_cent != r_cent: cluster.add(Edge(out_r_cent,r_cent,len=0.5,id=ids.next())) for minor in rxn.minor_products: cluster.add(Edge(p_cent,curr_name(minor.id),dir="forward", id=ids.next(),**MINOR_EDGE_ATTRS)) if ADD_MAJOR_LINKS and out_p_cent != r_cent: cluster.add(Edge(out_p_cent,curr_name(minor.id), id=ids.next(),**LINK_EDGE_ATTRS)) if out_p_cent != p_cent: cluster.add(Edge(p_cent,out_p_cent,len=0.5,id=ids.next())) if p_cent != r_cent: cluster.add(Edge(p_cent,r_cent,len=0.5,id=ids.next())) statements.append(cluster) statements.append(AttrStmt("node",**MET_ATTRS)) for major in rxn.major_reactants: statements.append(Edge(major.id,out_r_cent,id=ids.next())) for major in rxn.major_products: statements.append(Edge(out_p_cent,major.id, dir="forward",id=ids.next())) if ADD_MAJOR_LINKS: # pull the products and reactants closer together for l,r in zip(rxn.major_reactants[0:-1],rxn.major_reactants[1:]): statements.append(Edge(l.id,r.id,**PULL_EDGE_ATTRS)) for l,r in zip(rxn.major_products[0:-1],rxn.major_products[1:]): statements.append(Edge(l.id,r.id,**PULL_EDGE_ATTRS)) return statements
def generateGraph(): G = Graph( engine = 'dot', filename = 'Btrfs-Graph.dot', name = 'BRTFS-Browser', comment = 'https://github.com/Zo0MER/BRTFS-Browser.git', graph_attr = {'rankdir': 'RL', 'charset':'utf-8', 'bgcolor':'#eeeeee', 'labelloc':'t', 'splines':'compound', 'nodesep':'0.7', 'ranksep':'5' }, node_attr = {'fontsize': '18.0', 'shape':'box' } ) #node with title and hyperlink on github G.node('meta', label = 'Btrfs-debug-tree \nhttps://github.com/Zo0MER/BRTFS-Browser.git', href = 'https://github.com/Zo0MER/BRTFS-Browser.git', fontcolor = '#4d2600', fontsize = '30.0' ) first = inode[0] inode.remove(inode[0]) if (inode): #link first item ROOT_TREE_DIR INODE_ITEM, INODE_REF with all INODE_ITEM EXTEND_DATA for pair in inode: G.edge(''.join([str(x) for x in first]), ''.join([str(x) for x in pair])) else: G.node(first) #save *.dot and others pathout = enterPath.get() filenameout = enterFilename.get() if (filenameout): filenameout = filenameout + '.gv.dot' else: filenameout = "btrfs-graph" G.filename = filenameout + '.gv.dot' G.directory = pathout G.save() for t in types: G.format = t G.render()
#!/usr/bin/env python # er.py - http://www.graphviz.org/content/ER from graphviz import Graph e = Graph('ER', filename='er.gv', engine='neato') e.attr('node', shape='box') e.node('course') e.node('institute') e.node('student') e.attr('node', shape='ellipse') e.node('name0', label='name') e.node('name1', label='name') e.node('name2', label='name') e.node('code') e.node('grade') e.node('number') e.attr('node', shape='diamond', style='filled', color='lightgrey') e.node('C-I') e.node('S-C') e.node('S-I') e.edge('name0', 'course') e.edge('code', 'course') e.edge('course', 'C-I', label='n', len='1.00') e.edge('C-I', 'institute', label='1', len='1.00') e.edge('institute', 'name1') e.edge('institute', 'S-I', label='1', len='1.00')