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_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_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 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_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 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 _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
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/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")
