def plot_trail(trail):
graph = Digraph()
graph.attr('node', shape='box', fontsize='12', penwidth='1.0', color='#888888', style='rounded')
c = count()
def _make_graph(trail):
if isinstance(trail, Call):
# We need to make a node
node = str(c.next())
graph.node(node, format_args(trail))
for a in trail.args:
if isinstance(a, Call):
parent = _make_graph(a)
graph.edge(parent, node)
for v in trail.kwargs.values():
if isinstance(v, Call):
parent = _make_graph(v)
graph.edge(parent, node)
return node
_make_graph(trail)
return graph
def generate_dot(self, graph_input):
dot = Digraph("Traceable relationships",
comment="Traceable relationships")
dot.body.append("rankdir=LR")
dot.attr("graph", fontname="helvetica", fontsize="7.5")
dot.attr("node", fontname="helvetica", fontsize="7.5")
dot.attr("edge", fontname="helvetica", fontsize="7.5")
# Group traceables by their category.
categorized = {}
for traceable in graph_input.traceables:
category = traceable.attributes.get("category")
categorized.setdefault(category, []).append(traceable)
# Create subgraphs for each category so that its traceables lineup.
for category, traceables in categorized.items():
subgraph = Digraph(str(category))
subgraph.body.append("rank=same")
for traceable in traceables:
self.add_dot_traceable(subgraph, traceable)
dot.subgraph(subgraph)
# Add the relationships between traceables.
for relationship_info in graph_input.relationships:
traceable1, traceable2, relationship, direction = relationship_info
src = traceable1.tag if direction >= 0 else traceable2.tag
dst = traceable2.tag if direction >= 0 else traceable1.tag
reverse = self.storage.get_relationship_opposite(relationship)
dot.edge(src, dst, headlabel=reverse, taillabel=relationship,
labelfontsize="7.0", labelfontcolor="#999999")
return dot.source
def nlp44(sentence: str) -> None:
chunks = get_chunk_list(sentence)
G = Digraph(format='png')
G.attr('node', shape='circle')
for i, chunk in enumerate(chunks):
G.edge(chunk.join_morphs(), chunks[chunk.dst].join_morphs())
G.render('cabocha_tree')
return
class BrainGraph:
def __init__(self, brain, name='brain', typename='brain'):
self.graph = Digraph(typename, filename=name, format='png')
self.brain = brain
def add_node(self, node_id, node_type, text):
"""
Add node to graph
@param node_id: id of node
@param node_type: type of node
@param text: text to show inside node
"""
if node_type == 'Input':
self.graph.attr('node', shape='circle')
elif node_type == 'Oscillator':
self.graph.attr('node', shape='square')
self.graph.node(node_id, label=text)
def add_edge(self, source_id, desitnation_id, label):
"""
Add edge to graph
@param source_id: id of source node
@param destination_id: id of destination node
@param label: label of edge
"""
self.graph.edge(source_id, desitnation_id, label)
def save_graph(self):
"""
Save graph
"""
self.graph.render()
def brain_to_graph(self):
"""
Export complete brain to graph
"""
nodes = self.brain.nodes
params = self.brain.params
# belongs to TODO
duplicates = fnmatch.filter(nodes, 'node*-*')
for node in nodes:
# TODO REMOVE condition WHEN duplicated nodes bug is fixed -- duplicated nodes end in '-[0-9]+' or '-core[0-9]+' (node2-2, node2-core1)
if node not in duplicates:
node_id = nodes[node].id
text = node_id
if node_id in params:
param = params[node_id]
text += '\n Oscillator {0} \n period: {1} \n phase_offset: {2} \n amplitude: {3}'.format(
nodes[node].part_id, params[node_id].period, params[node_id].phase_offset, params[node_id].amplitude)
self.add_node(node_id, nodes[node].type, text)
for connection in self.brain.connections:
self.add_edge(str(connection.src), str(connection.dst), str(connection.weight))
def make_graph_visualization(graph, f_name, methods_hash):
dot = Digraph('Classes Graph')
dot.attr('node', shape='box')
for key in graph.keys():
methods_str = '()\n'.join([methods_hash[x]['name'] for x in graph[key]['members'].split(' ')
if x in methods_hash.keys()])
dot.node(key, label=graph[key]['name'] + '\n_______\n' + methods_str + '()')
for key in graph.keys():
if graph[key]['children'] == '': continue
for child in graph[key]['children'].split(' '):
dot.edge(key, child)
#print(dot.source)
dot.render(f_name, None, True)
def draw_causal_graph(result_order, result_matrix, observed_data_labels, output_name='graph', format='png'):
G = Digraph(format=format, engine='dot')
G.attr('node', shape='circle')
for label in observed_data_labels:
G.node(str(label), str(label))
for i in result_order:
for j in result_order:
if result_matrix[i][j] != 0:
G.edge(str(observed_data_labels[result_order[j]]), str(observed_data_labels[result_order[i]]), str(result_matrix[i][j]))
G.render(output_name)
return "{0}.{1}".format(output_name, format)
def plot(self, output_name="result", format="png", threshold=0.01, decimal=3):
graph = Digraph(format=format)
graph.attr("graph", layout="dot", splines="true", overlap="false")
graph.attr("node", shape="box")
for label in self.labels:
graph.node(label)
for i, m_i in enumerate(self.matrix):
for j, m_i_j in enumerate(m_i):
if np.abs(round(m_i_j, 3)) >= threshold:
graph.edge(self.labels[j],
self.labels[i],
str(round(m_i_j, decimal)))
graph.render(output_name, cleanup=True)
return graph
def visualize_it(self): #I'll give you somethin' to do
f = Digraph('finite_state_machine', filename='fsm.gv')
f.body.extend(['rankdir=LR', 'size="8,5"'])
f.attr('node', shape='circle')
#Iterate through each state
for key, state in self._states.items():
#Create a node for each state
f.node(str(state.get_state_id()), label=state.get_field("description"))
#Iterate over each transition in the state
if state != None:
for key, trans in state.get_transitions().items():
if trans != None:
print trans.get_end()
for condition in trans.get_conditions():
f.edge(str(state.get_state_id()), str(trans.to_dictionary()["end"]), label=str(condition))
f.view()
def draw_graph(centroid, graph):
g = Digraph(centroid, engine="sfdp")
g.attr("node", style="filled")
g.node(centroid, color="crimson")
for key in graph:
g.node(key, color=("burlywood2" if key is not centroid else "crimson"))
large_set = Queue()
large_set.put(centroid)
visited_from_graph = {}
while not large_set.empty():
key = large_set.get()
if key in graph and key not in visited_from_graph:
visited_from_graph[key] = True
for keyword in graph[key]:
g.edge(key, keyword, penwidth=str(float(graph[key][keyword]) / 50.0))
large_set.put(keyword)
g.view()
def plot(self, output_name="result", format="png", separate=False, decimal=3, threshold=0.01, integration=False):
if integration:
integration_matrix = self.matrixes.sum(axis=0)
graph = Digraph(format=format)
graph.attr("graph", layout="dot", splines="true", overlap="false")
graph.attr("node", shape="box")
for label in self.labels:
graph.node(label)
for i, m_i in enumerate(integration_matrix):
for j, m_i_j in enumerate(m_i):
if np.abs(round(m_i_j, decimal)) >= threshold:
graph.edge(self.labels[j],
self.labels[i],
str(round(m_i_j, decimal)))
graph.render(output_name, cleanup=True)
return graph
else:
def generate_random_color():
return "#{:X}{:X}{:X}".format(*[random.randint(0, 255) for i in range(3)])
graph = Digraph(format=format)
graph.attr("graph", layout="dot", splines="true", overlap="false")
graph.attr("node", shape="box")
legend = Digraph("cluster_legend")
legend.attr("graph", rankdir="LR")
legend.attr("node", style="invis")
lags = ["t"] + ["t_{}".format(i) for i in range(1, len(self.matrixes))]
for label in self.labels:
graph.node(label)
for lag, matrix in zip(lags, self.matrixes):
color = generate_random_color()
legend.edge("s_{}".format(lag),
"d_{}".format(lag),
lag,
color=color)
for i, m_i in enumerate(matrix):
for j, m_i_j in enumerate(m_i):
if round(np.abs(m_i_j), decimal) >= threshold:
graph.edge(self.labels[j],
self.labels[i],
str(round(m_i_j, decimal)),
color=color)
graph.subgraph(legend)
graph.render(output_name, cleanup=True)
return graph
def __init__(self, tree):
"""Construtor da classe DecisionTree"""
super(DecisionTree, self).__init__()
self.tree = tree
global dot
dot = Digraph(format='png')
dot.attr('node', shape='circle')
# Contador do node para gerar nos diferentes com o mesmo label
counter = 0
# Chama o metodo de criacao da arvore de decisao
self.build_tree(tree, counter)
# Renderiza a arvore de decisao
dot.render(view=False, cleanup=False)
def generate_dot(self, graph_input):
dot = Digraph("Traceable relationships",
comment="Traceable relationships")
dot.body.append("rankdir=LR")
dot.attr("graph", fontname="helvetica", fontsize="7.5")
dot.attr("node", fontname="helvetica", fontsize="7.5")
dot.attr("edge", fontname="helvetica", fontsize="7.5")
for traceable in graph_input.traceables:
self.add_dot_traceable(dot, traceable)
for relationship_info in graph_input.relationships:
traceable1, traceable2, relationship, direction = relationship_info
src = traceable1.tag if direction >= 0 else traceable2.tag
dst = traceable2.tag if direction >= 0 else traceable1.tag
reverse = self.storage.get_relationship_opposite(relationship)
dot.edge(src, dst, headlabel=reverse, taillabel=relationship,
labelfontsize="7.0", labelfontcolor="#999999")
return dot.source
def generate_graph(msgs, fn):
dot = Digraph()
dot.attr(rankdir="LR")
for m in msgs.values():
if m.typ == "start":
dot.node(m.name, shape="box", color="blue")
elif m.typ == "end":
dot.node(m.name, shape="box", color="green3")
elif m.typ == "auxstart":
dot.node(m.name, shape="diamond", color="blue")
elif m.typ == "auxend":
dot.node(m.name, shape="diamond", color="green3")
elif m.typ == "normal":
dot.node(m.name)
for m in msgs.values():
for n in m.next:
dot.edge(m.name, n)
dot.render(fn)
def create_dag(start, end, dictionary):
print "gets here"
f = Digraph(format='png')
f.body.extend(['rankdir=LR', 'size="8,5"'])
print "now here"
f.attr('node', shape='doublecircle')
f.node(start)
f.node(end)
f.attr('node', shape='circle')
for cur1 in dictionary.keys():
print cur1
# if cur1 != start and cur1 != end:
for cur2 in dictionary[cur1].keys():
# if cur2 != start and cur2 != end:
print f
f.edge(cur1, cur2, label=str(dictionary[cur1][cur2]))
# print "about to render"
f.render('static/img/dag')
def save(self, name):
g = Digraph('G', filename="{}.gv".format(name))#os.path.join(OUT, "graph.gv"))
g.attr('node', shape='circle')
for label in self.labels:
if label != "":
index = self.labels.index(label)
n_label = "{} ({})".format(label, self.nodes[index+1].weight)
g.node(n_label)
for (n1,n2),cov in self.edges.items():
n1_label = "{} ({})".format(self.labels[n1-1], self.nodes[n1].weight)
n2_label = "{} ({})".format(self.labels[n2-1], self.nodes[n2].weight)
g.edge(n1_label, n2_label, label=str(cov), color = "black")
for (n1,n2),cov in self.new_edges.items():
n1_label = "{} ({})".format(self.labels[n1-1], self.nodes[n1].weight)
n2_label = "{} ({})".format(self.labels[n2-1], self.nodes[n2].weight)
g.edge(n1_label, n2_label, label=str(cov), color = "red")
for (n1,n2),cov in self.fake_edges.items():
n1_label = "{} ({})".format(self.labels[n1-1], self.nodes[n1].weight)
n2_label = "{} ({})".format(self.labels[n2-1], self.nodes[n2].weight)
g.edge(n1_label, n2_label, label=str(cov), color = "black", style="dashed")
g.render()
def diagram(self):
from graphviz import Digraph
from queue import Queue
diagram=Digraph(comment='The Trie')
i=0
diagram.attr('node', shape='circle')
diagram.node(str(i), self.root.getValue())
q=Queue()
q.put((self.root, i))
while not q.empty():
node, parent_index=q.get()
for child in node.getChildren():
i+=1
if child.getEnding():
diagram.attr('node', shape='doublecircle')
diagram.node(str(i), child.getValue())
diagram.attr('node', shape='circle')
else:
diagram.node(str(i), child.getValue())
diagram.edge(str(parent_index), str(i))
q.put((child, i))
o=open('trie_dot.gv', 'w')
o.write(diagram.source)
o.close()
diagram.render('trie_dot.gv', view=True)
'trie_dot.gv.pdf'
def plotCss(css):
g_css = Digraph('structs', format='pdf',
filename=css['css_name'],
node_attr={'shape': 'record', 'height': '.1'})
g_css.attr(rankdir='LR')
css_line = ''
with g_css.subgraph(name='cluster0') as c:
c.graph_attr['rankdir'] = 'LR'
last = len(css['members']) - 1
for member in css['members']:
index = css['members'].index(member)
gv_line = ''
css_line += '<{0}> {0}|'.format(member['partition'])
for pattern in member['patterns']:
if pattern[0] == '\\':
gv_line += '\\{0}|'.format(pattern)
else:
gv_line += '{0}|'.format(pattern)
c.node(member['partition'], '<{0}> {0}| {1}'.format(
member['partition'], gv_line[:-1]))
if index < last:
nextitem = css['members'][index + 1]
c.edge(
'%s:%s' %
(member['partition'],
member['partition']),
'%s:%s' %
(nextitem['partition'],
nextitem['partition']))
return g_css
def draw(FA, adj, output):
newAlpha = list(FA[1])
if newAlpha[-1] == EPS:
newAlpha.pop();
sigma = ', '.join(newAlpha)
gr = Digraph();
gr.engine = 'dot'
gr.format = 'pdf'
gr.attr('node', style = 'invis');
gr.node('myStarting');
gr.attr('node', style = '', shape = 'doublecircle');
for u in FA[-1]:
gr.node(str(u));
gr.attr('node', shape = 'circle');
for u in FA[0]:
if u not in FA[-1]:
gr.node(str(u))
gr.edge('myStarting', str(FA[2]), 'Start');
for u, v in adj.keys():
if adj[u, v] == sigma:
gr.edge(str(u), str(v), 'Sigma')
else:
gr.edge(str(u), str(v), adj[u, v])
gr.render(output, view = True);
def display_tree(root,**kwargs):
max_depth = 5
dot = Digraph(comment='MCTS Tree')
fringe = [(None,0,root)]
while fringe:
(parent_hash,d,child) = fringe.pop()
child_str = str(child)
child_hash = str(hash(child))
if child.is_leaf():
dot.attr('node',shape='box',style='')
else:
dot.attr('node',shape='ellipse',style='')
dot.node(child_hash,child_str)
if parent_hash:
label = str(child.state)
dot.edge(parent_hash,
child_hash,
label=label)
# Add new nodes
for a_id in child.children:
if d < max_depth:
dot.attr('node',shape='diamond',style='filled')
child_aid_hash = child_hash + str(a_id)
dot.node(child_aid_hash,'')
else:
dot.attr('node',shape='box',style='filled')
child_aid_hash = child_hash + str(a_id)
dot.node(child_aid_hash,'...')
label = '{0},{1:0.2f},{2}'.format(a_id,
child.get_ucb(a_id),
child.costs[a_id])
dot.edge(child_hash,
child_aid_hash,
label=label)
if d < max_depth:
for gc in child.children[a_id]:
fringe.append((child_aid_hash,d+1,gc))
dot.format='png'
dot.render('data/test.gv')
img = mpimg.imread('data/test.gv.png')
plt.imshow(img)
plt.title(kwargs.get('title',''))
plt.show()
def print_graph(self):
dot = Digraph()
dot.attr('node', shape='circle')
dot.attr('node', style='filled')
dot.attr('node', fillcolor='white')
for key in self.nodelist.keys():
if key in self.path:
dot.attr('node', fillcolor='green')
node = dot.node(key)
dot.attr('node', fillcolor='white')
for key in self.edgelist.keys():
edges = self.edgelist[key]
dot.edge(key, edges[0].number)
dot.edge(key, edges[1].number)
print dot.source
dot.render('test-output/g.gv', view=True)
def create_graph(self):
g = Digraph('G')
g.body.append('ranksep=0.7; splines=ortho')
g.attr('node', shape='box')
# add people nodes
for generation, people_list in self.people_by_generation.iteritems():
_g = Digraph('generation_%s' % generation)
_g.attr('graph', rank='same')
for people in people_list:
if type(people) == Couple:
husband, wife = people.husband, people.wife
parent_id = people.get_id()
_g.node(parent_id, shape='point', height='0', color='invis')
_g.edge(husband, parent_id, dir='none', color='black:invis:black')
_g.edge(parent_id, wife, dir='none', color='black:invis:black')
elif type(people) == Children:
children = people.children
for i in xrange(len(children)):
_g.node(children[i])
g.subgraph(_g)
# add children edges
for generation, people_list in self.people_by_generation.iteritems():
_g = None
for people in [people for people in people_list if type(people) == Children]:
child_ids = people.get_ids()
children_id = people.get_id()
if _g is None:
_g = Digraph('children_%s' % '/'.join(child_ids))
_g.attr('graph', rank='same')
children = people.children
children_nodes = [children_id]
parent_id = people.parent.get_id()
if len(children) > 1:
_g.node(children_id, shape='point', height='0.01')
for i in xrange(len(children)):
_g.node(child_ids[i], shape='point', height='0.01')
g.edge(child_ids[i], children[i], dir='none')
children_nodes.append(child_ids[i])
for i in xrange(1, len(children_nodes)):
_g.edge(children_nodes[i-1], children_nodes[i], dir='none', constraint='false')
g.edge(parent_id, children_id, dir='none')
else:
g.edge(parent_id, children[0], dir='none')
if _g is not None:
g.subgraph(_g)
return g
def asGraph(self, computation_counter):
from graphviz import Digraph # @UnresolvedImport pylint: disable=F0401,I0021
graph = Digraph("cluster_%d" % computation_counter, comment = "Graph for %s" % self.getName())
graph.body.append("style=filled")
graph.body.append("color=lightgrey")
graph.body.append("label=Iteration_%d" % computation_counter)
def makeTraceNodeName(variable_trace):
return "%d/ %s %s %s" % (
computation_counter,
variable_trace.getVariable(),
variable_trace.getVersion(),
variable_trace.__class__.__name__
)
for function_body in self.active_functions:
constraint_collection = function_body.constraint_collection
for (_variable, _version), variable_trace in constraint_collection.getVariableTracesAll().items():
node = makeTraceNodeName(variable_trace)
previous = variable_trace.getPrevious()
if variable_trace.hasDefiniteUsages():
graph.attr("node", style = "filled", color = "blue")
elif variable_trace.hasPotentialUsages():
graph.attr("node", style = "filled", color = "yellow")
else:
graph.attr("node", style = "filled", color = "red")
graph.node(node)
if type(previous) is tuple:
for previous in previous:
graph.edge(makeTraceNodeName(previous), node)
elif previous is not None:
graph.edge(makeTraceNodeName(previous), node)
return graph
class Grafo:
def __init__(self, ruta):
self.ruta = ruta
self.s = Digraph('structs',
filename='grafo.dot',
node_attr={'shape': 'plaintext'})
self.s.attr(bgcolor='gray', fontcolor='white')
self.tree = ET.parse(ruta)
self.root = self.tree.getroot()
self.i_de_tabla = '''<<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">'''
self.f_de_tabla = '''</TABLE>>'''
self.i_de_fila = '<TR>'
self.f_de_fila = '</TR>'
self.i_de_columna = '<TD PORT="f0">'
self.f_de_columna = '</TD>'
# Va a retornar el numero de matrices que se pueden graficar
def cantidad_de_matrices(self):
tamano = 0
for i in range(len(self.root)):
tamano += 1
return tamano
# Muestra las matrices disponibles para graficar
def mostrar_matrices_disponibles(self):
tamano = 0
for i in range(len(self.root)):
print(" " + str(i + 1) + ". " + self.root[i].get("nombre"))
tamano += 1
return tamano
# Como lo que voy a mostrar las matrices del documento, y cada una de ellas se les asocio un numero
# cuando el usuario ingrese el numero, en realidad lo que esta mandando es la posicion de esa matriz dentro
# del arbol
def generar_grafo(self, opcion_grafo):
self.s.node(
'struct1', '''<
<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" PORT="f0"><TR>
<TD>MATRICES</TD>
</TR>
</TABLE>>''')
grafo = self.root[opcion_grafo]
nombre = self.i_de_fila + self.i_de_columna + grafo.get(
"nombre") + self.f_de_columna + self.f_de_fila
tabla = self.i_de_tabla + nombre + self.f_de_tabla
self.s.node('struct2', tabla)
n = self.i_de_fila + self.i_de_columna + "n = " + grafo.get(
"n") + self.f_de_columna + self.f_de_fila
tabla = self.i_de_tabla + "n = " + n + self.f_de_tabla
self.s.node('struct3', tabla)
m = self.i_de_fila + self.i_de_columna + "m = " + grafo.get(
"m") + self.f_de_columna + self.f_de_fila
tabla = self.i_de_tabla + m + self.f_de_tabla
self.s.node('struct4', tabla)
n = int(grafo.get("n"))
m = int(grafo.get("m"))
datos = grafo.findall("dato")
tabla = self.i_de_tabla
for i in range(n): # Recorriendo las filas
tabla += self.i_de_fila + "\n"
for j in range(m): # Recorreindo las columnas
for l in range(len(datos)):
x = int(datos[l].get("x"))
y = int(datos[l].get("y"))
if (x == (i + 1) and y == (j + 1)):
dato = datos[l].text
tabla += self.i_de_columna + dato + self.f_de_columna + "\n"
tabla += self.f_de_fila + "\n"
tabla += self.f_de_tabla + "\n"
#print("El formato es ", tabla)
self.s.node('struct5', tabla)
self.s.edges([
('struct1:f0', 'struct2:f0'), ('struct2:f0', 'struct3:f0'),
('struct2:f0', 'struct4:f0'), ('struct2:f0', 'struct5:f0')
])
#print("El nombre del filename es ", self.s.filename)
self.s.view()
archivo = render('dot', 'png', 'grafo.dot')
#print(archivo)
os.system(archivo)
# -*- coding: utf-8 -*-
#@note: conda activate my-rdkit-env
#@note: https://www.rdkit.org/docs/GettingStartedInPython.html#drawing-molecules
#@note: https://www.rdkit.org/docs/Install.html#how-to-install-rdkit-with-conda
from graphviz import Digraph
#dot = Digraph(comment='workflow', format="png")
dot = Digraph(comment='workflow', format="svg")
dot.attr('node', shape='box')
dot.node('A', '整个纳米体系')
dot.node('B', '(嵌入)\n 分子片段一')
dot.node('C', '(嵌入)\n 分子片段二')
dot.node('D', '(嵌入)\n 分子片段三')
dot.node('E', '分子力学力场模型')
dot.node('F', '杂化模型')
dot.edges(['AB', 'AC', 'AD', 'BE', 'CE', 'DE', 'EF'])
# 在创建两圆点之间创建一条边
#dot.edge('B', 'C', 'test')
# 保存source到文件，并提供Graphviz引擎
dot.save('test-table.gv') # 保存
dot.render('test-table.gv')
# dot.view() # 显示
# 从保存的文件读取并显示
def set_ranks(self):
pids = sorted(list(self.db.peoples.rows.keys()), reverse=False)
p0000 = Digraph(name='0000-')
p0000.attr(rank='same')
#p0000.body.append("rankdir=LR")
#p0000.attr(rankdir='LR')
p1000 = Digraph(name='1000-')
p1000.attr(rank='same')
#p1000.attr(sortv="1")
#p1000.body.append("rankdir=LR")
#p1000.attr(rankdir='LR')
p2000 = Digraph(name='2000-')
p2000.attr(rank='same')
#p2000.attr(sortv="2")
#p2000.body.append("rankdir=LR")
#p2000.attr(rankdir='LR')
p3000 = Digraph(name='3000-')
p3000.attr(rank='same')
#p3000.attr(sortv="3")
#p3000.body.append("rankdir=LR")
#p3000.attr(rankdir='LR')
p4000 = Digraph(name='4000-')
p4000.attr(rank='same')
#p4000.attr(sortv="1")
#p4000.body.append("rankdir=LR")
#p4000.attr(rankdir='LR')
p5000 = Digraph(name='5000-')
p5000.attr(rank='same')
#p5000.body.append("rankdir=LR")
#p5000.attr(sortv="1")
for pid in pids:
if pid > 0 and pid < 1000:
p0000.node(str(pid))
if pid >= 1000 and pid < 2000:
p1000.node(str(pid))
if pid >= 2000 and pid < 3000:
p2000.node(str(pid))
if pid >= 3000 and pid < 4000:
p3000.node(str(pid))
if pid >= 4000 and pid < 5000:
p4000.node(str(pid))
if pid >= 5000 and pid < 6000:
p5000.node(str(pid))
self.dot.subgraph(p0000)
self.dot.subgraph(p1000)
self.dot.subgraph(p2000)
self.dot.subgraph(p3000)
self.dot.subgraph(p4000)
self.dot.subgraph(p5000)
def plot_merge_class_arcs(arcs, class_to_idx, cfg, **kwargs):
""" make DAG plot and save to file_path as .png """
format = get_attr_kwargs(cfg, 'format', **kwargs)
file_path = get_attr_kwargs(cfg, 'file_path', **kwargs)
caption = get_attr_kwargs(cfg, 'caption', default=None, **kwargs)
n_cells = get_attr_kwargs(cfg, 'n_cells', **kwargs)
n_nodes_per_cell = get_attr_kwargs(cfg, 'n_nodes_per_cell', **kwargs)
conv1x1_label = get_attr_kwargs(cfg, 'conv1x1_label', **kwargs)
ops = get_attr_kwargs(cfg, 'ops', **kwargs)
view = get_attr_kwargs(cfg, 'view', **kwargs)
edge_attr = {'fontsize': '15', 'fontname': 'times'}
node_attr = {
'style': 'filled',
# 'shape' : 'circle',
'shape': 'rect',
'align': 'center',
'fontsize': '15',
'height': '0.5',
'width': '0.5',
'penwidth': '2',
'fontname': 'times'
}
G = Digraph(filename=file_path,
format=format,
edge_attr=edge_attr,
node_attr=node_attr,
engine='dot')
G.body.extend(['rankdir=LR'])
n_edges_per_cell = len(arcs[0]) // n_cells
assert n_edges_per_cell == (1 + n_nodes_per_cell) * n_nodes_per_cell // 2
# for cell_idx in range(n_cells):
# with G.subgraph(name='subgraph_cell_idx' + str(cell_idx)) as s:
# s.attr(rank='same')
# for class_name, idx in class_to_idx.items():
# class_name = class_name.title()
# # UpSample node
# upsample_label = f"U{cell_idx}"
# upsample_name = class_name + upsample_label
# s.node(upsample_name, upsample_label, fillcolor='yellow')
class_to_idx = list(reversed(list(class_to_idx.items())))
G_ori = G
for class_name, idx in class_to_idx:
class_name = class_name.title()
G = G_ori
with G.subgraph(name=f'cluster_{idx}') as G:
G.attr(color='blue', penwidth='3')
# G.attr(label=class_name)
G.attr(label=class_name,
overlap='false',
fontsize='25',
fontname='times')
edge_idx = 0
for cell_idx in range(n_cells):
# UpSample node
upsample_label = f"U{cell_idx}"
upsample_name = class_name + upsample_label
G.node(upsample_name, upsample_label, fillcolor='yellow')
with G.subgraph(name=f'cluster_{class_name}_{cell_idx}') as g:
g.attr(color='black', penwidth='2')
g.attr(label=f'Cell {cell_idx}',
overlap='false',
fontsize='20',
fontname='times')
if cell_idx != 0:
cell_out_label = 'Out'
cell_out_name = class_name + f"{cell_idx-1}" + cell_out_label
G.edge(cell_out_name, upsample_name, fillcolor="white")
# C_in node
cell_in_label = 'In'
cell_in_name = class_name + f"{cell_idx - 1}" + cell_in_label
g.node(cell_in_name,
cell_in_label,
fillcolor='darkseagreen2')
G.edge(upsample_name,
cell_in_name,
label=conv1x1_label,
fillcolor="lightgray")
pre_nodes = [cell_in_name]
for node_idx in range(cell_idx * n_nodes_per_cell,
(cell_idx + 1) * n_nodes_per_cell):
is_none_node = True
# Dense connection
for pre_node_idx in range(len(pre_nodes)):
pre_node_name = pre_nodes[pre_node_idx]
op_name = ops[arcs[idx][edge_idx]]
if op_name != 'None' and pre_node_name != 'None':
if is_none_node:
node_label = str(node_idx)
node_name = class_name + node_label
g.node(node_name,
node_label,
fillcolor='lightblue')
g.edge(pre_node_name,
node_name,
label=op_name,
fillcolor="black")
is_none_node = False
edge_idx += 1
if is_none_node:
pre_nodes.append('None')
else:
pre_nodes.append(node_name)
# output node
cell_out_label = 'Out'
cell_out_name = class_name + f"{cell_idx}" + cell_out_label
g.node(cell_out_name,
cell_out_label,
fillcolor='darkseagreen2')
# Replace C_in node
G.edge(upsample_name, cell_out_name, fillcolor="lightgray")
for pre_node in pre_nodes[1:]:
if pre_node != 'None':
g.edge(pre_node,
cell_out_name,
fillcolor="lightgray")
# add image caption
if caption:
G_ori.attr(label=caption,
overlap='false',
fontsize='25',
fontname='times')
if view:
G_ori.view()
else:
G_ori.save()
'weight': '1',
'fontsize': '11',
'fontcolor': 'black',
'len': '4'
},
graph_attr={
'fixedsize': 'false',
#'bgcolor': 'transparent'
'bgcolor': 'white'
},
node_attr={'shape': 'plaintext'},
directory='gv',
filename='map',
format='png')
#dot.attr(bgcolor='blue')
dot.attr(layout="neato")
dot.attr(nodesep='3')
dot.attr(ranksep='3')
dot.attr(size='5000,5000')
dot.node(
'h1', '''<
<table ALIGN="CENTER" BORDER="0" CELLBORDER="1" CELLSPACING="0"><tr><td port="0">wlan0<br/>192.168.1.163<br/>DC:A6:32:27:D8:01<br/>Raspberry Pi Trading Ltd</td><td port="hostname" rowspan="2">raspberrypi</td><td port="1">lo<br/>127.0.0.1<br/>00:00:00:00:00:00<br/>XEROX CORPORATION</td></tr><tr><td port="2">eth0<br/>None<br/>DC:A6:32:27:D7:FF<br/>Raspberry Pi Trading Ltd</td><td port="3"></td></tr></table>
>''')
nodes = [
'<table ALIGN="CENTER" BORDER="0" CELLBORDER="1" CELLSPACING="0"><tr port="0"><td>192.168.1.218<br/>18:cf:5e:56:d7:22<br/>Unknown</td></tr></table>',
'<table ALIGN="CENTER" BORDER="0" CELLBORDER="1" CELLSPACING="0"><tr port="0"><td>192.168.1.205<br/>d4:11:a3:81:3f:8f<br/>Unknown</td></tr></table>',
'<table ALIGN="CENTER" BORDER="0" CELLBORDER="1" CELLSPACING="0"><tr port="0"><td>192.168.1.146<br/>38:1a:52:28:32:e0<br/>Unknown</td></tr></table>',
'<table ALIGN="CENTER" BORDER="0" CELLBORDER="1" CELLSPACING="0"><tr port="0"><td>192.168.1.143<br/>d8:31:34:88:9e:34<br/>Unknown</td></tr></table>',
def export_graphviz(self, filename='rfstree.gv'):
"""
Export the dependency graph built in the fir phase
as a graphviz document. It returns an object g representing the
graph (e.g., you can visualize it by g.view())
Args:
filename (str): output file
Returns:
g (graphviz.Digraph): an object representing the graph
"""
def apply_styles(graph, styles):
graph.graph_attr.update(
('graph' in styles and styles['graph']) or {}
)
graph.node_attr.update(
('nodes' in styles and styles['nodes']) or {}
)
graph.edge_attr.update(
('edges' in styles and styles['edges']) or {}
)
return graph
if not hasattr(self, 'nodes'):
raise ValueError('Model must be trained.')
from graphviz import Digraph
g = Digraph('G', filename=filename)
g.body.extend(['rankdir=BT'])
g.attr('node', shape='circle')
# BFS
S = set()
Q = [0]
g.node('0', label='{}\nr2={:.4f}'.format(self.nodes[0].feature_name, self.nodes[0].data['r2score'][-1]))
while len(Q) > 0:
current_id = Q[0]
current = self.nodes[current_id]
Q = [Q[i] for i in range(1, len(Q))]
# prepare visualization data
keys = {}
if 'r2score' in current.data.keys():
diff_scores = np.ediff1d(current.data['r2score'], to_begin=current.data['r2score'][0])
for cnt, el in enumerate(current.data['ordered_features']):
keys[el] = cnt
else:
diff_scores = None
for node_id in current.children:
if node_id not in S:
lfn = self.nodes[node_id].feature_name
if current.feature_name == self.nodes[node_id].feature_name:
# make self loop if parent feature is equal to the current one
g.edge(str(current_id), str(current_id),
label='r2={:.4f}'.format(diff_scores[keys[lfn]]) if diff_scores is not None else '')
else:
if 'r2score' in self.nodes[node_id].data.keys():
lbl = '{}\nr2={:.4f}'.format(lfn, self.nodes[node_id].data['r2score'][-1])
else:
lbl = '{}'.format(lfn)
g.node(str(node_id), label=lbl)
g.edge(str(node_id), str(current.id),
label='r2={:.4f}'.format(diff_scores[keys[lfn]]) if diff_scores is not None else '')
S.add(node_id)
Q.append(node_id)
styles = {
# 'graph': {
# 'label': 'A Fancy Graph',
# 'fontsize': '16',
# 'fontcolor': 'black',
# 'bgcolor': 'white',
# 'rankdir': 'BT',
# },
# 'nodes': {
# 'fontname': 'Helvetica',
# 'shape': 'hexagon',
# 'fontcolor': 'black',
# 'color': 'black',
# 'style': 'filled',
# 'fillcolor': 'white',
# },
'edges': {
# 'style': 'solid',
# 'color': 'black',
'arrowhead': 'open',
# 'fontname': 'Courier',
'fontsize': '12',
'fontcolor': 'black',
}
}
g = apply_styles(g, styles)
# g.view()
return g
def to_graphviz(self):
graph = Digraph(name='cluster' + str(self.id))
label = self.name
graph.attr(label=label)
graph.subgraph(self.circuit.to_graphviz())
return graph
def build(name):
path = f'{name}-new.dot'
G = read_dot(path)
d = {}
for n in G.nodes:
if not (n in d):
d[n] = {
'num_units': min(10, get_num_units(G, n)),
'succ_str': list(G.successors(n))[:10]
}
g = Digraph('g', filename=f'{name}-build.gv')
g.graph_attr.update(splines="false", nodesep='1', ranksep='2')
g.attr(arrowShape="none")
for e in d:
with g.subgraph(name=f'cluster_{e}') as c:
c.attr(color="white")
for i in range(d[e]['num_units']):
name_d = f'{e}_{i}'
if 'Input' in e:
color = "#33cc33"
c.node(name_d,
shape="circle",
style="filled",
color=color,
fontcolor=color)
elif 'Dropout' in e:
color = "#ffcc00"
c.node(name_d,
shape="rect",
style="filled",
color=color,
fontcolor=color)
elif 'Concatenate' in e:
color = "#993300"
c.node(name_d,
shape="rect",
style="filled",
color=color,
fontcolor=color)
elif len(d[e]['succ_str']) == 0: # OUTPUT
color = "#ff0000"
c.node(name_d,
shape="circle",
style="filled",
color=color,
fontcolor=color)
else:
color = "#3498db"
c.node(name_d,
shape="circle",
style="filled",
color=color,
fontcolor=color)
for s in d[e]['succ_str']:
if 'Dense' in s:
for j in range(d[s]['num_units']):
name_a = f'{s}_{j}'
g.edge(name_d, name_a)
else:
for j in range(d[s]['num_units']):
name_a = f'{s}_{j}'
g.edge(name_d, name_a)
g.view()
for i in range(len(top_9)):
top = []
top.append(top_9[0][i].split("---|")[0])
top.append(top_9[0][i].split("---|")[1].split("|--->")[0])
top.append(top_9[0][i].split("---|")[1].split("|--->")[1])
end.append(top)
# In[4]:
for i in range(len(end)):
for j in range(len(end[0])):
end[i][j] = end[i][j].replace(" ", "")
# In[5]:
from graphviz import Digraph
G = Digraph(format="png")
G.attr("node", shape="square", style="filled")
for i in range(len(end)):
G.edge(end[i][0], end[i][2], label=end[i][1])
G.node("人口増減率", shape="circle", color="pink")
G.render("zenkoku")
# ### 付録
# In[12]:
lingam = LiNGAM()
lingam.fit(X, use_sklearn=True)
# hello.py - http://www.graphviz.org/content/hello
import os
import cv2 as cv
from graphviz import Digraph
g = Digraph('G', filename='hello.gv')
g.attr('node', shape='record')
g.node('Hello', 'a|b|c|d|e')
g.edge('Hello', 'World')
filename = 'hello'
filepath = './run'
render_format = 'png'
#以png渲染生成文件
g.render(filename, filepath, view=False, cleanup=True, format=render_format)
img = cv.imread(filepath + '/' + filename + '.' + render_format)
#创建窗口并显示图像
cv.namedWindow("Image")
cv.imshow("Image", img)
cv.waitKey(0)
#释放窗口
cv.destroyAllWindows()
os.remove(filepath + '/' + filename + '.' + render_format)
for ii in range(len(start_nodes)):
edges.append((start_nodes[ii], end_nodes[ii]))
# edges.append((start_nodes[ii],end_nodes[ii],{'capacity': capacities[ii]},{'cost': costs[ii]}))
print("edges:", edges, "\n")
G = nx.DiGraph()
G.add_edges_from(edges)
H = nx.relabel_nodes(G, NodeDict)
pos = nx.spring_layout(H)
nx.draw(H, pos, with_labels=True)
plt.show()
#%%
f = Digraph('graphviz plot1', filename='transportation network viz')
f.attr(rankdir='LR', size='8,3')
for ii in range(len(start_nodes)):
f.attr('node', shape='circle')
node1 = edges[ii][0]
node2 = edges[ii][1]
title1 = NodeDict[node1]
title2 = NodeDict[node2]
f.edge(f'{title1}', f'{title2}', label = f'Capacity: {capacities[ii]} Cost: {unit_costs[ii]}')
f.view()
#%%
supply_nodes = []
supply_values = []
for index, row in data_supply.iterrows():
if __name__ == "__main__":
alfabeto = ['a', 'b', 'c']
states = ['0', '1', '2', '3', '4', '5'] #, '6']
#grafo = [('0', '&', '5'), ('5', '&', '2'), ('2', 'b', '3'), ('3', 'b', '4'), ('4', '&', '6'), ('6', '&', '1'),
# ('5', 'a', '5'), ('6', 'a', '6'), ('5', 'b', '5'), ('6', 'b', '6')]
#grafo = [('0', '&', '2'), ('2', '&', '1'), ('2', 'a', '3'), ('3', 'b', '2'), ('3', 'c', '2')]
#grafo = [('0','&','4'), ('0','&','5'), ('4','&','2'), ('5','&','3'), ('2','b','1'), ('3','a','1'), ('4','a','4'),
# ('5', 'b', '5')]
grafo = [('0', '&', '4'), ('4', '&', '2'), ('2', '&', '5'),
('5', '&', '3'), ('3', '&', '6'), ('6', '&', '1'),
('4', 'a', '4'), ('5', 'b', '5')]
final_states = ['1']
grafo_q2(grafo, states, final_states)
drawGraph = Digraph('Automatum', filename='automataq02d', format='jpg')
drawGraph.attr(rankdir='LR', size='8,5')
drawGraph.attr('node', shape='doublecircle')
for x in final_states:
drawGraph.node(x)
drawGraph.attr('node', shape='circle')
for element in grafo:
init = str(element[0])
final = str(element[2])
label = ""
for symbol in element[1]:
label += (symbol)
drawGraph.edge(init, final, label=label)
drawGraph.view()
# Traffic Light Behaviors
# Tung M. Phan
# July 8th, 2018
# California Institute of Technology
from graphviz import Digraph
simple_lights = Digraph(filename='simple_lights.gv', comment='This is a very simple traffic light model')
simple_lights.node_attr.update(color='green', style='filled', fixedsize='true', width='1')
simple_lights.attr('node', shape = 'circle')
simple_lights.node ('0', 'green', color='yellow')
simple_lights.node ('1', 'red', color='yellow')
simple_lights.attr('node', shape = 'circle')
simple_lights.edge('0', '1', label='t_walk == t_remaining / ?cross')
simple_lights.edge('0', '1', label='⊤ / #wait')
simple_lights.edge('0', '0', label='⊤ / #wait')
simple_lights.edge('1', '0', label='⊤ / #wait')
simple_lights.edge('1', '1', label='⊤ / #wait')
simple_lights.edge('0', '0', label='t_walk < t_remaining / ?cross')
simple_lights.view()
# ## Derivation Trees
if __name__ == "__main__":
print('\n## Derivation Trees')
if __name__ == "__main__":
from graphviz import Digraph
if __name__ == "__main__":
tree = Digraph("root")
tree.attr('node', shape='plain')
tree.node(r"\<start\>")
if __name__ == "__main__":
tree
if __name__ == "__main__":
tree.edge(r"\<start\>", r"\<expr\>")
if __name__ == "__main__":
tree
# condition = []
# stm = []
# start.append('start')
num = 0
scope2 = []
for i in new_indexing_result:
scope2.append(i[0])
# print(scope2)
for i in new_indexing_result:
# if num>0:
# fc.edge(str(num - 1), str(num))
if i[1] in {'int', 'string', 'bool', 'char'}:
# start.append(i[2])
fc.attr('node', shape ='rectangle')
fc.node(str(num), label=i[2])
if num == 0:
fc.attr('node', rankdir='LR')
fc.node('start', shape='oval')
fc.edge('start', str(num))
if num > 0:
fc.edge(str(num - 1), str(num))
num += 1
if i[1] in {'while', 'for', 'if', 'else if'}:
# condition.append(i[2][1])
# fc.attr('node', shape='diamond')
fc.node(str(num), label=i[2][2], shape='diamond')
if num > 0:
fc.edge(str(num - 1), str(num))
def cli(output_file, json_dir):
print(f"Loading JSON files from {json_dir}")
cfg_dir = os.path.join(json_dir, "data")
files = [(fi) for fi in os.listdir(cfg_dir) if "_init" in fi]
print("Creating main Digraph")
conf = Digraph(name=json_dir)
conf.graph_attr['rankdir'] = 'LR'
netsenders = []
netrecvrs = []
nwconnections = {}
nwconnectionnames = []
nwtopicnames = []
procname_to_host = {}
j = {}
filename = os.path.join(json_dir, "boot.json")
with open(filename, "r") as jf:
try:
j = json.load(jf)
except json.decoder.JSONDecodeError as e:
raise RuntimeError(f"ERROR: failed to load {filename}") from e
for app in j["apps"].keys():
procname_to_host[app] = j["apps"][app]["host"]
for file in files:
procname = file[:-10]
filename = os.path.join(cfg_dir, file)
print(f"Parsing init file for process {procname}")
j = {}
with conf.subgraph(name=f"cluster_{procname}",
node_attr={'shape': 'box'}) as procconf:
procconf.attr(label=f"{procname}")
with open(filename, "r") as jf:
try:
j = json.load(jf)
except json.decoder.JSONDecodeError as e:
raise RuntimeError(
f"ERROR: failed to load {filename}") from e
# NetworkManager connections should be the same for all processes
if len(nwconnections) == 0:
for nwconn in j["nwconnections"]:
name = nwconn["name"]
target = re.search(r"host_[^}]*",
nwconn["address"]).group()
is_subscriber = len(nwconn["topics"]) != 0
print(
f"Adding NetworkManager connection with name {name}, target host {target}, and is_subscriber {is_subscriber}"
)
nwconnections[name] = {
"target": target,
"is_subscriber": is_subscriber,
"topics": nwconn["topics"]
}
nwconnectionnames.append(name)
if len(nwconn["topics"]) != 0:
nwtopicnames.extend(nwconn["topics"])
conf.node(name)
# print("Parsing module configuration")
qmap = {}
for modcfg in j["modules"]:
modinst = modcfg["inst"]
modplug = modcfg["plugin"]
if modplug == "NetworkToQueue":
netrecvrs.append(modinst)
if modplug == "QueueToNetwork":
netsenders.append(modinst)
for qcfg in modcfg["data"]["qinfos"]:
qinst = qcfg["inst"]
qdir = qcfg["dir"]
if qinst not in qmap:
qmap[qinst] = {"sinks": [], "sources": []}
if qdir == "input":
qmap[qinst]["sinks"].append(f"{procname}_{modinst}")
elif qdir == "output":
qmap[qinst]["sources"].append(f"{procname}_{modinst}")
procconf.node(f"{procname}_{modinst}",
label=f"{modinst}\n{modplug}")
# print("Creating queue links")
for qinst in qmap:
# print(f"Queue {qinst}")
qcfg = qmap[qinst]
procconf.node(f"{procname}_{qinst}",
shape="point",
width='0.01',
height='0.01',
xlabel=f"{qinst}")
first = True
for qsrc in qcfg["sources"]:
procconf.edge(qsrc, f"{procname}_{qinst}", dir="none")
for qsin in qcfg["sinks"]:
procconf.edge(f"{procname}_{qinst}", qsin)
netedges = {}
files = [(fi) for fi in os.listdir(cfg_dir) if "_conf" in fi]
for file in files:
procname = file[:-10]
filename = os.path.join(cfg_dir, file)
print(f"Parsing conf file for process {procname}")
j = {}
with open(filename, "r") as jf:
try:
j = json.load(jf)
except json.decoder.JSONDecodeError as e:
raise RuntimeError(f"ERROR: failed to load {filename}") from e
for modcfg in j["modules"]:
modname = modcfg["match"]
if modname in netrecvrs:
print(f"{modname} is a NetworkToQueue instance!")
conn_name = modcfg["data"]["receiver_config"]["name"]
netedge = f"{procname}_{modname}_{conn_name}"
print(
f"Setting sink of network edge {netedge} to {procname}_{modname}"
)
netedges[netedge] = {
"src": conn_name,
"sink": f"{procname}_{modname}",
"label": f"{modname}\n{modcfg['data']['msg_module_name']}",
"color": "green"
}
elif modname in netsenders:
print(f"{modname} is a QueueToNetwork instance!")
conn_name = modcfg["data"]["sender_config"]["name"]
netedge = f"{procname}_{modname}_{conn_name}"
print(
f"Setting src of network edge {netedge} to {procname}_{modname}"
)
netedges[netedge] = {
"sink": conn_name,
"src": f"{procname}_{modname}",
"label": f"{modname}\n{modcfg['data']['msg_module_name']}",
"color": "green"
}
else:
def add_nwedge(conn_name):
netedge = f"{procname}_{modname}_{conn_name}"
is_receiver = (nwconnections[conn_name]["target"] == procname_to_host[procname] and not nwconnections[conn_name]["is_subscriber"]) or \
(nwconnections[conn_name]["is_subscriber"] and nwconnections[conn_name]["target"] != procname_to_host[procname])
print(
f"Found NetworkManager connection {conn_name} in {procname}_{modname}, is_receiver: {is_receiver}"
)
if is_receiver:
netedges[netedge] = {
"src": conn_name,
"sink": f"{procname}_{modname}",
"color": "blue",
"label": f"{modname}"
}
else:
netedges[netedge] = {
"src": f"{procname}_{modname}",
"sink": conn_name,
"color": "blue",
"label": f"{modname}"
}
# We need to search for NetworkManager connections now
def search_nwconnection(obj_to_search):
if type(obj_to_search) == type(dict()):
for key in obj_to_search.keys():
if type(obj_to_search[key]) == type(""):
if obj_to_search[
key] in nwconnectionnames and not "reply_connection_name" in key:
add_nwedge(obj_to_search[key])
elif obj_to_search[
key] in nwtopicnames and not "timesync_connection_name" in obj_to_search.keys(
):
topic_name = obj_to_search[key]
for nwconn in nwconnections:
if topic_name in nwconnections[nwconn][
"topics"]:
add_nwedge(nwconn)
else:
search_nwconnection(obj_to_search[key])
elif type(obj_to_search) == type([]):
for key in obj_to_search:
if type(key) == type(""):
if key in nwconnectionnames:
add_nwedge(key)
elif key in nwtopicnames:
topic_name = key
for nwconn in nwconnections:
if topic_name in nwconnections[nwconn][
"topics"]:
add_nwedge(nwconn)
else:
search_nwconnection(key)
if "data" in modcfg:
search_nwconnection(modcfg["data"])
for netedge in netedges:
src = netedges[netedge]["src"]
sink = netedges[netedge]["sink"]
label = netedges[netedge]["label"]
color = netedges[netedge]["color"]
print(f"Setting up {netedge} to connect {src} to {sink}")
conf.attr('edge', color=color)
conf.edge(src, sink, label=f"{label}")
print("Writing output dot")
with open(output_file, 'w') as dotfile:
dotfile.write(conf.source)
def start(self, only_blocks=False, combined=False):
self.only_blocks = only_blocks
self.combined = combined
name = 'cluster_CFG' if self.combined else 'CFG'
dot = Digraph(name=name)
if not self.combined:
dot.attr('graph', fontname='helvetica')
dot.attr('graph', splines='spline')
dot.attr('graph', compound='true')
dot.attr('node', fontname='helvetica')
dot.attr('node', style='filled', fillcolor='white')
dot.attr('edge', fontname='helvetica')
for node in (self.root if isinstance(self.root, list) else [self.root]):
subgraph = Digraph()
self.draw(node, subgraph)
dot.subgraph(subgraph)
for link in self.missing_links:
dot.edge(**link)
return dot
M.transition(T25)
M.transition(T26)
M.transition(T35)
M.transition(T36)
M.transition(T46)
M.transition(T51)
#****************************************
# ausfuehrung
#****************************************
p = [1,0, 0 ,0, 0, 0]
matrix = M.createMatrix()
print("==================================")
print(" markov-matrix ")
print("===================================")
print(matrix)
prob = M.probability(p, matrix)
print("==================================")
print("Wahrscheinlichkeit eines Zustandes")
print("===================================")
print(prob)
#****************************************
# graph
#****************************************
g = Digraph(comment='Markov')
g.attr('node', shape='circle')
M.graph(g)
g.view()
def ann_viz(model,
view=True,
filename="network.gv",
title="My Neural Network"):
"""Vizualizez a Sequential model.
# Arguments
model: A Keras model instance.
view: whether to display the model after generation.
filename: where to save the vizualization. (a .gv file)
title: A title for the graph
"""
from graphviz import Digraph
import keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D, MaxPooling2D, Dropout, Flatten
import json
input_layer = 0
hidden_layers_nr = 0
layer_types = []
hidden_layers = []
output_layer = 0
for layer in model.layers:
if (layer == model.layers[0]):
input_layer = int(str(layer.input_shape).split(",")[1][1:-1])
hidden_layers_nr += 1
if (type(layer) == keras.layers.core.Dense):
hidden_layers.append(
int(str(layer.output_shape).split(",")[1][1:-1]))
layer_types.append("Dense")
else:
hidden_layers.append(1)
if (type(layer) == keras.layers.convolutional.Conv2D):
layer_types.append("Conv2D")
elif (type(layer) == keras.layers.pooling.MaxPooling2D):
layer_types.append("MaxPooling2D")
elif (type(layer) == keras.layers.core.Dropout):
layer_types.append("Dropout")
elif (type(layer) == keras.layers.core.Flatten):
layer_types.append("Flatten")
elif (type(layer) == keras.layers.core.Activation):
layer_types.append("Activation")
else:
if (layer == model.layers[-1]):
output_layer = int(
str(layer.output_shape).split(",")[1][1:-1])
else:
hidden_layers_nr += 1
if (type(layer) == keras.layers.core.Dense):
hidden_layers.append(
int(str(layer.output_shape).split(",")[1][1:-1]))
layer_types.append("Dense")
else:
hidden_layers.append(1)
if (type(layer) == keras.layers.convolutional.Conv2D):
layer_types.append("Conv2D")
elif (type(layer) == keras.layers.pooling.MaxPooling2D):
layer_types.append("MaxPooling2D")
elif (type(layer) == keras.layers.core.Dropout):
layer_types.append("Dropout")
elif (type(layer) == keras.layers.core.Flatten):
layer_types.append("Flatten")
elif (type(layer) == keras.layers.core.Activation):
layer_types.append("Activation")
last_layer_nodes = input_layer
nodes_up = input_layer
if (type(model.layers[0]) != keras.layers.core.Dense):
last_layer_nodes = 1
nodes_up = 1
input_layer = 1
g = Digraph('g', filename=filename)
n = 0
g.graph_attr.update(splines="false", nodesep='1', ranksep='2')
#Input Layer
with g.subgraph(name='cluster_input') as c:
if (type(model.layers[0]) == keras.layers.core.Dense):
the_label = title + '\n\n\n\nInput Layer'
#if (int(str(model.layers[0].input_shape).split(",")[1][1:-1]) > 10):
# the_label += " (+"+str(int(str(model.layers[0].input_shape).split(",")[1][1:-1]) - 10)+")";
# input_layer = 10;
c.attr(color='white')
for i in range(0, input_layer):
n += 1
c.node(str(n))
c.attr(label=the_label)
c.attr(rank='same')
c.node_attr.update(color="#2ecc71",
style="filled",
fontcolor="#2ecc71",
shape="circle")
elif (type(model.layers[0]) == keras.layers.convolutional.Conv2D):
#Conv2D Input visualizing
the_label = title + '\n\n\n\nInput Layer'
c.attr(color="white", label=the_label)
c.node_attr.update(shape="square")
pxls = str(model.layers[0].input_shape).split(',')
clr = int(pxls[3][1:-1])
if (clr == 1):
clrmap = "Grayscale"
the_color = "black:white"
elif (clr == 3):
clrmap = "RGB"
the_color = "#e74c3c:#3498db"
else:
clrmap = ""
c.node_attr.update(fontcolor="white",
fillcolor=the_color,
style="filled")
n += 1
c.node(str(n),
label="Image\n" + pxls[1] + " x" + pxls[2] +
" pixels\n" + clrmap,
fontcolor="white")
else:
raise ValueError(
"ANN Visualizer: Layer not supported for visualizing")
for i in range(0, hidden_layers_nr):
with g.subgraph(name="cluster_" + str(i + 1)) as c:
if (layer_types[i] == "Dense"):
c.attr(color='white')
c.attr(rank='same')
#If hidden_layers[i] > 10, dont include all
the_label = ""
#if (int(str(model.layers[i].output_shape).split(",")[1][1:-1]) > 10):
# the_label += " (+"+str(int(str(model.layers[i].output_shape).split(",")[1][1:-1]) - 10)+")";
# hidden_layers[i] = 10;
c.attr(labeljust="right", labelloc="b", label=the_label)
for j in range(0, hidden_layers[i]):
n += 1
c.node(str(n),
shape="circle",
style="filled",
color="#3498db",
fontcolor="#3498db")
for h in range(nodes_up - last_layer_nodes + 1,
nodes_up + 1):
g.edge(str(h), str(n))
last_layer_nodes = hidden_layers[i]
nodes_up += hidden_layers[i]
elif (layer_types[i] == "Conv2D"):
c.attr(style='filled', color='#5faad0')
n += 1
kernel_size = str(
model.layers[i].get_config()['kernel_size']).split(
',')[0][1] + "x" + str(model.layers[i].get_config(
)['kernel_size']).split(',')[1][1:-1]
filters = str(model.layers[i].get_config()['filters'])
c.node("conv_" + str(n),
label="Convolutional Layer\nKernel Size: " +
kernel_size + "\nFilters: " + filters,
shape="square")
c.node(str(n),
label=filters + "\nFeature Maps",
shape="square")
g.edge("conv_" + str(n), str(n))
for h in range(nodes_up - last_layer_nodes + 1,
nodes_up + 1):
g.edge(str(h), "conv_" + str(n))
last_layer_nodes = 1
nodes_up += 1
elif (layer_types[i] == "MaxPooling2D"):
c.attr(color="white")
n += 1
pool_size = str(
model.layers[i].get_config()['pool_size']).split(
',')[0][1] + "x" + str(model.layers[i].get_config(
)['pool_size']).split(',')[1][1:-1]
c.node(str(n),
label="Max Pooling\nPool Size: " + pool_size,
style="filled",
fillcolor="#8e44ad",
fontcolor="white")
for h in range(nodes_up - last_layer_nodes + 1,
nodes_up + 1):
g.edge(str(h), str(n))
last_layer_nodes = 1
nodes_up += 1
elif (layer_types[i] == "Flatten"):
n += 1
c.attr(color="white")
c.node(str(n),
label="Flattening",
shape="invtriangle",
style="filled",
fillcolor="#2c3e50",
fontcolor="white")
for h in range(nodes_up - last_layer_nodes + 1,
nodes_up + 1):
g.edge(str(h), str(n))
last_layer_nodes = 1
nodes_up += 1
elif (layer_types[i] == "Dropout"):
n += 1
c.attr(color="white")
c.node(str(n),
label="Dropout Layer",
style="filled",
fontcolor="white",
fillcolor="#f39c12")
for h in range(nodes_up - last_layer_nodes + 1,
nodes_up + 1):
g.edge(str(h), str(n))
last_layer_nodes = 1
nodes_up += 1
elif (layer_types[i] == "Activation"):
n += 1
c.attr(color="white")
fnc = model.layers[i].get_config()['activation']
c.node(str(n),
shape="octagon",
label="Activation Layer\nFunction: " + fnc,
style="filled",
fontcolor="white",
fillcolor="#00b894")
for h in range(nodes_up - last_layer_nodes + 1,
nodes_up + 1):
g.edge(str(h), str(n))
last_layer_nodes = 1
nodes_up += 1
with g.subgraph(name='cluster_output') as c:
if (type(model.layers[-1]) == keras.layers.core.Dense):
c.attr(color='white')
c.attr(rank='same')
c.attr(labeljust="1")
for i in range(1, output_layer + 1):
n += 1
c.node(str(n),
shape="circle",
style="filled",
color="#e74c3c",
fontcolor="#e74c3c")
for h in range(nodes_up - last_layer_nodes + 1,
nodes_up + 1):
g.edge(str(h), str(n))
c.attr(label='Output Layer', labelloc="bottom")
c.node_attr.update(color="#2ecc71",
style="filled",
fontcolor="#2ecc71",
shape="circle")
g.attr(arrowShape="none")
g.edge_attr.update(arrowhead="none", color="#707070")
if view == True:
g.view()
class Frequency_graph():
"""
DataFrame - с 3 столбцами ['case_name', 'transact', 'time_diff'].
count_treshold - принимает на вход:
- string: "All" (отрисовываются ребра любой частотности)
- integer: 0, 10, 123,... (отрисовываются ребра с частотой до или с заданного диапазона,
указывается совместно с параметром less_or_more)
less_or_more - принимает на вход:
- string: "<" или ">" (указывается для задания необходимого порога, если параметр
count_treshold принимает значение integer)
Функция возвращает граф, где цифрами обозначена частота перехода между двумя событиями.
Чем ярче и толще линия, тем чаще встречается данный переход.
"""
def __init__(self, DataFrame, filename=None):
self.df = DataFrame
self.name = filename
self.counts = None
self.graph = None
def check_colon(self):
name_processes = tuple(self.df['transact'].unique())
counts = [1 for i in name_processes if ':' in i]
if len(counts) != 0:
print(
"""В именах событий содержится двоеточие, данный вывод некорректен,
перед отрисовкой графа необходимо заменить двоеточие на тире"""
)
def graph_init(self):
if self.name is None:
curr_time = datetime.now().strftime("%H:%M:%S").replace(':', '-')
self.graph = Digraph('finite_state_machine',
filename=f'Graph_{curr_time}')
else:
self.graph = Digraph('finite_state_machine', filename=self.name)
self.graph.attr(rankdir='T', size='8,5')
self.graph.attr('node',
shape='box',
style='filled',
color='deepskyblue')
self.graph.node('Start Log',
shape='doublecircle',
color='deepskyblue1')
self.graph.node('Log End', shape='doublecircle', color='brown3')
self.graph.attr('node', shape='box', color='lightblue')
def count_transact(self, count_method):
if count_method == "uniq":
counts = self.df.groupby("transact")["case_name"]\
.agg("nunique")\
.sort_values(ascending=False)\
.reset_index()
else:
counts = pd.DataFrame(
self.df['transact'].value_counts()).reset_index()
counts.columns = ['transact', 'counts']
return counts
def stat_calculate(cls, count_treshold, less_or_more, count_method):
if count_treshold == 'All':
cls.counts = cls.count_transact(count_method)
else:
try:
if less_or_more == "<":
counts = cls.count_transact(count_method)
cls.counts = counts[counts['counts'] < count_treshold]
elif less_or_more == ">":
counts = cls.count_transact(count_method)
cls.counts = counts[counts['counts'] > count_treshold]
else:
return 'Недопустимое значение для параметра less_or_more или неправильно указано значение All'
except Exception as e:
print(e)
print(
"""Параметр count_treshold принимает либо значение All, либо должно иметь тип integer,\
совместно с параметром less_or_more, который принимает одно из следующих значений: "<" или ">" """
)
@staticmethod
def change_color_freq(count_transact, stat):
if count_transact <= 100: ## <= stat[0]
color = 'brown' #'brown'
elif (count_transact > 100) and (
count_transact <= 500): ## stat[0] > count_transact <= stat[1]
color = 'coral1' #'coral1'
elif (count_transact > 500) and (count_transact <= 1000): ## etc
color = 'goldenrod' #'goldenrod'
elif (count_transact > 1000) and (count_transact <= 2000):
color = 'deepskyblue1'
elif count_transact > 2000:
color = 'cyan'
return color
@staticmethod
def change_width_freq(count_transact, stat):
if count_transact <= 100: ## <= stat[0]
width = '1'
elif (count_transact > 100) and (
count_transact <= 500): ## stat[0] > count_transact <= stat[1]
width = '1' #'2'
elif (count_transact > 500) and (count_transact <= 1000): ## etc
width = '1' #'3'
elif (count_transact > 1000) and (count_transact <= 2000):
width = '4'
elif count_transact > 2000:
width = '5'
return width
@staticmethod
def get_stat_freq(freq_to_int):
percent_25 = int(np.percentile(freq_to_int, 25))
percent_50 = int(np.percentile(freq_to_int, 50))
percent_75 = int(np.percentile(freq_to_int, 75))
percent_95 = int(np.percentile(freq_to_int, 95))
stat_percent = [percent_25, percent_50, percent_75, percent_95]
return stat_percent
def draw_freq(cls,
count_treshold='All',
less_or_more=None,
count_method="uniq"):
cls.stat_calculate(count_treshold, less_or_more, count_method)
cls.graph_init()
cls.check_colon()
transact = cls.counts['transact'].values
countss = cls.counts['counts'].values
for c in range(len(transact)):
stat_percent = cls.get_stat_freq(countss)
tr = transact[c]
count = int(countss[c])
start = tr.split('-->')[0]
end = tr.split('-->')[1]
cls.graph.edge('{0}'.format(start),
'{0}'.format(end),
label='{0}'.format(count),
arrowhead='vee',
penwidth=cls.change_width_freq(count, stat_percent),
color=cls.change_color_freq(count, stat_percent),
fontcolor=cls.change_color_freq(
count, stat_percent))
cls.graph.view()
from Optimizacion.reporteOptimizacion import *
# variables.ventana = Tk()
variables.ventana.geometry("1200x650")
variables.ventana.resizable(False, False)
variables.ventana.config(bg="gray25") # color de fondo, background
variables.ventana.config(cursor="pirate") # tipo de cursor (arrow defecto)
variables.ventana.config(relief="sunken") # relieve del root
variables.ventana.config(bd=12) # tamaño del borde en píxeles
global tablaSym
tablaSym = Digraph("TablaSym", node_attr={'shape': 'record'})
global ErroresS
ErroresS = Digraph("reporte", node_attr={'shape': 'record'})
ErroresS.attr(style='rounded', color='#4b8dc5')
contenidoE: str = ""
global ReporteO
ReporteO= Digraph("reporteOp", node_attr={'shape': 'record'})
ReporteO.attr(style='rounded', color='#4b8dc5')
contenidoO: str = ""
def send_data():
print("Analizando Entrada:")
print("==============================================")
# reporteerrores = []
contenido = Tentrada.get(1.0, 'end')
variables.consola.delete("1.0", "end")
variables.consola.configure(state='normal')
def draw_vector(V, name='', rankdir='LR', ioff=0, joff=0):
g = Digraph(name)
g.attr(rankdir=rankdir, ranksep='1')
for i, v in V:
g.node(str(i + ioff), label='%s:%s' % (str(i), str(v)))
return g
def print_coupling_dot_LR(self, update, context):
if self.operation_count == 0:
self.print_entity_db(update)
update.message.reply_text("Type name of Entity")
self.operation_count += 1
elif self.operation_count == 1:
if update.message.text in self.model_db.keys():
self.selected = update.message.text
self.load_entity(self.selected)
command = Digraph(comment=self.entity.entity_name)
command.attr(rankdir='LR')
# command.node('externalIn', "External Input", shape="invhouse", color="red")
# command.node('externalOut', "External Output", shape="invhouse", color="skyblue")
# command.node('R', self.entity.entity_name, shape="box", style="bold")
entity_height = "0.3"
entity_width = "1"
entity_fontsize = "15"
port_height = "0.1"
port_width = "0.1"
ex_port_height = "0.3"
ex_port_width = "0.3"
port_shape = "point"
port_fontsize = "1.5"
if self.aft_msa.entity_list is not None:
for item in self.aft_msa.entity_list:
if item[2]:
command.node(item[0],
item[0],
shape="box",
style="bold",
height=entity_height,
width=entity_width,
fontsize=entity_fontsize)
else:
command.node(item[0],
item[0],
shape="box",
style="bold",
height=entity_height,
width=entity_width,
fontsize=entity_fontsize)
if self.aft_msa.external_input_map is not None:
i = 0
for keys, values in self.aft_msa.external_input_map.items(
):
command.node(keys + "exin" + str(i),
"",
shape="invhouse",
style='filled',
color='plum1',
height=ex_port_height,
width=ex_port_width)
j = 0
for item in values:
# item[1]
command.node(keys + item[1] + "in" + str(j),
"",
shape=port_shape,
height=port_height,
width=port_width)
command.edge(keys + "exin" + str(i),
keys + item[1] + "in" + str(j),
label=" " + keys)
command.edge(keys + item[1] + "in" + str(j),
item[0],
label=" " + item[1])
j += 1
i += 1
if self.aft_msa.internal_coupling_map_tuple is not None:
i = 0
for keys, values in self.aft_msa.internal_coupling_map_tuple.items(
):
# keys[1]
j = 0
for item in values:
command.node(keys[1] + "internalOut" + str(i) +
str(j),
"",
shape=port_shape,
height=port_height,
width=port_width)
# item[1]
# command.node(keys[1] + item[1] +"internalIn"+str(i)+str(j), item[1], shape=port_shape,
# height=port_height, width=port_width)
command.edge(keys[0],
keys[1] + "internalOut" + str(i) +
str(j),
style="dotted",
label=" " + keys[1])
# command.edge(keys[1] + "internalOut"+str(i),
# keys[1] + item[1] +"internalIn"+str(i)+str(j), style="dotted")
command.edge(keys[1] + "internalOut" + str(i) +
str(j),
item[0],
label=" " + item[1])
j += 1
i += 1
if self.aft_msa.external_output_map is not None:
i = 0
for keys, values in self.aft_msa.external_output_map.items(
):
# keys
command.node(keys + "exout" + str(i),
"",
shape="invhouse",
style='filled',
color='skyblue',
height=ex_port_height,
width=ex_port_width)
j = 0
for item in values:
# item1
command.node(keys + item[1] + "out" + str(j),
"",
shape=port_shape,
height=port_height,
width=port_width)
command.edge(item[0],
keys + item[1] + "out" + str(j),
style="dotted",
label=" " + keys)
command.edge(keys + item[1] + "out" + str(j),
keys + "exout" + str(i),
style="dotted",
label=" " + item[1])
j += 1
i += 1
self.send_dot_telegram(command, update, context)
self.clear_system()
else:
update.message.reply_text("[ERR] Entity Not Found")
update.message.reply_text("Type name of Entity")
class GraphDrawer:
def __init__(self, db=0, rengine='dot'):
self.db = db
self.dot = Digraph(
comment='The Round Table',
node_attr={
'color': 'lightblue2',
'style': 'filled'
},
engine=rengine
) #node_attr={'color': 'lightblue2', 'style': 'filled'},
self.dot.attr(newrank='true')
#self.dot.attr(rankdir='TB')
self.dot.attr(pad="0.5")
self.dot.attr(ranksep="1")
#self.dot.attr(nodesep="2.0")
self.dot.attr(ratio="auto")
self.dot.attr(remincross="false")
self.dot.attr(label="FAMILY TREE")
self.fill_nodes()
self.set_ranks()
self.fill_relations()
#self.set_rel_ranks()
self.dot.format = 'svg'
self.dot.render(view=True) #('round-table.gv', view=True)
def set_ranks(self):
pids = sorted(list(self.db.peoples.rows.keys()), reverse=False)
p0000 = Digraph(name='0000-')
p0000.attr(rank='same')
#p0000.body.append("rankdir=LR")
#p0000.attr(rankdir='LR')
p1000 = Digraph(name='1000-')
p1000.attr(rank='same')
#p1000.attr(sortv="1")
#p1000.body.append("rankdir=LR")
#p1000.attr(rankdir='LR')
p2000 = Digraph(name='2000-')
p2000.attr(rank='same')
#p2000.attr(sortv="2")
#p2000.body.append("rankdir=LR")
#p2000.attr(rankdir='LR')
p3000 = Digraph(name='3000-')
p3000.attr(rank='same')
#p3000.attr(sortv="3")
#p3000.body.append("rankdir=LR")
#p3000.attr(rankdir='LR')
p4000 = Digraph(name='4000-')
p4000.attr(rank='same')
#p4000.attr(sortv="1")
#p4000.body.append("rankdir=LR")
#p4000.attr(rankdir='LR')
p5000 = Digraph(name='5000-')
p5000.attr(rank='same')
#p5000.body.append("rankdir=LR")
#p5000.attr(sortv="1")
for pid in pids:
if pid > 0 and pid < 1000:
p0000.node(str(pid))
if pid >= 1000 and pid < 2000:
p1000.node(str(pid))
if pid >= 2000 and pid < 3000:
p2000.node(str(pid))
if pid >= 3000 and pid < 4000:
p3000.node(str(pid))
if pid >= 4000 and pid < 5000:
p4000.node(str(pid))
if pid >= 5000 and pid < 6000:
p5000.node(str(pid))
self.dot.subgraph(p0000)
self.dot.subgraph(p1000)
self.dot.subgraph(p2000)
self.dot.subgraph(p3000)
self.dot.subgraph(p4000)
self.dot.subgraph(p5000)
def set_rel_ranks(self, rels):
pids = sorted([int(key) for key in rels.keys() if '_im' not in key],
reverse=False)
print(pids)
p0000 = Digraph(name='0000-')
p0000.attr(rank='same')
#p0000.body.append("rankdir=LR")
#p0000.attr(rankdir='LR')
p1000 = Digraph(name='1000-')
p1000.attr(rank='same')
#p1000.attr(sortv="1")
#p1000.body.append("rankdir=LR")
#p1000.attr(rankdir='LR')
p2000 = Digraph(name='2000-')
p2000.attr(rank='same')
#p2000.attr(sortv="2")
#p2000.body.append("rankdir=LR")
#p2000.attr(rankdir='LR')
p3000 = Digraph(name='3000-')
p3000.attr(rank='same')
#p3000.attr(sortv="3")
#p3000.body.append("rankdir=LR")
#p3000.attr(rankdir='LR')
p4000 = Digraph(name='4000-')
p4000.attr(rank='same')
#p4000.attr(sortv="1")
#p4000.body.append("rankdir=LR")
#p4000.attr(rankdir='LR')
p5000 = Digraph(name='5000-')
p5000.attr(rank='same')
#p5000.body.append("rankdir=LR")
#p5000.attr(sortv="1")
for pid in pids:
if pid > 0 and pid < 1000:
p0000.node(rels[str(pid)])
if pid >= 1000 and pid < 2000:
p1000.node(rels[str(pid)])
if pid >= 2000 and pid < 3000:
p2000.node(rels[str(pid)])
if pid >= 3000 and pid < 4000:
p3000.node(rels[str(pid)])
if pid >= 4000 and pid < 5000:
p4000.node(rels[str(pid)])
if pid >= 5000 and pid < 6000:
p5000.node(rels[str(pid)])
self.dot.subgraph(p0000)
self.dot.subgraph(p1000)
self.dot.subgraph(p2000)
self.dot.subgraph(p3000)
self.dot.subgraph(p4000)
self.dot.subgraph(p5000)
def fill_nodes(self):
pids = sorted(list(self.db.peoples.rows.keys()), reverse=False)
for pid in pids:
people = self.db.get_people(pid)
text, color_rel = self.get_people_info(pid)
photo_ids = self.db.get_all_photo_ids(pid)
image_path = self.db.get_photo_path(
pid, photo_ids[0]) if photo_ids and type(photo_ids) == type(
[]) and len(photo_ids) > 0 else ''
image_mini_path = os.path.join(
os.path.join('photos', 'miniatures'),
str(pid) + '_001.png')
if image_path != '' and os.path.exists(
image_path) and not os.path.exists(image_mini_path):
print(pid)
gm = GalleryMiniature(pid, image_path)
gm.exec()
shape = 'doublecircle'
#else:
# shape = 'doubleoctagon'
node_text = str(people['pid'])
node_image = str(people['pid']) + '_im'
node_tooltip = str('День рождения: ' + str(people['birthday']) +
'' if 'birthday' in people.keys()
and str(people['birthday']) != '' else '')
node_image_tooltip = r'<img src="photos/miniatures/4009_001.png" width="189" height="255">'
#node_tooltip = node_tooltip + node_tooltip
self.dot.node(node_text,
text,
shape='box',
color=color_rel,
fontcolor='white',
width="3",
height="2",
fixedsize="true",
fontsize="36",
tooltip=node_tooltip) #image="f.png",'''
if os.path.exists(image_mini_path):
self.dot.node(node_image,
'',
shape=shape,
color=color_rel,
fontcolor='white',
tooltip=node_image_tooltip,
image=image_mini_path,
imagescale="true",
width="3",
height="3",
fixedsize="true",
fontsize="36") #image="f.png",'''
else:
self.dot.node(node_image,
'',
shape=shape,
color=color_rel,
fontcolor='white',
width="3",
height="3",
fixedsize="true",
fontsize="36") #image="f.png",'''
self.dot.edge(node_image, node_text, weigth="1400")
def get_people_info(self, pid):
people = self.db.get_people(int(pid))
text_formatter = lambda x: x if x == '' else '\n'.join(
str(x).split(' ')) + '\n'
text = text_formatter(people['surname']) + str(
'' if people['maiden'] == '' else '(' + people['maiden'] +
')\n') + text_formatter(people['name']) + text_formatter(
people['midname'])
pol = people['pol'] if 'pol' in people.keys() else ''
if pol == '':
color_rel = "/dark28/" + str(2)
if len(pol) > 0 and pol[0].lower() == 'м':
#text = text_formatter(self.mans_surnames[random.randint(0, len(self.mans_surnames)-1)]) + text_formatter(self.mans_names[random.randint(0, len(self.mans_names)-1)])
color_rel = "#ad66d5" #"/dark28/"+str(3)
if len(pol) > 0 and pol[0].lower() == 'ж':
#text = text_formatter(self.womans_surnames[random.randint(0, len(self.womans_surnames)-1)]) + text_formatter(self.womans_names[random.randint(0, len(self.womans_names)-1)])
color_rel = "#e667af" #"/dark28/"+str(8)
#is_alive = people['deathday'] if 'deathday' in people.keys() else ''
return (text, color_rel)
def have_parents(self, pid):
relations = self.db.get_relations(int(pid))
rel_keys = sorted([typeid
for typeid in relations]) if relations else []
if 1 in rel_keys or 2 in rel_keys:
return True
return False
def fill_relations(self):
pids = sorted(list(self.db.peoples.rows.keys()), reverse=True)
#print(pids)
rel_nodes = {}
pids_added = []
for pid in pids:
relations = self.db.get_relations(pid)
rel_keys = sorted([typeid
for typeid in relations]) if relations else []
#print(relations)
for key in rel_keys:
if key > 2:
#print(relations[key])
people_pid1 = str(relations[key]['ppid'])
people_pid2 = str(relations[key]['pid'])
people_pid_im1 = str(relations[key]['ppid']) + '_im'
people_pid_im2 = str(relations[key]['pid']) + '_im'
#print((people_pid1,people_pid2))
if people_pid2 in rel_nodes.keys():
node_need_add = False
else:
node_need_add = True
rel_nodes[
people_pid1] = people_pid1 + '_' + people_pid2
rel_nodes[
people_pid2] = people_pid1 + '_' + people_pid2
rel_nodes[
people_pid_im1] = people_pid1 + '_' + people_pid2
rel_nodes[
people_pid_im2] = people_pid1 + '_' + people_pid2
#rel_nodes[people_pid_im1] = people_pid_im1 + people_pid_im2
#rel_nodes[people_pid_im2] = people_pid_im1 + people_pid_im2
#print(rel_nodes)
if node_need_add:
self.dot.node(rel_nodes[people_pid2],
'',
shape='invtriangle',
color=str("/dark28/" + str(2)),
width="0.7",
height="0.7",
fixedsize="true")
#self.dot.node(rel_nodes[people_pid_im2], '', shape='invtriangle', color=str("/dark28/"+str(2)), width="1.5", height="1.5", fixedsize="true")
#self.dot.edge(people_pid2, people_pid1, color="#e1004c")
self.dot.edge(people_pid2,
rel_nodes[people_pid2],
color="#e1004c",
weigth="5000")
self.dot.edge(people_pid_im2,
rel_nodes[people_pid_im2],
style="invis",
constraint="false",
weigth="5000") #style="invis"
self.dot.edge(people_pid2,
rel_nodes[people_pid2],
style="invis",
weigth="5000")
#print(rel_nodes)
#print(rel_keys)
print(rel_nodes)
for pid in pids:
relations = self.db.get_relations(pid)
#print(relations)
rel_keys = sorted([typeid
for typeid in relations]) if relations else []
for key in rel_keys:
if key == 1 or key == 2:
if str(relations[key]['ppid']) in rel_nodes.keys():
self.dot.edge(rel_nodes[str(relations[key]['ppid'])],
str(relations[key]['pid']),
color="#3714b0",
weigth="10000") #color="#7908aa")
#self.dot.edge(rel_nodes[str(relations[key]['ppid'])], str(relations[key]['ppid']), color="#3714b0", weigth="10000")
#self.dot.edge(rel_nodes[str(relations[key]['ppid'])], str(relations[key]['pid']), style="invis", weigth="10000")
break
self.dot.edge(str(relations[key]['ppid']),
str(relations[key]['pid']),
color="#3714b0",
weigth="1000")
def plot(data=None, output=None):
components = [
"fs", "ipc", "mm", "net", "security", "block", "sched", "time", "irq",
"locking"
]
dot = Digraph(comment='Linux graph plot')
dot.attr(ratio="compress")
dot.attr(ranksep="0")
dot.attr(concentrate="true")
dot.attr(size="50,20")
dot.attr(rankdir="LR")
dot.attr("node",
fontname="Helvetica",
fontcolor="black",
fontsize="80",
shape="box")
dot.attr("edge", fontname="Helvetica", fontcolor="blue", fontsize="35")
adj_list = {}
for i in components:
adj_list[i] = {}
for line in open(os.path.join(data, i) + ".deps", "r"):
if "linux" in line:
comp = ""
for w in components:
if w in line:
comp = w
break
if comp == "":
continue
j = comp
if j == i or j == "ukdebug":
continue
if j not in adj_list[i]:
adj_list[i][j] = 0
adj_list[i][j] = adj_list[i][j] + 1
for i in components:
for j in adj_list[i]:
if j in components:
dot.edge(i, j, label=str(adj_list[i][j]))
dot.render(output)
def plot(arc, cfg, **kwargs):
""" make DAG plot and save to file_path as .png """
format = get_attr_kwargs(cfg, 'format', **kwargs)
file_path = get_attr_kwargs(cfg, 'file_path', **kwargs)
caption = get_attr_kwargs(cfg, 'caption', default=None, **kwargs)
n_cells = get_attr_kwargs(cfg, 'n_cells', **kwargs)
n_nodes_per_cell = get_attr_kwargs(cfg, 'n_nodes_per_cell', **kwargs)
conv1x1_label = get_attr_kwargs(cfg, 'conv1x1_label', **kwargs)
ops = get_attr_kwargs(cfg, 'ops', **kwargs)
view = get_attr_kwargs(cfg, 'view', **kwargs)
edge_attr = {'fontsize': '15', 'fontname': 'times'}
node_attr = {
'style': 'filled',
# 'shape' : 'circle',
'shape': 'rect',
'align': 'center',
'fontsize': '15',
'height': '0.5',
'width': '0.5',
'penwidth': '2',
'fontname': 'times'
}
G = Digraph(format=format,
edge_attr=edge_attr,
node_attr=node_attr,
engine='dot')
G.body.extend(['rankdir=LR'])
# intermediate nodes
n_edges_per_cell = len(arc) // n_cells
assert n_edges_per_cell == (1 + n_nodes_per_cell) * n_nodes_per_cell // 2
edge_idx = 0
for cell_idx in range(n_cells):
# UpSample node
G.node(f"U{cell_idx}", fillcolor='yellow')
with G.subgraph(name=f'cluster_{cell_idx}') as g:
g.attr(color='black')
g.attr(label=f'Cell {cell_idx}',
overlap='false',
fontsize='20',
fontname='times')
if cell_idx != 0:
G.edge(f"C{cell_idx-1}_{{out}}",
f"U{cell_idx}",
fillcolor="white")
# C_in node
g.node(f"C{cell_idx}_{{in}}", fillcolor='darkseagreen2')
G.edge(f"U{cell_idx}",
f"C{cell_idx}_{{in}}",
label=conv1x1_label,
fillcolor="lightgray")
pre_nodes = [f"C{cell_idx}_{{in}}"]
for node_idx in range(cell_idx * n_nodes_per_cell,
(cell_idx + 1) * n_nodes_per_cell):
is_none_node = True
# Dense connection
for pre_node_idx in range(len(pre_nodes)):
pre_node_name = pre_nodes[pre_node_idx]
op_name = ops[arc[edge_idx]]
if op_name != 'None' and pre_node_name != 'None':
if is_none_node:
g.node(str(node_idx), fillcolor='lightblue')
g.edge(pre_node_name,
str(node_idx),
label=op_name,
fillcolor="black")
is_none_node = False
edge_idx += 1
if is_none_node:
pre_nodes.append('None')
else:
pre_nodes.append(str(node_idx))
# output node
g.node(f"C{cell_idx}_{{out}}", fillcolor='darkseagreen2')
# Replace C_in node
G.edge(f"U{cell_idx}",
f"C{cell_idx}_{{out}}",
fillcolor="lightgray")
for pre_node in pre_nodes[1:]:
if pre_node != 'None':
g.edge(pre_node,
f"C{cell_idx}_{{out}}",
fillcolor="lightgray")
#
# # output node
# g.node("c_{k}", fillcolor='palegoldenrod')
# for i in range(n_nodes):
# g.edge(str(i), "c_{k}", fillcolor="gray")
# add image caption
if caption:
G.attr(label=caption, overlap='false', fontsize='25', fontname='times')
G.render(file_path, view=view)
def graphviz_visualization(net,
image_format="png",
initial_marking=None,
final_marking=None,
decorations=None,
debug=False,
set_rankdir=None):
"""
Provides visualization for the petrinet
Parameters
----------
net: :class:`pm4py.entities.petri.petrinet.PetriNet`
Petri net
image_format
Format that should be associated to the image
initial_marking
Initial marking of the Petri net
final_marking
Final marking of the Petri net
decorations
Decorations of the Petri net (says how element must be presented)
debug
Enables debug mode
set_rankdir
Sets the rankdir to LR (horizontal layout)
Returns
-------
viz :
Returns a graph object
"""
if initial_marking is None:
initial_marking = Marking()
if final_marking is None:
final_marking = Marking()
if decorations is None:
decorations = {}
filename = tempfile.NamedTemporaryFile(suffix='.gv')
viz = Digraph(net.name,
filename=filename.name,
engine='dot',
graph_attr={'bgcolor': 'transparent'})
if set_rankdir:
viz.graph_attr['rankdir'] = set_rankdir
else:
viz.graph_attr['rankdir'] = 'LR'
# transitions
viz.attr('node', shape='box')
# add transitions, in order by their (unique) name, to avoid undeterminism in the visualization
trans_sort_list = sorted(list(net.transitions),
key=lambda x:
(x.label
if x.label is not None else "tau", x.name))
for t in trans_sort_list:
if t.label is not None:
if t in decorations and "label" in decorations[
t] and "color" in decorations[t]:
viz.node(str(id(t)),
decorations[t]["label"],
style='filled',
fillcolor=decorations[t]["color"],
border='1')
else:
viz.node(str(id(t)), str(t.label))
else:
if debug:
viz.node(str(id(t)), str(t.name))
elif t in decorations and "color" in decorations[
t] and "label" in decorations[t]:
viz.node(str(id(t)),
decorations[t]["label"],
style='filled',
fillcolor=decorations[t]["color"],
fontsize='8')
else:
viz.node(str(id(t)), "", style='filled', fillcolor="black")
# places
viz.attr('node', shape='circle', fixedsize='true', width='0.75')
# add places, in order by their (unique) name, to avoid undeterminism in the visualization
places_sort_list_im = sorted(
[x for x in list(net.places) if x in initial_marking],
key=lambda x: x.name)
places_sort_list_fm = sorted([
x for x in list(net.places)
if x in final_marking and not x in initial_marking
],
key=lambda x: x.name)
places_sort_list_not_im_fm = sorted([
x for x in list(net.places)
if x not in initial_marking and x not in final_marking
],
key=lambda x: x.name)
# making the addition happen in this order:
# - first, the places belonging to the initial marking
# - after, the places not belonging neither to the initial marking and the final marking
# - at last, the places belonging to the final marking (but not to the initial marking)
# in this way, is more probable that the initial marking is on the left and the final on the right
places_sort_list = places_sort_list_im + places_sort_list_not_im_fm + places_sort_list_fm
for p in places_sort_list:
if p in initial_marking:
viz.node(str(id(p)),
str(initial_marking[p]),
style='filled',
fillcolor="green")
elif p in final_marking:
viz.node(str(id(p)), "", style='filled', fillcolor="orange")
else:
if debug:
viz.node(str(id(p)), str(p.name))
else:
if p in decorations and "color" in decorations[
p] and "label" in decorations[p]:
viz.node(str(id(p)),
decorations[p]["label"],
style='filled',
fillcolor=decorations[p]["color"],
fontsize='6')
else:
viz.node(str(id(p)), "")
# add arcs, in order by their source and target objects names, to avoid undeterminism in the visualization
arcs_sort_list = sorted(list(net.arcs),
key=lambda x: (x.source.name, x.target.name))
for a in arcs_sort_list:
if a in decorations and "label" in decorations[
a] and "penwidth" in decorations[a]:
viz.edge(str(id(a.source)),
str(id(a.target)),
label=decorations[a]["label"],
penwidth=decorations[a]["penwidth"])
elif a in decorations and "color" in decorations[a]:
viz.edge(str(id(a.source)),
str(id(a.target)),
color=decorations[a]["color"])
else:
viz.edge(str(id(a.source)), str(id(a.target)))
viz.attr(overlap='false')
viz.attr(fontsize='11')
viz.format = image_format
return viz
def graphviz_visualization(activities_count,
dfg,
image_format="png",
measure="frequency",
max_no_of_edges_in_diagram=100000,
start_activities=None,
end_activities=None,
soj_time=None,
font_size="12"):
"""
Do GraphViz visualization of a DFG graph
Parameters
-----------
activities_count
Count of attributes in the log (may include attributes that are not in the DFG graph)
dfg
DFG graph
image_format
GraphViz should be represented in this format
measure
Describes which measure is assigned to edges in direcly follows graph (frequency/performance)
max_no_of_edges_in_diagram
Maximum number of edges in the diagram allowed for visualization
start_activities
Start activities of the log
end_activities
End activities of the log
soj_time
For each activity, the sojourn time in the log
Returns
-----------
viz
Digraph object
"""
if start_activities is None:
start_activities = {}
if end_activities is None:
end_activities = {}
filename = tempfile.NamedTemporaryFile(suffix='.gv')
viz = Digraph("",
filename=filename.name,
engine='dot',
graph_attr={'bgcolor': 'transparent'})
# first, remove edges in diagram that exceeds the maximum number of edges in the diagram
dfg_key_value_list = []
for edge in dfg:
dfg_key_value_list.append([edge, dfg[edge]])
# more fine grained sorting to avoid that edges that are below the threshold are
# undeterministically removed
dfg_key_value_list = sorted(dfg_key_value_list,
key=lambda x: (x[1], x[0][0], x[0][1]),
reverse=True)
dfg_key_value_list = dfg_key_value_list[
0:min(len(dfg_key_value_list), max_no_of_edges_in_diagram)]
dfg_allowed_keys = [x[0] for x in dfg_key_value_list]
dfg_keys = list(dfg.keys())
for edge in dfg_keys:
if edge not in dfg_allowed_keys:
del dfg[edge]
# calculate edges penwidth
penwidth = assign_penwidth_edges(dfg)
activities_in_dfg = set()
activities_count_int = copy(activities_count)
for edge in dfg:
activities_in_dfg.add(edge[0])
activities_in_dfg.add(edge[1])
# assign attributes color
activities_color = get_activities_color(activities_count_int)
# represent nodes
viz.attr('node', shape='box')
if len(activities_in_dfg) == 0:
activities_to_include = sorted(list(set(activities_count_int)))
else:
# take unique elements as a list not as a set (in this way, nodes are added in the same order to the graph)
activities_to_include = sorted(list(set(activities_in_dfg)))
activities_map = {}
for act in activities_to_include:
if "frequency" in measure and act in activities_count_int:
viz.node(str(hash(act)),
act + " (" + str(activities_count_int[act]) + ")",
style='filled',
fillcolor=activities_color[act],
fontsize=font_size)
activities_map[act] = str(hash(act))
else:
viz.node(str(hash(act)),
act + " (" + human_readable_stat(soj_time[act]) + ")",
fontsize=font_size)
activities_map[act] = str(hash(act))
# make edges addition always in the same order
dfg_edges = sorted(list(dfg.keys()))
# represent edges
for edge in dfg_edges:
if "frequency" in measure:
label = str(dfg[edge])
else:
label = human_readable_stat(dfg[edge])
viz.edge(str(hash(edge[0])),
str(hash(edge[1])),
label=label,
penwidth=str(penwidth[edge]),
fontsize=font_size)
start_activities_to_include = [
act for act in start_activities if act in activities_map
]
end_activities_to_include = [
act for act in end_activities if act in activities_map
]
if start_activities_to_include:
viz.node("@@startnode",
"@@S",
style='filled',
shape='circle',
fillcolor="#32CD32",
fontcolor="#32CD32")
for act in start_activities_to_include:
label = str(start_activities[act]) if isinstance(
start_activities, dict) else ""
viz.edge("@@startnode",
activities_map[act],
label=label,
fontsize=font_size)
if end_activities_to_include:
viz.node("@@endnode",
"@@E",
style='filled',
shape='circle',
fillcolor="#FFA500",
fontcolor="#FFA500")
for act in end_activities_to_include:
label = str(end_activities[act]) if isinstance(
end_activities, dict) else ""
viz.edge(activities_map[act],
"@@endnode",
label=label,
fontsize=font_size)
viz.attr(overlap='false')
viz.format = image_format
return viz
"palegreen4", "paleturquoise1", "paleturquoise3", "paleturquoise4",
"palevioletred1", "palevioletred3", "palevioletred4", "peachpuff1",
"peachpuff3", "peachpuff4", "peru", "pink1", "pink3", "plum1", "plum3",
"plum4", "purple1", "purple3", "red1", "red3", "red4", "rosybrown",
"rosybrown4", "royalblue1", "royalblue3", "saddlebrown", "salmon1",
"salmon3", "sandybrown", "seashell3", "seashell4", "sienna1", "sienna3",
"skyblue4", "slateblue1", "slateblue3", "slategray2", "slategray3",
"slategrey", "snow3", "springgreen1", "springgreen3", "springgreen4",
"steelblue1", "steelblue3", "steelblue4", "tan", "tan1", "tan3", "tan4",
"thistle2", "thistle3", "thistle4", "tomato1", "tomato3", "tomato4",
"turquoise", "turquoise1", "turquoise3", "turquoise4", "violet",
"violetred", "violetred1", "wheat1", "wheat3", "yellow1", "yellow3",
"yellowgreen", "skyblue1", "skyblue3", "seagreen3", "seagreen4", "navy",
"seagreen1"
]
for i in range(len(q)):
#if(IS[i] == -1 or (players[i] == 1 and q[i] == 1)):
# if(b[i] == "leaf"):
# continue
dot.attr('node', style='filled', color=colors[IS[i]])
dot.node(str(i), b[i])
if (i > 0):
if (q[i] == 1):
dot.edge(str(parents[i]),
str(i),
minlen=str((i - parents[i] - 1) * 0.1 + 1))
else:
dot.edge(str(parents[i]), str(i))
dot.render('tree', view=True)
def plot_graph(mdp, graph_size='10,10', s_node_size='1,5',
a_node_size='0,5', rankdir='LR', ):
"""
Function for pretty drawing MDP graph with graphviz library.
Requirements:
graphviz : https://www.graphviz.org/
for ubuntu users: sudo apt-get install graphviz
python library for graphviz
for pip users: pip install graphviz
:param mdp:
:param graph_size: size of graph plot
:param s_node_size: size of state nodes
:param a_node_size: size of action nodes
:param rankdir: order for drawing
:return: dot object
"""
s_node_attrs = {'shape': 'doublecircle',
'color': '#85ff75',
'style': 'filled',
'width': str(s_node_size),
'height': str(s_node_size),
'fontname': 'Arial',
'fontsize': '24'}
a_node_attrs = {'shape': 'circle',
'color': 'lightpink',
'style': 'filled',
'width': str(a_node_size),
'height': str(a_node_size),
'fontname': 'Arial',
'fontsize': '20'}
s_a_edge_attrs = {'style': 'bold',
'color': 'red',
'ratio': 'auto'}
a_s_edge_attrs = {'style': 'dashed',
'color': 'blue',
'ratio': 'auto',
'fontname': 'Arial',
'fontsize': '16'}
graph = Digraph(name='MDP')
graph.attr(rankdir=rankdir, size=graph_size)
for state_node in mdp._transition_probs:
graph.node(state_node, **s_node_attrs)
for posible_action in mdp.get_possible_actions(state_node):
action_node = state_node + "-" + posible_action
graph.node(action_node,
label=str(posible_action),
**a_node_attrs)
graph.edge(state_node, state_node + "-" +
posible_action, **s_a_edge_attrs)
for posible_next_state in mdp.get_next_states(state_node,
posible_action):
probability = mdp.get_transition_prob(
state_node, posible_action, posible_next_state)
reward = mdp.get_reward(
state_node, posible_action, posible_next_state)
if reward != 0:
label_a_s_edge = 'p = ' + str(probability) + \
' ' + 'reward =' + str(reward)
else:
label_a_s_edge = 'p = ' + str(probability)
graph.edge(action_node, posible_next_state,
label=label_a_s_edge, **a_s_edge_attrs)
return graph
def dessinerArbre(self, montrerThemes=False):
"""
Permet de dessiner l'arbre d'annotations d'une personne, à l'aide de Graphviz.
L'objet retourné est un Digraph Graphviz. Il peut être enregistré comme suit :
dot = annot.dessinerArbre()
dot.format = 'png' # si on veut changer le format d'enregistrement
dot.render()
montrerThemes: boolean qui indique si on doit afficher les boîtes thématiques ou pas
return: graphviz.Digraph
"""
nom = self.texte.nom+'_-_'+self.annotateur.id
dot = Digraph(name=nom, node_attr={'shape':'box','style':'filled'})
dot.attr(newrank="true") # pour que ça affiche les clusters au bon endroit
dot.node("zero", style="invis") # Le noeud d'origine du dessin
# Ajout des unités
for u in self.texte.unites:
if u.name[0] == "A":
dot.node(u.name, u.name + " : " + u.txt, fillcolor='wheat')
elif u.name[0] == "B":
dot.node(u.name, u.name + " : " + u.txt, fillcolor='skyblue')
else:
dot.node(u.name, u.name + " : " + u.txt)
# Ajout des relations
typesRel = self.annotateur.campagne.typesRelations
debut = self.texte.unites[0].name
dot.edge("zero", debut, label="", style="invis") #On relie le début à l'origine
for rel in self.relations:
if typesRel[rel.type] == "horizontale":
## On n'utilise au final pas les sous-graphes car ils ne permettent pas d'afficher aussi les thèmes (on ne peut pas faire des clusters et sous-graphes qui se chevauchent)
# with dot.subgraph() as sub:
# sub.attr(rank="same")
# sub.node(rel.dest.name)
# sub.node(rel.origine.name)
# sub.edge(rel.dest.name, rel.origine.name, label=rel.type, dir="none")
## A la place on va relier les membres d'une relation horizontale au noeud situé au-dessus, de manière invisible
# Pour ça il faut donc chercher le parent qui est situé au dessus : ce n'est pas forcément le parent immédiat car on peut avoir un enchainement de relations horizontales
relParent = rel.type
noeudParent = rel.dest.name
while typesRel[relParent] == "horizontale" and noeudParent != debut: #on cherche jusqu'à arriver à une relation verticale, ou au début
mat = self.matrice()[:,noeudParent,:] # matrice (destination, typeRel) binaire présentant toutes les relations qui partent du parent
ligne = ""
colonne = ""
where = np.argwhere(mat.as_matrix()) # On cherche l'index de la case où il y a un 1, c'est à dire celle qui correspond à la relation qui part de cette unité
if(len(where)>0): # Si on a bien trouvé une case (normalement il n'y en a qu'une)
ligne, colonne = where[0]
# On transforme cet index numérique en le nom de l'unité et le type de relation
noeudParent = mat.index[ligne]
relParent = mat.columns[colonne]
else: # Sinon c'est qu'on est arrivé au début (il n'a pas de parent) ou que l'annotateur a oublié de relier cette unité
noeudParent = debut
#Si on est arrivé au début il faut se raccrocher à l'origine invisible comme parent vertical
if noeudParent == debut:
noeudParent = "zero"
#On ajoute ensuite une relation verticale invisible vers le noeud au-dessus, afin de contraindre notre noeud dans la hiérarchie du graphe : il doit forcément être placé sous noeudParent
dot.edge(noeudParent, rel.origine.name, style="invis", weight="1") # On met un poids de 1 (faible) car cette relation n'est pas importante et peut-être penchée. Les vraies relations verticales en revanche auront un poids plus élevées pour être dessinées le plus verticalement possible
# On dessine enfin la relation horizontale. constraint=false permet d'indiquer que cette relation n'intervient pas dans la hiérarchie du graphe : les deux noeuds doivent être dessinés au même niveau.
dot.edge(rel.dest.name, rel.origine.name, label=rel.type, dir="none", constraint="false")
else:
dot.edge(rel.dest.name, rel.origine.name, label=rel.type, dir="none", weight="2") # On met un poids de 2 pour que cette relation soit prioritaire sur les relations invisibles : elle doit être dessinée le plus verticalement possible.
# Ajout des thèmes
if montrerThemes:
colorsThemes = dict()
i = 0
colors=["violetred", "olivedrab", "red", "burlywood4", "blue", "peru", "seagreen4", "mediumorchid", "royalblue", "darkorange"]
for theme, unites in self.getThemesUnitsList():
if theme not in colorsThemes:
colorsThemes[theme] = colors[i]
with dot.subgraph(name="cluster_"+str(i)) as c:
c.attr(label="<<B>"+theme+"</B>>")
c.attr(color=colorsThemes[theme])
c.attr(fontcolor=str(colorsThemes[theme]))
for u in unites:
c.node(u.name)
i += 1
return dot
def initialize_graph(graph: Digraph):
graph.attr('node', shape='record')
def get_cluster_graph(self, engine="fdp", graph_attr=None, node_attr=None, edge_attr=None):
"""
Generate directory graph in the DOT language. Directories are shown as clusters
.. warning::
This function scans the entire directory tree starting from top so the resulting
graph can be really big.
Args:
engine: Layout command used. ['dot', 'neato', 'twopi', 'circo', 'fdp', 'sfdp', 'patchwork', 'osage']
graph_attr: Mapping of (attribute, value) pairs for the graph.
node_attr: Mapping of (attribute, value) pairs set for all nodes.
edge_attr: Mapping of (attribute, value) pairs set for all edges.
Returns: graphviz.Digraph <https://graphviz.readthedocs.io/en/stable/api.html#digraph>
"""
# https://www.graphviz.org/doc/info/
from graphviz import Digraph
g = Digraph("directory", #filename="flow_%s.gv" % os.path.basename(self.relworkdir),
engine=engine) # if engine == "automatic" else engine)
# Set graph attributes.
#g.attr(label="%s@%s" % (self.__class__.__name__, self.relworkdir))
g.attr(label=self.top)
#g.attr(fontcolor="white", bgcolor='purple:pink')
#g.attr(rankdir="LR", pagedir="BL")
#g.attr(constraint="false", pack="true", packMode="clust")
g.node_attr.update(color='lightblue2', style='filled')
#g.node_attr.update(ranksep='equally')
# Add input attributes.
if graph_attr is not None:
fg.graph_attr.update(**graph_attr)
if node_attr is not None:
fg.node_attr.update(**node_attr)
if edge_attr is not None:
fg.edge_attr.update(**edge_attr)
def node_kwargs(path):
return dict(
#shape="circle",
#shape="none",
#shape="plaintext",
#shape="point",
shape="record",
#color=node.color_hex,
fontsize="8.0",
label=os.path.basename(path),
)
edge_kwargs = dict(arrowType="vee", style="solid", minlen="1")
cluster_kwargs = dict(rankdir="LR", pagedir="BL", style="rounded", bgcolor="azure2")
# TODO: Write other method without clusters if not walk.
exclude_top_node = False
for root, dirs, files in os.walk(self.top):
if exclude_top_node and root == self.top: continue
cluster_name = "cluster_%s" % root
#print("root", root, cluster_name, "dirs", dirs, "files", files, sep="\n")
with g.subgraph(name=cluster_name) as d:
d.attr(**cluster_kwargs)
d.attr(rank="source" if (files or dirs) else "sink")
d.attr(label=os.path.basename(root))
for f in files:
filepath = os.path.join(root, f)
d.node(filepath, **node_kwargs(filepath))
if os.path.islink(filepath):
# Follow the link and use the relpath wrt link as label.
realp = os.path.realpath(filepath)
realp = os.path.relpath(realp, filepath)
#realp = os.path.relpath(realp, self.top)
#print(filepath, realp)
#g.node(realp, **node_kwargs(realp))
g.edge(filepath, realp, **edge_kwargs)
for dirname in dirs:
dirpath = os.path.join(root, dirname)
#head, basename = os.path.split(dirpath)
new_cluster_name = "cluster_%s" % dirpath
#rank = "source" if os.listdir(dirpath) else "sink"
#g.node(dirpath, rank=rank, **node_kwargs(dirpath))
#g.edge(dirpath, new_cluster_name, **edge_kwargs)
#d.edge(cluster_name, new_cluster_name, minlen="2", **edge_kwargs)
d.edge(cluster_name, new_cluster_name, **edge_kwargs)
return g
# finalcgv.py - Curriculum Graph Visualizer
from graphviz import Digraph
c = Digraph('test_ie', filename='test_ie.gv')
c.attr('graph', fontname="Helvetica")
c.attr('node', fontname="Helvetica")
# c.attr('fontname="Arial"')
# legend
c0 = Digraph('cluster_0')
c0.body.append('label = "LEGEND"')
c0.body.append('color=lightgrey')
c0.node_attr.update(style='filled', color='white')
c0.edge_attr.update(color='white')
c0.node('Semester 6', color='plum')
c0.node('Semester 7', color='crimson')
c0.node('Semester 3', color='peachpuff')
c0.node('Semester 4', color='darkseagreen')
c0.node('Semester 5', color='lightblue')
c0.node('Completed', color='grey')
c0.node('Semester 1', color='pink')
c0.node('Semester 2', color='lightsalmon')
c0.node('Semester 8', color='chocolate')
c0.edge('Semester 6', 'Semester 7')
c0.edge('Semester 7', 'Semester 8')
c0.edge('Semester 7', 'Semester 8')
c0.edge('Semester 3', 'Semester 4')
c0.edge('Semester 4', 'Semester 5')
c0.edge('Completed', 'Semester 1')
c0.edge('Semester 1', 'Semester 2')
import chunks
from graphviz import Digraph
sentences = chunks.get_sentences_as_chunks()
def get_chunk_and_dst(chunk, chunks_for_sentence):
return (chunk, chunks_for_sentence[chunk.dst] if chunk.dst > 0 else None)
relates = list(map(lambda chunks_for_sentence: list(map(lambda chunk: get_chunk_and_dst(chunk, chunks_for_sentence), chunks_for_sentence)), sentences))
sentence = relates[7]
graph = Digraph(format='png')
graph.attr('node', shape='circle')
for index, relate in enumerate(sentence):
graph.node(str(index), relate[0].get_surfaces_without_symbol())
for index, relate in enumerate(sentence):
if relate[1] != None:
graph.edge(str(index), str(relate[0].dst))
graph.render('output')
from graphviz import Digraph
import numpy as np
f = Digraph('Markov_Chain_Diagram', format = 'png')
f.body.extend(['rankdir=LR', 'size="10, 10"'])
A = np.loadtxt('../model/modelnhidden5groupAtrans.txt')
f.attr('node', shape='doublecircle')
f.node('START')
f.node('END')
DIM = A.shape[0] - 2
f.attr('node', shape='circle')
for it in range(DIM):
if(A[-2,it]>1e-4): # plot the edge only the probability is greater than 1e-4
f.edge('START', '{0}'.format(it), label= str(round(A[-2, it], 3)))
for it in range(DIM):
if(A[it,-1]>1e-4):
f.edge('{0}'.format(it), 'END', label= str(round(A[it, -1], 3)))
for outer_it in range(DIM):
for inner_it in range(DIM):
if(A[outer_it,inner_it]>1e-4):
f.edge('{0}'.format(outer_it), '{0}'.format(inner_it), label= str(round(A[outer_it,inner_it], 3)))
f.render(filename = 'HiddenMarkov{0}'.format(DIM), view = True)
def generateGraph( facts, input, output ):
dot = Digraph(comment='expert_system')
dot.strict = True
for fact in sorted(facts):
dot.attr('node', shape='circle')
dot.node(fact)
for rule in facts[fact].getRules():
dot.attr('node', shape='box')
dot.node(rule.getRule())
for fact in sorted(facts):
for rule in facts[fact].getRules():
dot.edge(rule.getRule(),fact)
for factFromRule in rule.getFacts():
dot.edge(factFromRule, rule.getRule())
dot.render('output', view=True)
def draw(self):
g = Digraph(filename='./temp/tmp.gv', format='png')
g.body.extend(['rankdir=LR'])
# accepting states
g.attr('node', shape='doublecircle')
for state in self.acceptingStates:
g.node(str(state))
# other states
g.attr('node', shape='circle')
for state in self.states:
if not state in self.acceptingStates:
g.node(str(state))
# transitions
for transition in self.transitions:
g.edge(str(transition.fromState), str(transition.toState), str(transition.symbol))
# Initial state initialization
g.attr('node', shape='plaintext')
g.node('')
g.edge('', str(self.initialState))
g.view()
