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(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_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 _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 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 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 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 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 add_node(self, node_id, label): n = gv.node(self.gr, node_id) gv.setv(n, 'label', label) return
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 add_role(self, role):
if role not in self._role_nodes:
self._role_nodes[role] = gv.node(self.graph, role)
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')
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 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)
