def _add_edge(self, jump): node = gv.node(self.graph, jump.uid.encode('utf-8')) gv.setv(node, 'shape', 'plaintext') gv.setv(node, 'label', self.create_label_for(jump).encode('utf-8')) gv.setv(node, 'fontsize', '10') self.nodes[jump.uid] = node edge_1 = gv.edge(self.nodes[jump.state_from], node) edge_2 = gv.edge(node, self.nodes[jump.state_to]) gv.setv(edge_1, 'dir', 'none') gv.setv(edge_1, 'tailport', jump.state_from.encode('utf-8')) gv.setv(edge_1, 'headport', jump.uid.encode('utf-8')) gv.setv(edge_1, 'weight', '40') gv.setv(edge_1, 'minlen', '1') gv.setv(edge_2, 'tailport', jump.uid.encode('utf-8')) gv.setv(edge_2, 'headport', jump.state_to.encode('utf-8')) gv.setv(edge_2, 'weight', '40') gv.setv(edge_2, 'minlen', '1') if isinstance(jump, facts.Option): gv.setv(edge_1, 'style', 'dotted') gv.setv(edge_2, 'style', 'dotted') if isinstance(jump, facts.Answer): pass
def createEdge(self, trdefinition): # prevent from adding multiple same named nodes nodeSet = set() for line in trdefinition: # now we have list of names: state1, state2, event, event handler tok = line.split(',') # no enought tokens (empty line?) if len(tok) < 3: continue for i in range(len(tok)): tok[i] = tok[i].strip(' ') # adding nodes to graph if (not tok[0] in nodeSet): nodeSet.add(tok[0]) n = gv.node(self.dot, tok[0]) gv.setv(n, "shape", "Mrecord") if ((not tok[1] in nodeSet) and (tok[1] != "FSM_NO_STATE")): nodeSet.add(tok[1]) n = gv.node(self.dot, tok[1]) gv.setv(n, "shape", "Mrecord") if (tok[2] == "FSM_DEF_TR"): e = gv.edge(self.dot, tok[0], tok[1]) gv.setv(e, "label", "["+tok[3]+"] ") elif (tok[1] == "FSM_NO_STATE"): e = gv.edge(self.dot, tok[0], tok[0]) gv.setv(e, "label", tok[2]+"["+tok[3]+"] ") gv.setv(e, "arrowhead", "tee") else: e = gv.edge(self.dot, tok[0], tok[1]) gv.setv(e, "label", tok[2]+"["+tok[3]+"] ")
def graph_from_fsa(fsa): g = gv.digraph('graph') gv.setv(g, 'rankdir', 'LR') for st in fsa.states(): n = gv.node(g, str(st)) gv.setv(n, 'label', str(st)) gv.setv(n, 'shape', ('double' if st in fsa.final_s else '') + 'circle') if (st == fsa.first_s): inv_n = gv.node(g, str(id([]))) gv.setv(inv_n, 'label', '') gv.setv(inv_n, 'style', 'invis') gv.setv(gv.edge(inv_n, n), 'color', 'gray51') for s1, s2, c in fsa.transitions(): e = gv.edge(g, str(s1), str(s2)) gv.setv(e, 'color', 'gray71') gv.setv(e, 'arrowsize', '0.7') if (c == '#'): c = u'\u03bb' gv.setv(e, 'fontcolor', 'goldenrod2') gv.setv(e, 'style', 'dashed') else: gv.setv(e, 'fontcolor', 'firebrick2') gv.setv(e, 'label', (' ' + c + ' ').encode('utf-8')) return g
def draw_outside(graph, index, search_files=None, draw_dir=None): if search_files is not None: draw_related_outside(graph, index, search_files, [], []) elif draw_dir is not None: draw_related_outside(graph, index, get_xsls_in_dir(draw_dir), [], []) else: for file_name, imported_by in index.iteritems(): gv.node(graph, '{0}'.format(file_name)) for imp in set(imported_by): gv.edge(graph, os.path.relpath(file_name, config.ROOT_XSL_DIR), os.path.relpath(imp, config.ROOT_XSL_DIR)) return graph
def draw_outside(self, graph, search_files=None, draw_dir=None, limit=None, squash=True): self.__squash = squash self.__limit = limit if search_files is not None: self.__draw_related_outside(graph, search_files) elif draw_dir is not None: self.__draw_related_outside(graph, get_xsls_in_dir(draw_dir)) else: for file_name, imported_by in self.index.iteritems(): gv.node(graph, file_name) for imp in set(imported_by): gv.edge(graph, self.get_relative_path(file_name), self.get_relative_path(imp)) return graph
def gv_layout(nodes,edges,mode="dot"): G = gv.graph("root") s = gv.graph(G,"test") for i in nodes: sg = "%02x %s"%(i,nodes[i][0]) n = gv.node(s,sg) if nodes[i][0] in gv_colors: gv.setv(n,"color",gv_colors[nodes[i][0]]) gv.setv(n,"style","filled") for i in edges: if i[0] in nodes and i[1] in nodes: e = gv.edge(G,"%02x %s"%(i[0],nodes[i[0]][0]),"%02x %s"%(i[1],nodes[i[1]][0])) gv.setv(e,"dir","none") gv.layout(G, mode) gv.render(G) # for debugging purposes gv.render(G,'svg','test.svg') devs = {} fn = gv.firstnode(G) try: devs[gv.nameof(fn)] = gv.getv(fn,"pos").split(",") except: print 'Failed in gv_render' for i in range(len(nodes)-1): fn = gv.nextnode(G,fn) devs[gv.nameof(fn)] = gv.getv(fn,"pos").split(",") return devs
def draw_tree(tree, graph, processed): for item, values in tree.iteritems(): for value in values: if not value: continue gv.edge(graph, item, value.keys()[0]) if item in processed: continue processed.append(item) gv.node(graph, item) for value in values: draw_tree(value, graph, processed)
def draw_edge(g, x1, x2, aDict): if x1 in aDict and x2 in aDict: n2 = aDict[x2] n1 = aDict[x1] e = gv.edge(g, n1, n2) gv.setv(e, "dir", "none") return e
def _add(self, handle, node="", edge="", subg="", **attrs): """ Adds items to parent graph (given by handle). Adds the item to parent Graphviz-item graph handle, sets item attributes as necessary and returns a Graphviz.<Type> instance. """ head, tail = '', '' if edge: head, tail = edge node, head, tail, subg = map(encode_page, [node, head, tail, subg]) self.changed = 1 if head and tail: item = gv.edge(handle, *(head, tail)) # print "gv.edge(g, '" + "', '".join(edge) + "')" graphvizitem = GraphvizEdge(self, item) elif node: item = gv.node(handle, node) # print "gv.node(g, '" + node + "')" graphvizitem = GraphvizNode(self, item) elif subg: # print "item = gv.graph(g, '%s')" % (subg) item = gv.graph(handle, subg) graphvizitem = GraphvizSubgraph(self, item) else: raise ValueError("No graph element type specified") self._setattrs(handle=item, **attrs) return graphvizitem
def gv_layout(nodes, edges, mode="dot"): G = gv.graph("root") s = gv.graph(G, "test") for i in nodes: sg = "%02x %s" % (i, nodes[i][0]) n = gv.node(s, sg) if nodes[i][0] in gv_colors: gv.setv(n, "color", gv_colors[nodes[i][0]]) gv.setv(n, "style", "filled") for i in edges: if i[0] in nodes and i[1] in nodes: e = gv.edge(G, "%02x %s" % (i[0], nodes[i[0]][0]), "%02x %s" % (i[1], nodes[i[1]][0])) gv.setv(e, "dir", "none") gv.layout(G, mode) gv.render(G) # for debugging purposes gv.render(G, 'svg', 'test.svg') devs = {} fn = gv.firstnode(G) try: devs[gv.nameof(fn)] = gv.getv(fn, "pos").split(",") except: print 'Failed in gv_render' for i in range(len(nodes) - 1): fn = gv.nextnode(G, fn) devs[gv.nameof(fn)] = gv.getv(fn, "pos").split(",") return devs
def __draw_related_outside(self, graph, search_files): for search_file in search_files: if search_file not in self.__drawn_nodes: gv.node(graph, self.get_relative_path(search_file)) self.__drawn_nodes.add(search_file) imported_by = self.index.get(search_file) if imported_by is None: continue imported_by = set(imported_by) squashed = get_squashed(imported_by, self.index) if len(imported_by) > 8 and self.__squash else [] squashed = squashed if len(squashed) > 6 else [] file_rel_path = self.get_relative_path(search_file) for imp in imported_by: if imp not in self.__drawn_nodes: self.__drawn_nodes.add(imp) if imp not in squashed: gv.node(graph, self.get_relative_path(imp)) if (imp, file_rel_path) not in self.__drawn_edges: self.__drawn_edges.add((imp, file)) if imp not in squashed: gv.edge(graph, self.get_relative_path(imp), file_rel_path) if squashed: name = '{} files importing {}'.format(len(squashed), file_rel_path) if name not in self.__drawn_nodes: self.__drawn_nodes.add(name) n = gv.node(graph, name) gv.setv(n, 'fontsize', '25') gv.setv(n, 'tooltip', '\n'.join(map(self.get_relative_path, squashed))) if (name, file_rel_path) not in self.__drawn_edges: self.__drawn_edges.add((name, file_rel_path)) gv.edge(graph, name, file_rel_path) self.__depth += 1 if self.__limit is None or self.__depth < self.__limit: self.__draw_related_outside(graph, imported_by)
def main(): # create a new empty graph G = gv.digraph('G') # define a simple graph ( A->B ) gv.edge(gv.node(G, 'A'), gv.node(G, 'B')) # compute a directed graph layout gv.layout(G, 'dot') # annotate the graph with the layout information gv.render(G) # do something with the layout n = gv.firstnode(G) while n: print 'node ' + gv.nameof(n) + ' is at ' + gv.getv(n, 'pos') e = gv.firstout(n) while e: print 'edge ' + gv.nameof(gv.tailof(e)) + '->' + gv.nameof( gv.headof(e)) + ' is at ' + gv.getv(e, 'pos') e = gv.nextout(n, e) n = gv.nextnode(G, n)
def draw_related_inside(graph, data, files, drawn_nodes, drawn_edges): for xsl_file in files: file_data = data.get(xsl_file) if file_data is None: continue if xsl_file not in drawn_nodes: gv.node(graph, '{0}'.format(os.path.relpath(xsl_file, config.ROOT_XSL_DIR))) drawn_nodes.append(xsl_file) imports = file_data.get('imports') if not imports: continue for xsl_import in imports: if (xsl_file, xsl_import) not in drawn_edges: gv.edge(graph, os.path.relpath(xsl_file, config.ROOT_XSL_DIR), os.path.relpath(xsl_import, config.ROOT_XSL_DIR)) drawn_edges.append((xsl_file, xsl_import)) draw_related_inside(graph, data, imports, drawn_nodes, drawn_edges)
def main(): # create a new empty graph G = gv.digraph("G") # define a simple graph ( A->B ) gv.edge(gv.node(G, "A"), gv.node(G, "B")) # compute a directed graph layout gv.layout(G, "dot") # annotate the graph with the layout information gv.render(G) # do something with the layout n = gv.firstnode(G) while n: print(f"node {gv.nameof(n)} is at {gv.getv(n, 'pos')}") e = gv.firstout(n) while e: print( f"edge {gv.nameof(gv.tailof(e))}->{gv.nameof(gv.headof(e))} is at {gv.getv(e, 'pos')}" ) e = gv.nextout(n, e) n = gv.nextnode(G, n)
def __draw_related_inside(self, graph, files): for xsl_file in files: file_data = self.data.get(xsl_file) if file_data is None: continue if xsl_file not in self.__drawn_nodes: gv.node(graph, '{0}'.format(self.get_relative_path(xsl_file))) self.__drawn_nodes.add(xsl_file) imports = file_data.get('imports') if not imports: continue for xsl_import in imports: if (xsl_file, xsl_import) not in self.__drawn_edges: gv.edge(graph, self.get_relative_path(xsl_file), self.get_relative_path(xsl_import)) self.__drawn_edges.add((xsl_file, xsl_import)) self.__draw_related_inside(graph, imports)
def draw_related_outside(graph, index, search_files, drawn_nodes, drawn_edges): for search_file in search_files: imported_by = index.get(search_file) if imported_by is None: continue if search_file not in drawn_nodes: gv.node(graph, '{0}'.format(os.path.relpath(search_file, config.ROOT_XSL_DIR))) drawn_nodes.append(search_file) imported_by = set(imported_by) for imp in imported_by: if imp not in drawn_nodes: gv.node(graph, '{0}'.format(os.path.relpath(imp, config.ROOT_XSL_DIR))) drawn_nodes.append(imp) if (imp, file) not in drawn_edges: gv.edge(graph, os.path.relpath(imp, config.ROOT_XSL_DIR), os.path.relpath(search_file, config.ROOT_XSL_DIR)) drawn_edges.append((imp,file)) draw_related_outside(graph, index, imported_by, drawn_nodes, drawn_edges)
def __graphviz_tree(tree, names, graph, curr_node_handle): for node in tree.nodes: if node.attribute: label = names[node.attribute][0] else: label = names[0][node.node_class] edge_label = names[tree.attribute][node.value] gv_child = gv.node(graph, label + str(id(node))) gv.setv(gv_child, "label", label) gv_edge = gv.edge(curr_node_handle, gv_child) gv.setv(gv_edge, "label", edge_label) __graphviz_tree(node, names, graph, gv_child)
def visit(node, graph, subgraph): if isinstance(node, Rule): gnode = gv.node(graph, str(id(node))) stylize_rule(gnode, node) for n in node.childs: visit(n, graph, subgraph) e = gv.edge(graph, str(id(node)), str(id(n))) stylize_edge(e) else: # Token gnode = gv.node(subgraph, str(id(node))) stylize_token(gnode, node)
def draw_note(g): global aColor gv.graph(g, "cluster_0") g1 = gv.findsubg(g, "cluster_0") gv.setv(g1, "color", "white") aNodes = [] length = 0 for key in aColor: c = aColor[key] n = gv.node(g1, key) gv.setv(n, "shape", "box") gv.setv(n, "style", "filled") gv.setv(n, "color", c) gv.setv(n, "label", key) aNodes.append(key) length = length + 1 for i in range(0, length - 1): e = gv.edge(g1, aNodes[i], aNodes[i + 1]) gv.setv(e, "style", "invis")
def draw_note(g): global aColor gv.graph(g, "cluster_0") g1 = gv.findsubg(g, "cluster_0") gv.setv(g1, "color", "white") aNodes = [] length = 0 for key in aColor: c = aColor[key] n = gv.node(g1, key) gv.setv(n, "shape", "box") gv.setv(n, "style", "filled") gv.setv(n, "color", c) gv.setv(n, "label", key) aNodes.append(key) length = length +1 for i in range(0, length-1): e = gv.edge(g1, aNodes[i], aNodes[i+1]) gv.setv(e, "style", "invis")
def layout_graph(edges): """ Take a description of the connectivity of a graph and return a representation of that graph in 2D cartesian space. Input: `edges` An iterable over pairs of 'node_id's that are connected. A 'node_id' is an arbitrary object in this context, with the only restriction that it's uniquely identified by its string representation, that is: (str(node1) == str(node2)) implies (node1 == node2). Output: An iterable yielding triples of the form (`id`, `x`, `y`) where `id` is the string representation of the node_id that this vertex represents, and `x`, `y` are the string representations of the cartesian coordinates of said vertex. It is a bit dirty to return strings rather than the values themselves, but these are meant to be written out to a file anyway, so I'm avoiding redundant conversions. Only the vertices that are connected to some other vertex are listed here (i.e. don't provide vertices linked to themselves), and the vertex order is arbitrary. Nothing should be assumed about the coordinate system in which these vertices are described. Neither scale nor origin are defined. You may need to normalize them and rescale them if you have specific requirements in this regard. `edges` An iterable yielding pairs of the form (`id_a`, `id_b`) where `id_a`, `id_b` are the string representations of the `node_id` of the endpoints of this edge. Not coincidentially, this is the data expected in the graph description referred to in searchview.py '*.history' description files. """ print "Adding edges to graphviz..." graph = gv.strictgraph("graph") for a, b in edges: gv.edge(graph, str(a), str(b)) print "Laying out..." gv.layout(graph, "sfdp") print "Rendering..." gv.render(graph) print "Creating vertices..." vertex_names = set(imap(str, ichain(edges))) return (tuple([name] + gv.getv(gv.findnode(graph, name), "pos").split(",")) for name in vertex_names)
#!/usr/bin/python import gv g = gv.digraph("G") n = gv.node(g, "hello") m = gv.node(g, "world") e = gv.edge(n, m) gv.layout(g, "dot") gv.render(g, "png", "gv_test.png") gv.rm(g)
s2 = m1.group(3) m2 = r2.match(s2) s2_name = m2.group(1) s2_cont = filter_cont(m2.group(2)) if not s2_cont in ls: ls.append(s2_cont) ds[s2_name] = s2_cont t = m1.group(2) lt.append((s1_cont, s2_cont, t)) G = gv.graph("G") N = gv.protonode(G) E = gv.protoedge(G) gv.setv(N, 'shape', 'box') dNodes = {} for node in ls: name = node dNodes[name] = gv.node(G, name) for k in lt: edge = gv.edge(dNodes[k[0]], dNodes[k[1]]) gv.setv(edge, 'label', k[2]) gv.setv(edge, 'dir', "forward") gv.layout(G, 'dot') #gv.render(G, 'xlib') gv.render(G, 'pdf', sys.argv[2])
def link_roles(self, dependent_role, depended_role): gv.edge(self._role_nodes[dependent_role], self._role_nodes[depended_role])
# based on: modgraph.tcl by John Ellson <*****@*****.**> import sys import gv modules = open("/proc/modules", 'r').readlines() G = gv.digraph("G") N = gv.protonode(G) E = gv.protoedge(G) gv.setv(G, 'rankdir', 'LR') gv.setv(G, 'nodesep', '0.05') gv.setv(N, 'shape', 'box') gv.setv(N, 'width', '0') gv.setv(N, 'height', '0') gv.setv(N, 'margin', '.03') gv.setv(N, 'fontsize', '8') gv.setv(N, 'fontname', 'helvetica') gv.setv(E, 'arrowsize', '.4') for rec in modules: fields = rec.split(' ') n = gv.node(G, fields[0]) for usedby in fields[3].split(','): if (usedby != '-') & (usedby != ''): gv.edge(n, gv.node(G, usedby)) gv.layout(G, 'dot') gv.render(G, 'xlib')
def connectLockPid(self, _type, _lock, _pid): import gv _edge = gv.edge(_lock, _pid) self.setEdgeAttrs(_edge, self.CONNECTION_ATTRS, _type) return _edge
based on: modgraph.tcl by John Ellson <*****@*****.**> """ import gv # pylint: disable=import-error modules = open("/proc/modules", "r").readlines() G = gv.digraph("G") N = gv.protonode(G) E = gv.protoedge(G) gv.setv(G, "rankdir", "LR") gv.setv(G, "nodesep", "0.05") gv.setv(N, "shape", "box") gv.setv(N, "width", "0") gv.setv(N, "height", "0") gv.setv(N, "margin", ".03") gv.setv(N, "fontsize", "8") gv.setv(N, "fontname", "helvetica") gv.setv(E, "arrowsize", ".4") for rec in modules: fields = rec.split(" ") n = gv.node(G, fields[0]) for usedby in fields[3].split(","): if usedby not in ("-", ""): gv.edge(n, gv.node(G, usedby)) gv.layout(G, "dot") gv.render(G, "xlib")
def GetGVData(names,map,contents=None,type="xdot",node_shape='record',debug=0,output_graphic_filename=None,aliases=None): large_mode=False if len(names)>800: large_mode=True if not aliases: aliases={} if not node_shape: node_shape="record" if not contents: contents={} root_name="Root" if len(names)>0: root_name=str(names[0]) g=gv.digraph(root_name) layout_alrogithm='dot' node_color=None if large_mode: node_shape='point' gv.setv(g,"model","subset") layout_alrogithm='neato' layout_alrogithm='twopi' node_color='red' debug=1 gv.setYinvert(g) name2node={} edges=[] method='plain' for name in names: if aliases.has_key(name): display_name=str(aliases[name]) else: display_name=str(name) if method=='plain': node_str='' if contents.has_key(name): for i in range(0,len(contents[name]),1): [address,op,[op1,op2],comment]=contents[name][i] node_str+=str(op) if op1: node_str+=" "+str(op1) if op2: node_str+=" "+str(op2) node_str+='\r\n' display_name="{"+display_name+"|"+node_str+"}" node=gv.node(g,display_name) name2node[name]=node gv.setv(node,"shape",node_shape) if node_color: gv.setv(node,"color",node_color) elif method=='layered': #dirty look node_str='' if contents.has_key(name): for i in range(0,len(contents[name]),1): [address,op,[op1,op2],comment]=contents[name][i] node_str+="|{"+MakeLenStr(str(op),5) if op1: node_str+="|"+MakeLenStr(str(op1),5) if op2: node_str+="|"+MakeLenStr(str(op2),5) node_str+='}' node=gv.node(g,"{"+display_name+node_str+"}") name2node[name]=node gv.setv(node,"shape","record") elif method=='subgraph': #Too big subg=gv.graph(g,'cluster'+display_name) gv.setv(subg,"label",display_name) gv.setv(subg,"color","black") node=gv.node(subg,display_name) name2node[name]=node nodes.append(node) gv.setv(node,"shape","record") node_str='' if contents.has_key(name): src=node for i in range(0,len(contents[name]),1): [address,op,[op1,op2],comment]=contents[name][i] node_str=hex(address)+"|"+str(op) if op1: node_str+="|"+str(op1) if op2: node_str+="|"+str(op2) node=gv.node(subg,node_str) nodes.append(node) gv.setv(node,"shape","record") #edge=gv.edge(src,node) src=node for name in names: if map.has_key(name): for dst_name in map[name]: if name2node.has_key(name) and name2node.has_key(dst_name): edge=gv.edge(name2node[name],name2node[dst_name]) gv.setv(edge,"invis","") edges.append([name,dst_name,edge]) if debug: print 'Start layout' start_time=time.time() gv.layout(g,layout_alrogithm) if debug: end_time=time.time() elapsed_time=end_time-start_time print 'End layout',end_time-start_time prefix='' for i in range(0,5,1): prefix+=hex(random.randint(0,9999)) gv.render(g,type,".temp.dat") if debug: img_filename=prefix+".jpg" dot_filename=prefix+".dot" print 'writing',img_filename gv.render(g,"jpg",img_filename) #For debugging gv.render(g,"dot",dot_filename) #For debugging print 'done writing',img_filename if output_graphic_filename: gv.render(g,"jpg",output_graphic_filename) #For debugging node_attrs_map={} edge_attrs_maps={} for name in name2node.keys(): node_attrs=GetAttrs(name2node[name]) node_attrs_map[name]=node_attrs for [src,dst,edge] in edges: line_attrs=GetAttrs(edge) if not edge_attrs_maps.has_key(src): edge_attrs_maps[src]={} edge_attrs_maps[src][dst]=line_attrs ###### Get maxx,maxy maxx=0 maxy=0 graph_attrs=GetAttrs(g) if graph_attrs.has_key('bb'): [x1str,y1str,x2str,y2str]=re.compile(",").split(graph_attrs['bb']) x1=int(x1str) y1=int(y1str) x2=int(x2str) y2=int(y2str) maxx=x1 if x2>maxx: maxx=x2 maxy=y1 if y2>maxy: maxy=y2 maxx+=200 maxy+=200 return [[maxx,maxy],node_attrs_map,edge_attrs_maps] #################### End of Graphviz processor ################### ##################################################################
def add_edge(self, node1, node2, value): length = self.minlen + pow((self.maxv - value), 2) * self.dx e = gv.edge(self.gr, node1, node2) gv.setv(e, 'len', str(length)) gv.setv(e, 'label', str(value)) return
def link_roles(self, dependent_role, depended_role): gv.edge( self._role_nodes[dependent_role], self._role_nodes[depended_role] )
#!/usr/bin/python import sys import gv # create a new empty graph G = gv.digraph('G') # define a simple graph ( A->B ) gv.edge(gv.node(G, 'A'), gv.node(G, 'B')) # compute a directed graph layout gv.layout(G, 'dot') # annotate the graph with the layout information gv.render(G) # do something with the layout n = gv.firstnode(G) while n: print 'node ' + gv.nameof(n) + ' is at ' + gv.getv(n, 'pos') e = gv.firstout(n) while e: print 'edge ' + gv.nameof(gv.tailof(e)) + '->' + gv.nameof( gv.headof(e)) + ' is at ' + gv.getv(e, 'pos') e = gv.nextout(n, e) n = gv.nextnode(G, n)
def graph_draw(g, pos=None, size=(15, 15), pin=False, layout="neato", maxiter=None, ratio="fill", overlap=False, splines=False, mode="major", vsize=0.1, penwidth=1.0, eweight=None, ewidth=None, gprops={}, vprops={}, eprops={}, vcolor=None, ecolor=None, vcmap=matplotlib.cm.jet, vnorm=True, ecmap=matplotlib.cm.jet, enorm=True, output="", output_format="auto", returngv=False, fork=False, seed=0): """Draw a graph using graphviz.""" if output != "": output = os.path.expanduser(output) # check opening file for writing, since graphview will bork if it is not # possible to open file if os.path.dirname(output) != "" and \ not os.access(os.path.dirname(output), os.W_OK): raise IOError("cannot write to " + os.path.dirname(output)) if g.is_directed(): gvg = gv.digraph("G") else: gvg = gv.graph("G") # main graph properties gv.setv(gvg, "outputorder", "edgesfirst") gv.setv(gvg, "mode", mode) if overlap == False: if layout == "neato" and mode == "ipsep": overlap = "ipsep" else: overlap = "false" else: overlap = "true" if isinstance(overlap, str): gv.setv(gvg, "overlap", overlap) if splines: gv.setv(gvg, "splines", "true") gv.setv(gvg, "ratio", str(ratio)) gv.setv(gvg, "size", "%f,%f" % (size[0] / 2.54, size[1] / 2.54)) # centimeters if maxiter != None: gv.setv(gvg, "maxiter", str(maxiter)) if seed != 0: if type(seed) == int: gv.setv(gvg, "start", "%d" % seed) else: gv.setv(gvg, "start", seed) # apply all user supplied properties for k, val in gprops.iteritems(): if isinstance(val, PropertyMap): gv.setv(gvg, k, str(val[g])) else: gv.setv(gvg, k, str(val)) # normalize color properties if vcolor != None and not isinstance(vcolor, str): minmax = [float("inf"), -float("inf")] for v in g.vertices(): c = vcolor[v] minmax[0] = min(c, minmax[0]) minmax[1] = max(c, minmax[1]) if minmax[0] == minmax[1]: minmax[1] += 1 if vnorm: vnorm = matplotlib.colors.normalize(vmin=minmax[0], vmax=minmax[1]) if ecolor != None and not isinstance(ecolor, str): minmax = [float("inf"), -float("inf")] for e in g.edges(): c = ecolor[e] minmax[0] = min(c, minmax[0]) minmax[1] = max(c, minmax[1]) if minmax[0] == minmax[1]: minmax[1] += 1 if enorm: enorm = matplotlib.colors.normalize(vmin=minmax[0], vmax=minmax[1]) nodes = [] edges = [] # add nodes for v in g.vertices(): n = gv.node(gvg, str(g.vertex_index[v])) if type(vsize) != tuple: vw = vh = vsize else: vw, vh = vsize if type(vw) == PropertyMap: vw = vw[v] if type(vh) == PropertyMap: vh = vh[v] if type(vw) == str and vw == "in": vw = v.in_degree() if type(vw) == str and vw == "out": vw = v.out_degree() if type(vw) == str and vw == "total": vw = v.in_degree() + v.out_degree() if type(vh) == str and vh == "in": vh = v.in_degree() if type(vh) == str and vh == "out": vh = v.out_degree() if type(vh) == str and vh == "total": vh = v.in_degree() + v.out_degree() gv.setv(n, "width", "%g" % vw) gv.setv(n, "height", "%g" % vh) gv.setv(n, "style", "filled") gv.setv(n, "color", "black") # apply color if vcolor != None: if isinstance(vcolor, str): gv.setv(n, "fillcolor", vcolor) else: color = tuple( [int(c * 255.0) for c in vcmap(vnorm(vcolor[v]))]) gv.setv(n, "fillcolor", "#%.2x%.2x%.2x%.2x" % color) else: gv.setv(n, "fillcolor", "red") gv.setv(n, "label", "") # user supplied position if pos != None: gv.setv(n, "pos", "%f,%f" % (pos[0][v], pos[1][v])) gv.setv(n, "pin", str(pin)) # apply all user supplied properties for k, val in vprops.iteritems(): if isinstance(val, PropertyMap): gv.setv(n, k, str(val[v])) else: gv.setv(n, k, str(val)) nodes.append(n) for e in g.edges(): ge = gv.edge(nodes[g.vertex_index[e.source()]], nodes[g.vertex_index[e.target()]]) gv.setv(ge, "arrowsize", "0.3") if g.is_directed(): gv.setv(ge, "arrowhead", "vee") # apply color if ecolor != None: if isinstance(ecolor, str): gv.setv(ge, "color", ecolor) else: color = tuple( [int(c * 255.0) for c in ecmap(enorm(ecolor[e]))]) gv.setv(ge, "color", "#%.2x%.2x%.2x%.2x" % color) # apply weight if eweight != None: if isinstance(eweight, PropertyMap): gv.setv(ge, "weight", str(eweight[e])) else: gv.setv(ge, "weight", str(eweight)) # apply width if ewidth != None: if isinstance(ewidth, PropertyMap): gv.setv(ge, "penwidth", str(ewidth[e])) else: gv.setv(ge, "penwidth", str(ewidth)) # apply all user supplied properties for k, v in eprops.iteritems(): if isinstance(v, PropertyMap): gv.setv(ge, k, str(v[e])) else: gv.setv(ge, k, str(v)) edges.append(ge) gv.layout(gvg, layout) gv.render(gvg, "dot", "/dev/null") # retrieve postitions if pos == None: pos = (g.new_vertex_property("double"), g.new_vertex_property("double")) for n in xrange(0, len(nodes)): p = gv.getv(nodes[n], "pos") p = p.split(",") pos[0][g.vertex(n)] = float(p[0]) pos[1][g.vertex(n)] = float(p[1]) if output_format == "auto": if output == "": output_format = "xlib" else: output_format = output.split(".")[-1] # if using xlib we need to fork the process, otherwise good ol' graphviz # will call exit() when the window is closed if output_format == "xlib" or fork: pid = os.fork() if pid == 0: gv.render(gvg, output_format, output) os._exit(0) # since we forked, it's good to be sure if output_format != "xlib": os.wait() else: gv.render(gvg, output_format, output) if returngv: return pos, gv else: gv.rm(gvg) del gvg return pos
#!/usr/bin/python import gv g = gv.digraph("G") print gv.setv(g,"aaa","xxx") print gv.getv(g,"aaa") n = gv.node(g,"hello") print gv.getv(n,"label") print gv.setv(n,"aaa","xxx") print gv.getv(n,"aaa") m = gv.node(g,"world") print gv.getv(m,"aaa") e = gv.edge(n,m) print gv.setv(e,"aaa","xxx") print gv.getv(e,"aaa") gv.rm(e) gv.rm(m) gv.rm(n) gv.rm(g) g = gv.readstring("digraph G {a->b}") gv.rm(g) g = gv.read("hello.gv") gv.layout(g, "dot") gv.render(g, "png", "hello.png") gv.rm(g)
#!/usr/bin/python import sys import gv # create a new empty graph G = gv.digraph('G') # define a simple graph ( A->B ) gv.edge(gv.node(G, 'A'),gv.node(G, 'B')) # compute a directed graph layout gv.layout(G, 'dot') # annotate the graph with the layout information gv.render(G) # do something with the layout n = gv.firstnode(G) while n : print 'node '+gv.nameof(n)+' is at '+gv.getv(n,'pos') e = gv.firstout(n) while e : print 'edge '+gv.nameof(gv.tailof(e))+'->'+gv.nameof(gv.headof(e))+' is at '+gv.getv(e,'pos') e = gv.nextout(n,e) n = gv.nextnode(G,n)
def add_edge(self,a,b): nodea = gv.node(self.G, a.string()) gv.setv(nodea, "label", "%s|%d" % (a.string(), a.weight)) nodeb = gv.node(self.G, b.string()) gv.setv(nodeb, "label", "%s|%d" % (b.string(), b.weight)) gv.edge(nodea, nodeb)
def connectLockPid(self, _type, _lock, _pid): import gv _edge=gv.edge(_lock, _pid) self.setEdgeAttrs(_edge, self.CONNECTION_ATTRS, _type) return _edge
def _add_empty_edge(self, jump): edge = gv.edge(self.nodes[jump.state_from], self.nodes[jump.state_to]) gv.setv(edge, 'headport', jump.state_to.encode('utf-8')) gv.setv(edge, 'tailport', jump.state_from.encode('utf-8')) gv.setv(edge, 'weight', '20') gv.setv(edge, 'minlen', '1')
def graph_draw(g, pos=None, size=(15,15), pin=False, layout="neato", maxiter=None, ratio="fill", overlap=False, splines=False, mode="major", vsize=0.1, penwidth=1.0, eweight=None, ewidth=None, gprops={}, vprops={}, eprops={}, vcolor=None, ecolor=None, vcmap=matplotlib.cm.jet, vnorm=True, ecmap=matplotlib.cm.jet, enorm=True, output="", output_format="auto", returngv=False, fork=False, seed=0): """Draw a graph using graphviz.""" if output != "": output = os.path.expanduser(output) # check opening file for writing, since graphview will bork if it is not # possible to open file if os.path.dirname(output) != "" and \ not os.access(os.path.dirname(output), os.W_OK): raise IOError("cannot write to " + os.path.dirname(output)) if g.is_directed(): gvg = gv.digraph("G") else: gvg = gv.graph("G") # main graph properties gv.setv(gvg,"outputorder", "edgesfirst") gv.setv(gvg,"mode", mode) if overlap == False: if layout == "neato" and mode == "ipsep": overlap = "ipsep" else: overlap = "false" else: overlap = "true" if isinstance(overlap,str): gv.setv(gvg,"overlap", overlap) if splines: gv.setv(gvg,"splines", "true") gv.setv(gvg,"ratio", str(ratio)) gv.setv(gvg,"size", "%f,%f" % (size[0]/2.54,size[1]/2.54)) # centimeters if maxiter != None: gv.setv(gvg,"maxiter", str(maxiter)) if seed != 0: if type(seed) == int: gv.setv(gvg, "start", "%d" % seed) else: gv.setv(gvg, "start", seed) # apply all user supplied properties for k,val in gprops.iteritems(): if isinstance(val, PropertyMap): gv.setv(gvg, k, str(val[g])) else: gv.setv(gvg, k, str(val)) # normalize color properties if vcolor != None and not isinstance(vcolor, str): minmax = [float("inf"), -float("inf")] for v in g.vertices(): c = vcolor[v] minmax[0] = min(c,minmax[0]) minmax[1] = max(c,minmax[1]) if minmax[0] == minmax[1]: minmax[1] += 1 if vnorm: vnorm = matplotlib.colors.normalize(vmin=minmax[0], vmax=minmax[1]) if ecolor != None and not isinstance(ecolor, str): minmax = [float("inf"), -float("inf")] for e in g.edges(): c = ecolor[e] minmax[0] = min(c,minmax[0]) minmax[1] = max(c,minmax[1]) if minmax[0] == minmax[1]: minmax[1] += 1 if enorm: enorm = matplotlib.colors.normalize(vmin=minmax[0], vmax=minmax[1]) nodes = [] edges = [] # add nodes for v in g.vertices(): n = gv.node(gvg,str(g.vertex_index[v])) if type(vsize) != tuple: vw = vh = vsize else: vw, vh = vsize if type(vw) == PropertyMap: vw = vw[v] if type(vh) == PropertyMap: vh = vh[v] if type(vw) == str and vw == "in": vw = v.in_degree() if type(vw) == str and vw == "out": vw = v.out_degree() if type(vw) == str and vw == "total": vw = v.in_degree() + v.out_degree() if type(vh) == str and vh == "in": vh = v.in_degree() if type(vh) == str and vh == "out": vh = v.out_degree() if type(vh) == str and vh == "total": vh = v.in_degree() + v.out_degree() gv.setv(n, "width", "%g" % vw) gv.setv(n, "height", "%g" % vh) gv.setv(n, "style", "filled") gv.setv(n, "color", "black") # apply color if vcolor != None: if isinstance(vcolor,str): gv.setv(n, "fillcolor", vcolor) else: color = tuple([int(c*255.0) for c in vcmap(vnorm(vcolor[v]))]) gv.setv(n, "fillcolor", "#%.2x%.2x%.2x%.2x" % color) else: gv.setv(n, "fillcolor", "red") gv.setv(n, "label", "") # user supplied position if pos != None: gv.setv(n, "pos", "%f,%f" % (pos[0][v],pos[1][v])) gv.setv(n, "pin", str(pin)) # apply all user supplied properties for k,val in vprops.iteritems(): if isinstance(val, PropertyMap): gv.setv(n, k, str(val[v])) else: gv.setv(n, k, str(val)) nodes.append(n) for e in g.edges(): ge = gv.edge(nodes[g.vertex_index[e.source()]], nodes[g.vertex_index[e.target()]]) gv.setv(ge, "arrowsize", "0.3") if g.is_directed(): gv.setv(ge, "arrowhead", "vee") # apply color if ecolor != None: if isinstance(ecolor,str): gv.setv(ge, "color", ecolor) else: color = tuple([int(c*255.0) for c in ecmap(enorm(ecolor[e]))]) gv.setv(ge, "color", "#%.2x%.2x%.2x%.2x" % color) # apply weight if eweight != None: if isinstance(eweight, PropertyMap): gv.setv(ge, "weight", str(eweight[e])) else: gv.setv(ge, "weight", str(eweight)) # apply width if ewidth != None: if isinstance(ewidth, PropertyMap): gv.setv(ge, "penwidth", str(ewidth[e])) else: gv.setv(ge, "penwidth", str(ewidth)) # apply all user supplied properties for k,v in eprops.iteritems(): if isinstance(v, PropertyMap): gv.setv(ge, k, str(v[e])) else: gv.setv(ge, k, str(v)) edges.append(ge) gv.layout(gvg, layout) gv.render(gvg, "dot", "/dev/null") # retrieve postitions if pos == None: pos = (g.new_vertex_property("double"), g.new_vertex_property("double")) for n in xrange(0, len(nodes)): p = gv.getv(nodes[n], "pos") p = p.split(",") pos[0][g.vertex(n)] = float(p[0]) pos[1][g.vertex(n)] = float(p[1]) if output_format == "auto": if output == "": output_format = "xlib" else: output_format = output.split(".")[-1] # if using xlib we need to fork the process, otherwise good ol' graphviz # will call exit() when the window is closed if output_format == "xlib" or fork: pid = os.fork() if pid == 0: gv.render(gvg, output_format, output) os._exit(0) # since we forked, it's good to be sure if output_format != "xlib": os.wait() else: gv.render(gvg, output_format, output) if returngv: return pos, gv else: gv.rm(gvg) del gvg return pos
#!/usr/bin/env python3 import gv # pylint: disable=import-error # create a new empty graph G = gv.digraph("G") # define a simple graph ( A->B ) gv.edge(gv.node(G, "A"), gv.node(G, "B")) # compute a directed graph layout gv.layout(G, "dot") # annotate the graph with the layout information gv.render(G, "ps")