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