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 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(self, graph, nodes, nesting): subgraph = gv.graph(graph, self.uid.encode('utf-8')) gv.setv(subgraph, 'label', self.uid.encode('utf-8')) # gv.setv(subgraph, 'rank', 'same') gv.setv(subgraph, 'shape', 'box') gv.setv(subgraph, 'bgcolor', self.color % (150+nesting*25) if '%' in self.color else self.color) for node_uid in self.members: if node_uid in nodes: gv.node(subgraph, node_uid.encode('utf-8')) for child in self.children: child.draw(subgraph, nodes, nesting=nesting+1)
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 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 _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 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 _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 render_graphviz(filename, tree, names): gv_graph = gv.digraph("ID3") gv_root = gv.node(gv_graph, names[tree.attribute][0]) gv_tree = __graphviz_tree(tree, names, gv_graph, gv_root) gv.layout(gv_graph, "dot") return gv.render(gv_graph, "png", filename)
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 add_node(self, fact): node = gv.node(self.graph, fact.uid.encode('utf-8')) gv.setv(node, 'shape', 'plaintext') gv.setv(node, 'label', self.create_label_for(fact).encode('utf-8')) gv.setv(node, 'fontsize', '10') self.nodes[fact.uid] = node return node
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 out_graph(self): if self.depth > 1: self.generate_graph(1,0) else: first_node = self.get_node(1,0) n = gv.node(self.G, first_node.string()) gv.setv(n, "label", "%s|%d" % (first_node.string(), first_node.weight)) gv.layout(self.G, 'dot') #gv.render(self.G, 'xlib') gv.write(self.G, "tree.dot")
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 __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 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_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 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 draw_node(g, key, aName, aType): global aColor n = gv.node(g, aName) # set node show name gv.setv(n, "label", key) gv.setv(n, "style", "filled") gv.setv(n, "shape", "box") # if aType == "ovs": # gv.setv(n, "fixedsize", "true") # gv.setv(n, "width", "3") # elif aType == "br": # gv.setv(n, "fixedsize", "true") # gv.setv(n, "width", "3") # elif aType == "eth": # e = gv.edge(n, "swith") # gv.setv(e, "dir", "none") #if aType == "eth": # e = gv.edge(n, "swith") # gv.setv(e, "dir", "none") # gv.setv(e, "style", "dashed") if key == "br-int": gv.setv(n, "width", "10") # set color if aType in aColor: c = aColor[aType] else: c = "lightgrey" gv.setv(n, "color", c) return 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 add_role(self, role): if role not in self._role_nodes: self._role_nodes[role] = gv.node(self.graph, role)
def add_node(self, node_id, label): n = gv.node(self.gr, node_id) gv.setv(n, 'label', label) return
#!/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)
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
def createPidNode(self, _subtree): import gv _node = gv.node(self.graph, _subtree.owner) self.setNodeAttrs(_node, self.PID_NODE_ATTRS) return _node
#!/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")
graph = gv.digraph('filegraph') for dirpath, dirnames, filenames in os.walk('src'): try: subgraph = subgraphs[clean(dirpath)] except: subgraph = gv.graph(graph, 'cluster_' + clean(dirpath)) gv.setv(subgraph, 'label', dirpath) subgraphs[clean(dirpath)] = subgraph print clean(dirpath) print dirnames print filenames for filename in filenames: node = gv.node(subgraph, clean(filename)) gv.setv(node, 'label', filename) for dirname in dirnames: subgraphfun(subgraph, clean(os.path.join(dirpath,dirname)), dirname) gv.write(graph, 'graph.dot') os.system('dot -Tpdf -ograph.pdf graph.dot') #os.system('neato -Tpdf -ofilegraph.pdf filegraph.dot')
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 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
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")
#!/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)
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])
#!/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 createLockNode(self, _lock): import gv _node = gv.node(self.graph, _lock.getName()) self.setNodeAttrs(_node, self.LOCK_NODE_ATTRS) return _node
# 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')
#!/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)