def _render_graph(source_to_targets, node_to_label, metric_name,
node_to_value):
g = AGraph(directed=True)
# Gather all nodes in graph
all_nodes = set(source_to_targets.keys())
for targets in source_to_targets.values():
all_nodes.update(targets)
# Build graphviz graph
for node in all_nodes:
if node not in node_to_value:
continue
cmap = mpl.cm.get_cmap('viridis')
rgba = cmap(node_to_value[node])
color_value = mpl.colors.rgb2hex(rgba)
if node_to_value[node] > 0.5:
font_color = 'black'
else:
font_color = 'white'
g.add_node(node_to_label[node],
label=node_to_label[node],
fontname='arial',
style='filled',
fontcolor=font_color,
fillcolor=color_value)
for source, targets in source_to_targets.items():
for target in targets:
if source in node_to_value and target in node_to_value:
g.add_edge(node_to_label[source], node_to_label[target])
return g
def visualize_streams(goals, constants, filename='graph.pdf'):
from pygraphviz import AGraph
import subprocess
graph = AGraph(strict=True, directed=False)
graph.node_attr['style'] = 'filled'
graph.node_attr['shape'] = 'circle'
graph.node_attr['fontcolor'] = 'black'
graph.node_attr['colorscheme'] = 'SVG'
graph.edge_attr['colorscheme'] = 'SVG'
for constant in constants:
graph.add_node(str(constant), shape='box', color='LightGreen')
for goal in goals:
name = '\n'.join(
str(arg) for arg in [goal.predicate.name] + list(goal.args))
#name = str(goal)
graph.add_node(name, shape='box', color='LightBlue')
for arg in goal.args:
if isinstance(arg, AbstractConstant):
arg_name = str(arg)
graph.add_edge(name, arg_name)
#import os
#import webbrowser
graph.draw(filename, prog='dot')
subprocess.Popen('open %s' % filename, shell=True)
#os.system(filename)
#webbrowser.open(filename)
raw_input('Display?')
#safe_remove(filename)
return graph
def render(self, filename):
g = AGraph(strict=False, directed=True)
# create nodes
for frame_id, node in self.callers.items():
label = "{ %s }" % node
g.add_node(frame_id, shape='Mrecord', label=label,
fontsize=13, labelfontsize=13)
# create edges
for frame_id, node in self.callers.items():
child_nodes = []
for child_id in node.child_methods:
child_nodes.append(child_id)
g.add_edge(frame_id, child_id)
# order edges l to r
if len(child_nodes) > 1:
sg = g.add_subgraph(child_nodes, rank='same')
sg.graph_attr['rank'] = 'same'
prev_node = None
for child_node in child_nodes:
if prev_node:
sg.add_edge(prev_node, child_node, color="#ffffff")
prev_node = child_node
g.layout()
g.draw(path=filename, prog='dot')
print("callviz: rendered to %s" % filename)
self.clear()
def get_graphviz(self,
triple_args_function=None,
ignore_properties=VIS_IGNORE_PROPERTIES):
"""
Create a pygraphviz graph from the tree
"""
def _id(node):
return node.uri.split("/")[-1]
g = AGraph(directed=True)
triples = list(self.get_triples())
nodeset = set(
chain.from_iterable((t.subject, t.object) for t in triples))
for n in nodeset:
label = "%s: %s" % (n.id, n.word)
for k, v in n.__dict__.iteritems():
if k not in ignore_properties:
label += "\\n%s: %s" % (k, v)
g.add_node(_id(n), label=label)
# create edges
for triple in triples:
kargs = (triple_args_function(triple)
if triple_args_function else {})
if 'label' not in kargs:
kargs['label'] = triple.predicate
g.add_edge(_id(triple.subject), _id(triple.object), **kargs)
# some theme options
g.graph_attr["rankdir"] = "BT"
g.node_attr["shape"] = "rect"
g.edge_attr["edgesize"] = 10
g.node_attr["fontsize"] = 10
g.edge_attr["fontsize"] = 10
return g
class FSM(object):
'''Finite State Machine'''
def __init__(self, finite_states):
self.states = finite_states
nodes = {
state : []
for state in finite_states
}
self.graph = AGraph(nodes, directed=True, strict=False)
self.edgesize = len(nodes) / 5.0
def validate(self, *args):
for arg in args:
assert arg in self.states, arg
def transition(self, src, dest, label='', **kwargs):
self.validate(src, dest)
self.graph.add_edge(src, dest, label=label, len=self.edgesize, **kwargs)
def success(self, src, dest, label=''):
self.transition(src, dest, label, color='green')
def fail(self, src, dest, label=''):
self.transition(src, dest, label, color='red')
def save(self,name='graph',prog='dot'):
self.graph.layout(prog=prog)
self.graph.draw('{}.png'.format(name))
def render(self, filename):
g = AGraph(strict=False, directed=True)
# create nodes
for frame_id, node in self.callers.items():
label = "{ %s }" % node
g.add_node(frame_id,
shape='Mrecord',
label=label,
fontsize=13,
labelfontsize=13)
# create edges
for frame_id, node in self.callers.items():
child_nodes = []
for child_id in node.child_methods:
child_nodes.append(child_id)
g.add_edge(frame_id, child_id)
# order edges l to r
if len(child_nodes) > 1:
sg = g.add_subgraph(child_nodes, rank='same')
sg.graph_attr['rank'] = 'same'
prev_node = None
for child_node in child_nodes:
if prev_node:
sg.add_edge(prev_node, child_node, color="#ffffff")
prev_node = child_node
g.layout()
g.draw(path=filename, prog='dot')
print("rendered to %s" % filename)
self.clear()
def visualize_stream_orders(orders,
streams=[],
filename='stream_orders' + DEFAULT_EXTENSION):
from pygraphviz import AGraph
graph = AGraph(strict=True, directed=True)
graph.node_attr['style'] = 'filled'
graph.node_attr['shape'] = 'box'
graph.node_attr['color'] = STREAM_COLOR
graph.node_attr['fontcolor'] = 'black'
#graph.node_attr['fontsize'] = 12
graph.node_attr['width'] = 0
graph.node_attr['height'] = 0.02 # Minimum height is 0.02
graph.node_attr['margin'] = 0
graph.graph_attr['outputMode'] = 'nodesfirst'
graph.graph_attr['dpi'] = 300
streams = set(streams) | set(flatten(orders))
for stream in streams:
graph.add_node(str(stream))
for stream1, stream2 in orders:
graph.add_edge(str(stream1), str(stream2))
# TODO: could also print the raw values (or a lookup table)
# https://stackoverflow.com/questions/3499056/making-a-legend-key-in-graphviz
graph.draw(filename, prog='dot')
print('Saved', filename)
#display_image(filename)
return graph
def get_graphviz(self, triple_args_function=None,
ignore_properties=VIS_IGNORE_PROPERTIES):
"""
Create a pygraphviz graph from the tree
"""
def _id(node):
return node.uri.split("/")[-1]
g = AGraph(directed=True)
triples = list(self.get_triples())
nodeset = set(chain.from_iterable((t.subject, t.object)
for t in triples))
for n in nodeset:
label = "%s: %s" % (n.id, n.word)
for k, v in n.__dict__.iteritems():
if k not in ignore_properties:
label += "\\n%s: %s" % (k, v)
g.add_node(_id(n), label=label)
# create edges
for triple in triples:
kargs = (triple_args_function(triple)
if triple_args_function else {})
if 'label' not in kargs:
kargs['label'] = triple.predicate
g.add_edge(_id(triple.subject), _id(triple.object), **kargs)
# some theme options
g.graph_attr["rankdir"] = "BT"
g.node_attr["shape"] = "rect"
g.edge_attr["edgesize"] = 10
g.node_attr["fontsize"] = 10
g.edge_attr["fontsize"] = 10
return g
def plan_library_to_graphviz(planlibrary):
"""Converts a plan library into a graphviz data structure"""
G = AGraph()
for a in planlibrary:
G.add_edge(a.path[0], a.path[1])
return G
def plot(table_names=None):
"""
Plot relationships between columns and tables using Graphviz.
Parameters
----------
table_names : iterable of str, optional
Names of UrbanSim registered tables to plot.
Defaults to all registered tables.
Returns
-------
graph : pygraphviz.AGraph
PyGraphviz graph object.
"""
if not table_names:
# Default to all registered tables.
table_names = simulation.list_tables()
graph = AGraph(directed=True)
graph.graph_attr['fontname'] = 'Sans'
graph.graph_attr['fontsize'] = 28
graph.node_attr['shape'] = 'box'
graph.node_attr['fontname'] = 'Sans'
graph.node_attr['fontcolor'] = 'blue'
graph.edge_attr['weight'] = 2
# Add each registered table as a subgraph with columns as nodes.
for table_name in table_names:
subgraph = graph.add_subgraph(name='cluster_' + table_name,
label=table_name,
fontcolor='red')
table = simulation.get_table(table_name)
for column_name in table.columns:
full_name = table_name + '.' + column_name
subgraph.add_node(full_name, label=column_name)
# Iterate over computed columns to build nodes.
for key, wrapped_col in simulation._COLUMNS.items():
table_name = key[0]
column_name = key[1]
# Combine inputs from argument names and argument default values.
args = list(wrapped_col._argspec.args)
if wrapped_col._argspec.defaults:
default_args = list(wrapped_col._argspec.defaults)
else:
default_args = []
inputs = args[:len(args) - len(default_args)] + default_args
# Create edge from each input column to the computed column.
for input_name in inputs:
full_name = table_name + '.' + column_name
graph.add_edge(input_name, full_name)
graph.layout(prog='dot')
return graph
def visualize_constraints(constraints, filename='constraint_network.pdf', use_functions=True):
from pygraphviz import AGraph
graph = AGraph(strict=True, directed=False)
graph.node_attr['style'] = 'filled'
#graph.node_attr['fontcolor'] = 'black'
#graph.node_attr['fontsize'] = 12
graph.node_attr['colorscheme'] = 'SVG'
graph.edge_attr['colorscheme'] = 'SVG'
#graph.graph_attr['rotate'] = 90
#graph.node_attr['fixedsize'] = True
graph.node_attr['width'] = 0
graph.node_attr['height'] = 0.02 # Minimum height is 0.02
graph.node_attr['margin'] = 0
graph.graph_attr['rankdir'] = 'RL'
graph.graph_attr['nodesep'] = 0.05
graph.graph_attr['ranksep'] = 0.25
#graph.graph_attr['pad'] = 0
# splines="false";
graph.graph_attr['outputMode'] = 'nodesfirst'
graph.graph_attr['dpi'] = 300
functions = set()
negated = set()
heads = set()
for fact in constraints:
prefix = get_prefix(fact)
if prefix in (EQ, MINIMIZE):
functions.add(fact[1])
elif prefix == NOT:
negated.add(fact[1])
else:
heads.add(fact)
heads.update(functions)
heads.update(negated)
objects = {a for head in heads for a in get_args(head)}
optimistic_objects = filter(lambda o: isinstance(o, OptimisticObject), objects)
for opt_obj in optimistic_objects:
graph.add_node(str(opt_obj), shape='circle', color=PARAMETER_COLOR)
for head in heads:
if not use_functions and (head in functions):
continue
# TODO: prune values w/o free parameters?
name = str_from_fact(head)
if head in functions:
color = COST_COLOR
elif head in negated:
color = NEGATED_COLOR
else:
color = CONSTRAINT_COLOR
graph.add_node(name, shape='box', color=color)
for arg in get_args(head):
if arg in optimistic_objects:
graph.add_edge(name, str(arg))
graph.draw(filename, prog='dot') # neato | dot | twopi | circo | fdp | nop
return graph
def plot(table_names=None):
"""
Plot relationships between columns and tables using Graphviz.
Parameters
----------
table_names : iterable of str, optional
Names of UrbanSim registered tables to plot.
Defaults to all registered tables.
Returns
-------
graph : pygraphviz.AGraph
PyGraphviz graph object.
"""
if not table_names:
# Default to all registered tables.
table_names = simulation.list_tables()
graph = AGraph(directed=True)
graph.graph_attr['fontname'] = 'Sans'
graph.graph_attr['fontsize'] = 28
graph.node_attr['shape'] = 'box'
graph.node_attr['fontname'] = 'Sans'
graph.node_attr['fontcolor'] = 'blue'
graph.edge_attr['weight'] = 2
# Add each registered table as a subgraph with columns as nodes.
for table_name in table_names:
subgraph = graph.add_subgraph(name='cluster_' + table_name,
label=table_name, fontcolor='red')
table = simulation.get_table(table_name)
for column_name in table.columns:
full_name = table_name + '.' + column_name
subgraph.add_node(full_name, label=column_name)
# Iterate over computed columns to build nodes.
for key, wrapped_col in simulation._COLUMNS.items():
table_name = key[0]
column_name = key[1]
# Combine inputs from argument names and argument default values.
args = list(wrapped_col._argspec.args)
if wrapped_col._argspec.defaults:
default_args = list(wrapped_col._argspec.defaults)
else:
default_args = []
inputs = args[:len(args) - len(default_args)] + default_args
# Create edge from each input column to the computed column.
for input_name in inputs:
full_name = table_name + '.' + column_name
graph.add_edge(input_name, full_name)
graph.layout(prog='dot')
return graph
def visualize_stream_plan_bipartite(stream_plan,
filename='stream_plan' + DEFAULT_EXTENSION,
use_functions=False):
from pygraphviz import AGraph
graph = AGraph(strict=True, directed=True)
graph.node_attr['style'] = 'filled'
graph.node_attr['shape'] = 'box'
graph.node_attr['fontcolor'] = 'black'
#graph.node_attr['fontsize'] = 12
graph.node_attr['width'] = 0
graph.node_attr['height'] = 0.02 # Minimum height is 0.02
graph.node_attr['margin'] = 0
#graph.graph_attr['rankdir'] = 'LR'
graph.graph_attr['nodesep'] = 0.1
graph.graph_attr['ranksep'] = 0.25
graph.graph_attr['outputMode'] = 'nodesfirst'
graph.graph_attr['dpi'] = 300
# TODO: store these settings as a dictionary
def add_fact(fact):
head, color = (fact[1], COST_COLOR) if get_prefix(fact) == EQ else (
fact, CONSTRAINT_COLOR)
s_fact = str_from_fact(head)
graph.add_node(s_fact, color=color)
return s_fact
def add_stream(stream):
color = FUNCTION_COLOR if isinstance(stream,
FunctionResult) else STREAM_COLOR
s_stream = str(stream.instance) if isinstance(
stream, FunctionResult) else str(stream)
graph.add_node(s_stream, style='rounded,filled', color=color)
# shape: oval, plaintext, polygon, rarrow, cds
# style: rounded, filled, bold
return s_stream
achieved_facts = set()
for stream in stream_plan:
if not use_functions and isinstance(stream, FunctionResult):
continue
s_stream = add_stream(stream)
for fact in stream.instance.get_domain():
if fact in achieved_facts:
s_fact = add_fact(fact)
graph.add_edge(s_fact, s_stream) # Add initial facts?
#if not isinstance(stream, StreamResult):
# continue
for fact in stream.get_certified():
if fact not in achieved_facts: # Ensures DAG
s_fact = add_fact(fact)
graph.add_edge(s_stream, s_fact)
achieved_facts.add(fact)
graph.draw(filename, prog='dot')
print('Saved', filename)
return graph
def cm_json_to_graph(cm_json):
"""Return pygraphviz Agraph from Kappy's contact map JSON.
Parameters
----------
cm_json : dict
A JSON dict which contains a contact map generated by Kappy.
Returns
-------
graph : pygraphviz.Agraph
A graph representing the contact map.
"""
cmap_data = get_cmap_data_from_json(cm_json)
# Initialize the graph
graph = AGraph()
# In this loop we add sites as nodes and clusters around sites to the
# graph. We also collect edges to be added between sites later.
edges = []
for node_idx, node in enumerate(cmap_data):
sites_in_node = []
for site_idx, site in enumerate(node['node_sites']):
# We map the unique ID of the site to its name
site_key = (node_idx, site_idx)
sites_in_node.append(site_key)
graph.add_node(site_key,
label=site['site_name'],
style='filled',
shape='ellipse')
# Each port link is an edge from the current site to the
# specified site
if not site['site_type'] or not site['site_type'][0] == 'port':
continue
# As of kappy 4.1.2, the format of port links have changed
# Old format: [[1, 0]], New format: [[[0, 1], 0]]
for port_link in site['site_type'][1]['port_links']:
port_link = tuple([
link[1] if isinstance(link, list) else link
for link in port_link
])
if isinstance(port_link, list):
port_link = port_link[1]
edge = (site_key, tuple(port_link))
edges.append(edge)
graph.add_subgraph(sites_in_node,
name='cluster_%s' % node['node_type'],
label=node['node_type'])
# Finally we add the edges between the sites
for source, target in edges:
graph.add_edge(source, target)
return graph
def add_graph(g: AGraph, layer_graph: tx.Graph, cluster):
for node in layer_graph.nodes:
# HTML for record nodes https://graphviz.org/doc/info/shapes.html#top
g.add_node(f"{cluster}_{node.name}",
shape="none",
margin=0,
label=tx.utils.vizstyle(node))
for node in layer_graph.nodes:
for other_node in layer_graph.edges_out[node]:
g.add_edge(f"{cluster}_{node.name}",
f"{cluster}_{other_node.name}")
def _render(self, costs=False, word_probs=False, highlight_best=False):
from pygraphviz import AGraph
graph = AGraph(directed=True)
for node_id, node_label in self.nodes.iteritems():
attributes = self._node_attr(node_id, costs=costs, word_probs=word_probs)
graph.add_node(node_id, **attributes)
for (parent_node_id, child_node_id) in self.edges:
graph.add_edge(parent_node_id, child_node_id)
self.graph = graph
if highlight_best:
self._highlight_best()
def draw_workflow(filename, workflow):
dot = AGraph(directed=True, strict=False) # (comment="Computing scheme")
for i, n in workflow.nodes.items():
dot.add_node(i, label="{0} \n {1}".format(n.foo.__name__, _format_arg_list(n.bound_args.args, None)))
for i in workflow.links:
for j in workflow.links[i]:
dot.add_edge(i, j[0], j[1].name) # , headlabel=j[1].name, labeldistance=1.8)
dot.layout(prog="dot")
dot.draw(filename)
def _render(self, costs=False, word_probs=False, highlight_best=False):
from pygraphviz import AGraph
graph = AGraph(directed=True)
for node_id, node_label in self.nodes.iteritems():
attributes = self._node_attr(node_id, costs=costs, word_probs=word_probs)
graph.add_node(node_id, **attributes)
for (parent_node_id, child_node_id) in self.edges:
graph.add_edge(parent_node_id, child_node_id)
self.graph = graph
if highlight_best:
self._highlight_best()
def visualize(self, name='lp'):
ls = self.edge_list()
G = AGraph(directed=True)
for (_id, label, next_id, next_label, edge_label) in ls:
G.add_node(_id, label=label)
G.add_node(next_id, label=next_label)
G.add_edge(_id, next_id, label=edge_label)
G.layout(prog='dot')
G.draw(name + '.png')
def draw_workflow(filename, workflow):
dot = AGraph(directed=True) # (comment="Computing scheme")
for i, n in workflow.nodes.items():
dot.add_node(i, label="{0} \n {1}".format(
n.foo.__name__, _format_arg_list(n.bound_args.args, None)))
for i in workflow.links:
for j in workflow.links[i]:
dot.add_edge(i, j[0])
dot.layout(prog='dot')
dot.draw(filename)
def get_image():
global TIMESTAMP
ip_dict = {
} # maps source-destination IP pairs to their number of occurrences
trace_file = open(LOG_PATH, newline='')
local_timestamp = TIMESTAMP
for line in trace_file.readlines():
split_line = line.split('|')
if len(split_line) == 4:
timestamp = float(split_line[0].split('[')[1].split(']')[0])
if timestamp > local_timestamp:
src_dst_pair = (split_line[1], split_line[2])
if src_dst_pair in ip_dict.keys():
ip_dict[src_dst_pair] = ip_dict[src_dst_pair] + 1
else:
ip_dict[src_dst_pair] = 1
local_timestamp = timestamp
if local_timestamp > TIMESTAMP:
ip_graph = AGraph(directed=True)
for (src_ip, dst_ip), packet_count in ip_dict.items():
ip_graph.add_edge(src_ip,
dst_ip,
color='brown',
label=packet_count,
labelangle=45,
len=1.95)
ip_graph.layout()
ip_graph.draw('graph.png')
TIMESTAMP = local_timestamp
graph_img = Image.open('graph.png')
graph_img.thumbnail((720, 720))
background_image = Image.new('RGB', SIZE, color=(255, 255, 255))
x = round((SIZE[0] / 2.0) - graph_img.width)
y = round((SIZE[1] / 4.0) - (graph_img.height / 4.0))
background_image.paste(graph_img, (x, y))
return background_image
class Visualizer:
def __init__(self, hsm):
self.graph = AGraph(strict=False,
directed=True,
name=type(hsm).__name__)
self._load_transitions(hsm)
def _load_transitions(self, hsm, group=None):
prefix = group + "." if group else ""
nodes = []
for t in hsm.transitions:
# if origin is an HSM we have to connect from it's final node
if issubclass(t["from"], HSM):
u = prefix + t["from"].__name__ + ".FINAL"
else:
u = prefix + t["from"].__name__
nodes.append(u)
# if we connect to an HSM we must create a new substructure and load from the hsm recursively
if issubclass(t["to"], HSM):
sub = t["to"].__name__
v = prefix + sub + "." + t["to"].init_state.__name__
nodes.append(v)
self._load_transitions(t["to"], group=sub)
# there is always only one FAILED
elif issubclass(t["to"], FAILED):
v = FAILED.__name__
else:
v = prefix + t["to"].__name__
nodes.append(v)
# finally add it to the graph
self.graph.add_edge(u,
v,
label=self._get_condition_string(
t["condition"]))
sg = self.graph.add_subgraph(nodes,
name="cluster_" + prefix,
style="dotted") #TODO not done here yet
def _get_condition_string(self, cond):
if isinstance(cond, dict):
return str(list(cond.keys())[0].name) + ": " + str(
list(cond.values())[0])
elif callable(cond):
return cond.__name__
return cond.name
def save_graph(self, filename):
self.graph.layout(prog="dot")
self.graph.draw(filename)
def render_local(self, filename):
"""Renders the OBST image locally using pygraphviz."""
# Get the graph information
node_list, edge_list = self.__generate_image()
# Generate the graph
from pygraphviz import AGraph
G=AGraph(strict=True,directed=True) # Create a graph
for node in node_list:
G.add_node(node)
for edge in edge_list:
G.add_edge(edge[0], edge[1])
G.layout('dot') # Set hierarchical layout
G.draw(filename) # Save the image.
def to_dot(self, filename, edges):
from pygraphviz import AGraph
dot = AGraph(directed=True)
for n in edges.keys():
dot.add_node(str(n))
if lib.qcgc_arena_get_blocktype(ffi.cast("cell_t *", n)) not in [
lib.BLOCK_BLACK, lib.BLOCK_WHITE]:
node = dot.get_node(str(n))
node.attr['color'] = 'red'
for n in edges.keys():
if edges[n] is not None:
dot.add_edge(str(n), str(edges[n]))
dot.layout(prog='dot')
dot.draw(filename)
def to_dot(self, filename, edges):
from pygraphviz import AGraph
dot = AGraph(directed=True)
for n in edges.keys():
dot.add_node(str(n))
if lib.qcgc_arena_get_blocktype(ffi.cast(
"cell_t *", n)) not in [lib.BLOCK_BLACK, lib.BLOCK_WHITE]:
node = dot.get_node(str(n))
node.attr['color'] = 'red'
for n in edges.keys():
if edges[n] is not None:
dot.add_edge(str(n), str(edges[n]))
dot.layout(prog='dot')
dot.draw(filename)
def as_graph(self, to=None):
from pygraphviz import AGraph
g = AGraph(directed=True)
for a in self.activities.values():
g.add_node(a.title, label=a.title)
for t in self.transitions.values():
g.add_edge(t.input.title, t.output.title, label=t.name)
if to:
g.write(to)
else:
return str(g)
def _construct_graph(graph: gz.AGraph, state):
graph.add_node(
state.id_nr,
label=_state_to_node(state),
shape="record",
)
for move, next_state in state.next_states.items():
if next_state:
_construct_graph(graph, next_state)
graph.add_edge(u=state.id_nr,
v=next_state.id_nr,
key="l",
label=str(move))
def single_layer(list_of_task_dicts: list, list_of_task_tuples: list,
recursive_depth: int, parent: str, file_name: str) -> None:
"""
each SVG has nodes and hyperlinks; no subgraphs
"""
use_case = AGraph(directed=True)
use_case.clear()
use_case.graph_attr.update(compound="true")
for task_tup in list_of_task_tuples:
#print(task_tup)
if task_has_children_in_list_of_task_dicts(task_tup,
list_of_task_dicts):
#print(" has child, so hyperlink")
use_case.add_node(
smush(task_tup),
label=with_spaces(task_tup),
color="blue", # to indicate hyperlink
shape=
"rectangle", # to distinguish from nodes that do not have children
href="single_layer_" + str(recursive_depth + 1) + "_" +
smush(task_tup) + ".svg")
for task_dist in list_of_task_dicts:
if task_tup in task_dist.keys():
#for task_tup in task_dist[task_tup]:
single_layer(list_of_task_dicts,
task_dist[task_tup],
recursive_depth + 1,
"single_layer_" + str(recursive_depth) + "_" +
file_name,
file_name=smush(task_tup))
else:
#print(" no children, so create node")
use_case.add_node(smush(task_tup), label=with_spaces(task_tup))
if recursive_depth > 0:
use_case.add_node("zoom out",
href=parent + ".svg",
color="red",
shape="triangle")
for index, task_tup in enumerate(list_of_task_tuples[1:]):
use_case.add_edge(smush(list_of_task_tuples[index]), smush(task_tup))
use_case.write("single_layer_" + str(recursive_depth) + "_" + file_name +
".dot")
use_case.draw("single_layer_" + str(recursive_depth) + "_" + file_name +
".svg",
format="svg",
prog="dot")
return
def crear_grafo_invocaciones(datos_csv):
'''[Autor: Ivan Litteri]
[Ayuda: crea grafo.svg y grafo.png]'''
g = AGraph(directed=True, rankdir='LR')
for funcion in datos:
g.add_node(funcion)
for i in datos[funcion]["invocaciones"]:
g.add_edge((funcion, i))
g.layout(prog='dot')
g.draw('grafo.svg')
g.draw('grafo.png')
def draw_finite_state_machine(finite_state_machine: FiniteStateMachine,
path: str):
"""Creates a directed non-strict multi graph image representation of the FSM."""
from pygraphviz import AGraph
graph = AGraph(strict=False, directed=True)
graph.add_nodes_from(finite_state_machine.state_set)
for initial_state in finite_state_machine.initial_states:
graph.get_node(initial_state).attr["color"] = "green"
for element, transitions in finite_state_machine.transitions.items():
for from_state, to_states in transitions.items():
for to_state in to_states:
graph.add_edge(from_state, to_state, label=element)
for final_state in finite_state_machine.final_states:
graph.get_node(final_state).attr["color"] = "red"
graph.draw(path, prog="dot")
def visualize_stream_plan(stream_plan, filename='stream_plan.pdf'):
from pygraphviz import AGraph
graph = AGraph(strict=True, directed=True)
graph.node_attr['style'] = 'filled'
graph.node_attr['shape'] = 'box'
graph.node_attr['color'] = STREAM_COLOR
for stream in stream_plan:
graph.add_node(str(stream))
for stream1, stream2 in get_partial_orders(stream_plan):
graph.add_edge(str(stream1), str(stream2))
# TODO: could also print the raw values (or a lookup table)
# https://stackoverflow.com/questions/3499056/making-a-legend-key-in-graphviz
graph.draw(filename, prog='dot')
return graph
def cm_json_to_graph(im_json):
"""Return pygraphviz Agraph from Kappy's contact map JSON.
Parameters
----------
im_json : dict
A JSON dict which contains a contact map generated by Kappy.
Returns
-------
graph : pygraphviz.Agraph
A graph representing the contact map.
"""
cmap_data = im_json['contact map']['map']
# Initialize the graph
graph = AGraph()
# In this loop we add sites as nodes and clusters around sites to the
# graph. We also collect edges to be added between sites later.
edges = []
for node_idx, node in enumerate(cmap_data):
sites_in_node = []
for site_idx, site in enumerate(node['node_sites']):
# We map the unique ID of the site to its name
site_key = (node_idx, site_idx)
sites_in_node.append(site_key)
graph.add_node(site_key,
label=site['site_name'],
style='filled',
shape='ellipse')
# Each port link is an edge from the current site to the
# specified site
if not site['site_type'] or not site['site_type'][0] == 'port':
continue
for port_link in site['site_type'][1]['port_links']:
edge = (site_key, tuple(port_link))
edges.append(edge)
graph.add_subgraph(sites_in_node,
name='cluster_%s' % node['node_type'],
label=node['node_type'])
# Finally we add the edges between the sites
for source, target in edges:
graph.add_edge(source, target)
return graph
def render_image(self, filename):
"""Renders the graph image locally using pygraphviz."""
# Create a graph
G=AGraph(directed=False)
# Add nodes
for node in self.nodes:
G.add_node(node)
# Add edges
for edge in self.edges:
G.add_edge(edge[0], edge[1], color='blue')
# Give layout and draw.
G.layout('circo')
G.draw(filename) # Save the image.
# Display the output image.
os.system("gwenview %s&" % filename)
def render_image(self, filename):
"""Renders the graph image locally using pygraphviz."""
# Create a graph
G = AGraph(directed=False)
# Add nodes
for node in self.nodes:
G.add_node(node)
# Add edges
for edge in self.edges:
G.add_edge(edge[0], edge[1], color='blue')
# Give layout and draw.
G.layout('circo')
G.draw(filename) # Save the image.
# Display the output image.
os.system("gwenview %s&" % filename)
def visualize_constraints(constraints,
filename='constraint_network' + DEFAULT_EXTENSION,
use_functions=True):
from pygraphviz import AGraph
graph = AGraph(strict=True, directed=False)
graph.node_attr['style'] = 'filled'
#graph.node_attr['fontcolor'] = 'black'
#graph.node_attr['fontsize'] = 12
graph.node_attr['colorscheme'] = 'SVG'
graph.edge_attr['colorscheme'] = 'SVG'
#graph.graph_attr['rotate'] = 90
#graph.node_attr['fixedsize'] = True
graph.node_attr['width'] = 0
graph.node_attr['height'] = 0.02 # Minimum height is 0.02
graph.node_attr['margin'] = 0
graph.graph_attr['rankdir'] = 'RL'
graph.graph_attr['nodesep'] = 0.05
graph.graph_attr['ranksep'] = 0.25
#graph.graph_attr['pad'] = 0
# splines="false";
graph.graph_attr['outputMode'] = 'nodesfirst'
graph.graph_attr['dpi'] = 300
positive, negated, functions = partition_facts(constraints)
for head in (positive + negated + functions):
# TODO: prune values w/o free parameters?
name = str_from_fact(head)
if head in functions:
if not use_functions:
continue
color = COST_COLOR
elif head in negated:
color = NEGATED_COLOR
else:
color = CONSTRAINT_COLOR
graph.add_node(name, shape='box', color=color)
for arg in get_args(head):
if isinstance(arg, OptimisticObject) or is_parameter(arg):
arg_name = str(arg)
graph.add_node(arg_name, shape='circle', color=PARAMETER_COLOR)
graph.add_edge(name, arg_name)
graph.draw(filename, prog='dot') # neato | dot | twopi | circo | fdp | nop
print('Saved', filename)
return graph
def cm_json_to_graph(im_json):
"""Return pygraphviz Agraph from Kappy's contact map JSON.
Parameters
----------
im_json : dict
A JSON dict which contains a contact map generated by Kappy.
Returns
-------
graph : pygraphviz.Agraph
A graph representing the contact map.
"""
cmap_data = im_json['contact map']['map']
# Initialize the graph
graph = AGraph()
# In this loop we add sites as nodes and clusters around sites to the
# graph. We also collect edges to be added between sites later.
edges = []
for node_idx, node in enumerate(cmap_data):
sites_in_node = []
for site_idx, site in enumerate(node['node_sites']):
# We map the unique ID of the site to its name
site_key = (node_idx, site_idx)
sites_in_node.append(site_key)
graph.add_node(site_key, label=site['site_name'], style='filled',
shape='ellipse')
# Each port link is an edge from the current site to the
# specified site
if not site['site_type'] or not site['site_type'][0] == 'port':
continue
for port_link in site['site_type'][1]['port_links']:
edge = (site_key, tuple(port_link))
edges.append(edge)
graph.add_subgraph(sites_in_node,
name='cluster_%s' % node['node_type'],
label=node['node_type'])
# Finally we add the edges between the sites
for source, target in edges:
graph.add_edge(source, target)
return graph
def draw_workflow(filename, workflow, paint=None):
dot = AGraph(directed=True) # (comment="Computing scheme")
dot.node_attr['style'] = 'filled'
for i, n in workflow.nodes.items():
dot.add_node(i,
label="{0} \n {1}".format(
n.foo.__name__,
_format_arg_list(n.bound_args.args, None)))
x = dot.get_node(i)
if paint:
paint(x, n.foo.__name__)
for i in workflow.links:
for j in workflow.links[i]:
dot.add_edge(i, j[0])
dot.layout(prog='dot')
dot.draw(filename)
def generate_graph(self) -> AGraph:
graph = AGraph(directed=True, splines='curved', overlap='vpsc')
for cfg in self.cfgs:
for bb in cfg.basic_blocks:
style = {}
if bb.type == 'BBExit':
style = dict(style='filled', color='#665c54')
if bb.type == 'BBEntry':
style = dict(style='filled', color='#458588')
graph.add_node(n=bb.id,
label=f'bb={bb.id} stmt={bb.stmt_id}',
**style)
for succ in bb.succs:
graph.add_edge(bb.id, succ)
for pred in bb.preds:
graph.add_edge(pred, bb.id)
return graph
def build_graph(score):
corpus= create_corpus(score)
calc_tf_idf(corpus, log_tf, log_idf)
#corpus= group_corpus(corpus, log_tf, log_idf)
g= AGraph(strict=False)
for i, d1 in enumerate(corpus):
d1_name= str(d1)
edges= [(d2, d2.similarity(d1)) for d2 in corpus[i+1:]]
edges.sort(key=lambda x:x[1], reverse=True)
edges= edges[:5]
for d2, weight in edges:
d2_name= str(d2)
g.add_edge(d1_name, d2_name)
e= g.get_edge(d1_name, d2_name)
e.attr['label']= str(weight)[:5]
#import ipdb;ipdb.set_trace()
return g
def get_dot(self, labeller=None):
self.labeller = labeller
a_graph = AGraph(directed=True)
nx_graph = self.graph.nx_graph
# TODO: Add some default stuff?
# a_graph.graph_attr.update(N.graph.get('graph',{}))
# a_graph.node_attr.update(N.graph.get('node',{}))
# a_graph.edge_attr.update(N.graph.get('edge',{}))
structural_nodes = []
output_nodes = []
input_nodes = []
# First, add nodes
for node in nx_graph.nodes():
name, attrs = self.get_node_attributes(node)
if self.graph.is_input(node):
input_nodes.append(name)
elif self.graph.is_structural(node):
structural_nodes.append(name)
elif self.graph.is_output(node):
output_nodes.append(name)
# Keep a reference to the original node
a_graph.add_node(name, **attrs)
# We need to add subgraphs to cluster stuff on rank
sub = a_graph.add_subgraph(input_nodes, name='input')
sub.graph_attr['rank'] = 'source'
sub = a_graph.add_subgraph(structural_nodes, name='structural')
sub.graph_attr['rank'] = 'same'
sub = a_graph.add_subgraph(output_nodes, name='output')
sub.graph_attr['rank'] = 'sink'
# Now add edges
for u, v, edgedata in nx_graph.edges_iter(data=True):
attrs = {}
a_graph.add_edge(self.graph.node_to_name(u),
self.graph.node_to_name(v),
**attrs)
return a_graph
def render_image(node_list, edge_list):
# Generate the graph
from pygraphviz import AGraph
G=AGraph(strict=False,directed=True) # Create a graph
for node in node_list:
G.add_node(node)
for edge in edge_list:
G.add_edge(edge[0], edge[1])
G.layout('dot') # Set hierarchical layout
filename = str(time())
postfix = 0
while exists(filename+str(postfix)+".png"):
postfix+=1
filename += str(postfix) + ".png"
G.draw(filename) # Save the image.
with open(filename, "rb") as handle:
return xmlrpclib.Binary(handle.read())
def write_graph(probs, path):
graph = AGraph(directed=True)
next_label = 0
labels = {}
for from_state, to_states in probs.iteritems():
if from_state not in labels:
labels[from_state] = next_label
next_label += 1
for to_state in to_states:
if to_state not in labels:
labels[to_state] = next_label
next_label += 1
for label in xrange(next_label):
graph.add_node(label, fillcolor="blue", label="", style="filled")
for from_state, to_states in probs.iteritems():
for to_state, prob in to_states.iteritems():
graph.add_edge(labels[from_state], labels[to_state], label="%.2g" % prob)
# prog: neato (default), dot, twopi, circo, fdp or nop.
graph.layout()
graph.draw(path)
def draw_graph(state_manager, filename):
graph = AGraph()
graph.node_attr["style"] = "filled"
graph.node_attr["shape"] = "circle"
graph.node_attr["fixedsize"] = "true"
graph.node_attr["width"] = 0.5
graph.node_attr["height"] = 0.5
# we add all nodes (keys = ID)
graph.add_nodes_from(state_manager.state.keys())
for var_id in state_manager.state:
# and for each of these nodes, we change color
node = graph.get_node(var_id)
node.attr["fillcolor"] = get_color(state_manager.state[var_id])
# finally, we add edges
for c in state_manager.constraints:
e = c.list_vars
graph.add_edge(e[0], e[1])
graph.write(filename)
def get_graphviz(self, triple_hook=graphviz_triple_hook,
node_hook=graphviz_node_hook,
theme_options=VIS_THEME_OPTIONS, **hook_options):
"""
Create a pygraphviz graph from the tree
@param triple_hook: a function that returns an attribute dict (or None)
given a triple and the kargs
@param node_hook: a function that returns a label given a node
and the kargs
@param theme_options: a dict-of-dicts containing global
graph/node/edge attributes
@param hook_options: additional arguments to pass to the hook functions
"""
def _id(node):
return node.uri.split("/")[-1]
g = AGraph(directed=True, strict=False)
triples = list(self.get_triples())
# create nodes
nodeset = set(chain.from_iterable((t.subject, t.object)
for t in triples))
for n in sorted(nodeset, key=lambda n:n.id):
g.add_node(_id(n), **node_hook(n, **hook_options))
connected = set()
# create edges
for triple in sorted(triples, key=lambda t:t.predicate):
kargs = triple_hook(triple, **hook_options)
if kargs:
if kargs.get('reverse'):
g.add_edge(_id(triple.object), _id(triple.subject), **kargs)
else:
g.add_edge(_id(triple.subject), _id(triple.object), **kargs)
connected |= {_id(triple.subject), _id(triple.object)}
connected = chain.from_iterable(g.edges())
for isolate in set(g.nodes()) - set(connected):
g.remove_node(isolate)
# some theme options
for obj, attrs in theme_options.iteritems():
for k, v in attrs.iteritems():
getattr(g, "%s_attr" % obj)[k] = v
return g
def _drawmap(fs, rulename=None):
"""Draw a map of the firewalls and their connections based on their interfaces.
If nulename is specified, draw also the sources and dests for a that rule. #TODO: implement this
"""
A = AGraph()
A.graph_attr['bgcolor'] = 'transparent'
# A.graph_attr['size'] = '8,5'
# Draw hosts
for h in fs.hosts:
A.add_node(h.hostname)
if h.network_fw in (1, True, '1'): # network firewall
f = Node(A, h.hostname)
f.attr['color'] = 'red'
# Draw nets
for net in fs.networks:
A.add_node(net.name)
poly = Node(A, net.name)
poly.attr['shape'] = 'polygon'
poly.attr['sides'] = '8'
# Connect hosts to nets
for host in fs.hosts:
on_Internet = True
for net in fs.networks:
if host in net:
on_Internet = False
A.add_edge(host.hostname, net.name)
e = Edge(A, host.hostname, net.name)
e.attr['label'] = host.iface
e.attr['fontsize'] = '6'
# If a host is not in any configured net, it's on the Internet
if on_Internet:
A.add_edge(host.hostname, 'Internet')
e = Edge(A, host.hostname, 'Internet')
e.attr['label'] = host.iface
e.attr['fontsize'] = '6'
A.layout(prog='circo')
return A
class DotRenderer(GraphRenderer):
"""Renderer fox dot."""
"""The AGraph used for rendering."""
_graph = None
def __init__(self, settings, reporter):
GraphRenderer.__init__(self, settings, reporter)
if not pygraphvizAvail:
self.reporter.severe("Can not render dot format because module `pygraphviz` cannot be loaded")
def prepare(self):
self._graph = AGraph(strict=False, directed=True,
name=self._visitor.sourceName)
def finish(self):
# TODO The ordering of nodes seems to be rather random in the output;
# however, the node ordering is used for the layout of the graph
# at least by `dot` and by `neato`; there should be a way to
# determine the ordering
r = self._graph.string()
self._graph = None
return r
def renderAnchor(self, anchor):
self._graph.add_node(anchor.id(), label=anchor.name())
def renderReference(self, reference):
if reference.fromAnchor is None:
# No anchor to start edge from
# TODO Should result in a warning
return
fromId = reference.fromAnchor.id()
toId = reference.toAnchor.id()
if self._doReverse:
(fromId, toId) = (toId, fromId)
self._graph.add_edge(fromId, toId)
def create_graph(graph_data, input_format, avatars):
def add_node(node):
attrs = {
'label': node,
'shape': 'circle',
'margin': 0,
'color': CIRCLES_BORDER_COLOR,
'fontcolor': TEXT_COLOR,
'fontsize': 10,
}
if avatars:
# TODO: Draw some placeholder image for users without avatars?
if 'avatar_url' in graph_data.get(node, {}):
attrs['image'] = get_avatar_path(node)
attrs['label'] = ''
attrs['xlabel'] = node
attrs['width'] = AVATAR_SIZE / DPI
attrs['height'] = AVATAR_SIZE / DPI
attrs['fixedsize'] = 'true'
graph.add_node(node, **attrs)
graph_attrs = {
'directed': True,
'dpi': DPI,
'background': BACKGROUND_COLOR,
}
if input_format == 'dot':
graph = AGraph(graph_data, **graph_attrs)
else:
graph = AGraph(**graph_attrs)
for username, info in six.iteritems(graph_data):
add_node(username)
for f in info.get('followers', []):
add_node(f)
graph.add_edge(f, username, color=ARROWS_BORDER_COLOR)
for f in info.get('following', []):
add_node(f)
graph.add_edge(username, f, color=ARROWS_BORDER_COLOR)
return graph
except Exception, e:
error.handleWarning("Could not load pickle instance: %s" % str(e))
return
# this method should be reimplemented in each child class -
# for instance, a directed graph should make a directed AGraph
# and a weighted graph should have weights displayed on edges
def makeImageObject(self):
try:
from pygraphviz import AGraph
except Exception, e:
self.error.handleFatal("Could not import pygraphviz package. If you're on windows, pygraphviz may not be installable.\n%s" % str(e))
image = AGraph()
for edge in self.edges_iter():
image.add_edge(*edge)
return image
def makeImage(self, filename="graphimage.png", prog = "dot"):
image = self.makeImageObject()
image.draw(filename, prog=prog)
def isWeighted(self):
return self.__class__.__name__ in ['GOXGraph', 'GOXDiGraph']
# Create a minimal spanning tree containing only some number of terms of interest and the pairwise shortest
# paths between them.
# @param goi The gene ontology terms of interest
class Plugin:
def __init__(self, title="System"):
self.schematic = AGraph(
directed=True,
label=title,
rankdir='LR',
splines='true'
)
self.nodes = []
self.edges = []
self.outputs = {}
self.ip_outputs = {}
#sources
def write_stimulus(self, stream):
self.nodes.append((id(stream), "Stimulus", "ellipse"))
def write_repeater(self, stream):
self.nodes.append(
(id(stream), "Repeater : {0}".format(stream.value), "ellipse")
)
def write_counter(self, stream):
self.nodes.append(
(
id(stream),
"Counter : {0}, {1}, {2}".format(
stream.start,
stream.stop,
stream.step
),
"ellipse"
)
)
def write_in_port(self, stream):
self.nodes.append(
(
id(stream),
"InPort : {0} {1}".format(
stream.name, stream.bits
), "ellipse"
)
)
def write_serial_in(self, stream):
self.nodes.append(
(
id(stream),
"SerialIn : {0}".format(
stream.name
),
"ellipse"
)
)
#sinks
def write_response(self, stream):
self.nodes.append((id(stream), "Response", "box"))
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"w"
)
)
def write_out_port(self, stream):
self.nodes.append(
(
id(stream),
"OutPort : {0}".format(
stream.name
),
"box"
)
)
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"w"
)
)
def write_serial_out(self, stream):
self.nodes.append(
(
id(stream),
"SerialOut : {0}".format(
stream.name
),
"box"
)
)
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"w"
)
)
def write_svga(self, stream):
self.nodes.append((id(stream), "SVGA", "box"))
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"w"
)
)
def write_console(self, stream):
self.nodes.append((id(stream), "Console", "box"))
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"w"
)
)
def write_asserter(self, stream):
self.nodes.append((id(stream), "Asserter", "box"))
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"w"
)
)
#combinators
def write_binary(self, stream):
labels = { 'add' : '+', 'sub' : '-', 'mul' : '*', 'div' : '//',
'mod' : '%', 'and' : '&', 'or' : '|', 'xor' : '^',
'sl' : '<<', 'sr' : '>>', 'eq' : '==', 'ne' : '!=',
'lt' : '<=', 'le' : '<', 'gt' : '>', 'ge' : '>='
}
self.nodes.append((id(stream), labels[stream.function], "circle"))
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"nw"
)
)
self.edges.append(
(
id(stream.b),
id(stream),
stream.b.get_bits(),
"sw"
)
)
def write_unary(self, stream):
labels = { 'abs' : 'abs', 'not' : '!', 'invert' : '~', 'sln' : '<<',
'srn' : '>>',
}
self.nodes.append((id(stream), labels[stream.function], "circle"))
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"nw"
)
)
self.edges.append(
(
id(stream.b),
id(stream),
stream.b.get_bits(),
"sw"
)
)
def write_lookup(self, stream):
self.nodes.append((id(stream), "Lookup", "ellipse"))
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"w"
)
)
def write_array(self, stream):
self.nodes.append((id(stream), "Array", "ellipse"))
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"nw"
)
)
self.edges.append(
(
id(stream.b),
id(stream),
stream.b.get_bits(),
"w"
)
)
self.edges.append(
(
id(stream.c),
id(stream),
stream.c.get_bits(),
"sw"
)
)
def write_decoupler(self, stream):
self.nodes.append(
(
id(stream),
"Decoupler",
"ellipse"
)
)
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"w"
)
)
def write_resizer(self, stream):
self.nodes.append((id(stream), "Resizer", "ellipse"))
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"w"
)
)
def write_printer(self, stream):
self.nodes.append((id(stream), "Printer", "ellipse"))
self.edges.append(
(
id(stream.a),
id(stream),
stream.a.get_bits(),
"w"
)
)
def write_output(self, stream):
self.outputs[id(stream)] = id(stream.process)
def write_process(self, p):
self.nodes.append((id(p), "Process", "ellipse"))
for i in p.inputs:
self.edges.append((id(i), id(p), i.get_bits(), "centre"))
def write_external_ip(self, ip):
for i in ip.output_streams:
self.ip_outputs[id(i)]=id(ip)
self.nodes.append((id(ip), ip.definition.name, "ellipse"))
for i in ip.input_streams:
self.edges.append((id(i), id(ip), i.get_bits(), "centre"))
def write_chip(self, *args):
pass
#System VHDL Generation and external tools
def draw(self, filename):
for ident, label, shape in self.nodes:
self.schematic.add_node(
str(ident),
shape=shape,
label=str(label)
)
for from_node, to_node, bits, headport in self.edges:
if from_node in self.outputs:
self.schematic.add_edge(
str(self.outputs[from_node]),
str(to_node),
label=str(bits),
headport=headport
)
elif from_node in self.ip_outputs:
self.schematic.add_edge(
str(self.ip_outputs[from_node]),
str(to_node),
label=str(bits),
headport=headport
)
else:
self.schematic.add_edge(
str(from_node),
str(to_node),
label=str(bits)
)
self.schematic.layout(prog='dot')
self.schematic.draw(filename)
# All rights reserved, see LICENSE for details. __author__ = """Aric Hagberg ([email protected])""" from pygraphviz import AGraph A = AGraph() # set some default node attributes A.node_attr['style'] = 'filled' A.node_attr['shape'] = 'circle' A.node_attr['fixedsize'] = 'true' A.node_attr['fontcolor'] = '#FFFFFF' # make a star in shades of red for i in range( 16 ): A.add_edge( 0, i ) n = A.get_node( i ) n.attr['fillcolor'] = "#%2x0000" % ( i * 16 ) n.attr['height'] = "%s" % ( i / 16.0 + 0.5 ) n.attr['width'] = "%s" % ( i / 16.0 + 0.5 ) print A.string() # print to screen A.write( "star.dot" ) # write to simple.dot print "Wrote star.dot" A.draw( 'star.png', prog="circo" ) # draw to png using circo print "Wrote star.png" import matplotlib.pyplot as plt a = plt.imread( 'star.png' ) plt.imshow( a ) plt.show()
def dot_layout(cy_elements):
"""
Get a CyElements object and augment it (in-place) with positions,
widths, heights, and spline data from a dot based layout.
Returns the object.
"""
elements = cy_elements.elements
g = AGraph(directed=True, strict=False)
# make transitive relations appear top to bottom
# TODO: make this not specific to leader example
elements = list(elements)
nodes_by_id = dict(
(e["data"]["id"], e)
for e in elements if e["group"] == "nodes"
)
order = [
(nodes_by_id[e["data"]["source"]], nodes_by_id[e["data"]["target"]])
for e in elements if
e["group"] == "edges" and
e["data"]["obj"] in ('reach', 'le')
]
elements = topological_sort(elements, order, lambda e: e["data"]["id"])
# add nodes to the graph
for e in elements:
if e["group"] == "nodes":
g.add_node(e["data"]["id"], label=e["data"]["label"].replace('\n', '\\n'))
# TODO: remove this, it's specific to leader_demo
weight = {
'reach': 10,
'le': 10,
'id': 1,
}
constraint = {
'pending': False,
}
# add edges to the graph
for e in elements:
if e["group"] == "edges":
g.add_edge(
e["data"]["source"],
e["data"]["target"],
e["data"]["id"],
weight=weight.get(e["data"]["obj"], 0),
#constraint=constraint.get(e["data"]["obj"], True),
)
# add clusters
clusters = defaultdict(list)
for e in elements:
if e["group"] == "nodes" and e["data"]["cluster"] is not None:
clusters[e["data"]["cluster"]].append(e["data"]["id"])
for i, k in enumerate(sorted(clusters.keys())):
g.add_subgraph(
name='cluster_{}'.format(i),
nbunch=clusters[k],
)
# now get positions, heights, widths, and bsplines
g.layout(prog='dot')
for e in elements:
if e["group"] == "nodes":
attr = g.get_node(e["data"]["id"]).attr
e["position"] = _to_position(attr['pos'])
e["data"]["width"] = 72 * float(attr['width'])
e["data"]["height"] = 72 * float(attr['height'])
elif e["group"] == "edges":
attr = g.get_edge(e["data"]["source"], e["data"]["target"], e["data"]["id"]).attr
e["data"].update(_to_edge_position(attr['pos']))
g.draw('g.png')
return cy_elements
def dot_layout(cy_elements, edge_labels=False, subgraph_boxes=False, node_gt=None):
"""
Get a CyElements object and augment it (in-place) with positions,
widths, heights, and spline data from a dot based layout.
edge_labels is true if labels should appear on edges
subgraph_boxes is true if boxes should be drawn around subgraphs
Returns the object.
"""
elements = cy_elements.elements
# g = AGraph(directed=True, strict=False)
g = AGraph(directed=True, strict=False, forcelabels=True)
# make transitive relations appear top to bottom
elements = list(elements)
nodes_by_id = dict((e["data"]["id"], e) for e in elements if e["group"] == "nodes")
order = [
(nodes_by_id[e["data"]["source"]], nodes_by_id[e["data"]["target"]])
for e in elements
if e["group"] == "edges" and "transitive" in e["data"] and e["data"]["transitive"]
]
elements = topological_sort(elements, order, lambda e: e["data"]["id"])
# get the node id's and stable sort them by cluster
# the idea here is to convert the graph into a dag by sorting
# the nodes, then reversing the back edges. In particular, we try to make
# all the edges between two clusters go in the same direction so clustering
# doesn't result in horizontal edges, which dot renders badly.
sorted_nodes = [e["data"]["id"] for e in elements if e["group"] == "nodes"]
sorted_nodes = sorted(enumerate(sorted_nodes), key=lambda x: (nodes_by_id[x[1]]["data"]["cluster"], x[0]))
sorted_nodes = [y for idx, y in sorted_nodes]
node_key = dict((id, idx) for idx, id in enumerate(sorted_nodes))
if node_gt is None:
node_gt = lambda X, y: False
else:
node_gt = lambda x, y: node_key[x] > node_key[y]
# add nodes to the graph
for e in elements:
if e["group"] == "nodes" and e["classes"] != "non_existing":
g.add_node(e["data"]["id"], label=e["data"]["label"].replace("\n", "\\n"))
# TODO: remove this, it's specific to leader_demo
weight = {"reach": 10, "le": 10, "id": 1}
constraint = {"pending": False}
# add edges to the graph
for e in elements:
if e["group"] == "edges":
# kwargs = {'weight': weight.get(e["data"]["obj"], 0)},
kwargs = {"label": e["data"]["label"]} if edge_labels else {}
if node_gt(e["data"]["source"], e["data"]["target"]):
g.add_edge(
e["data"]["target"],
e["data"]["source"],
e["data"]["id"],
dir="back",
**kwargs
# constraint=constraint.get(e["data"]["obj"], True),
)
else:
g.add_edge(
e["data"]["source"],
e["data"]["target"],
e["data"]["id"],
**kwargs
# constraint=constraint.get(e["data"]["obj"], True),
)
# add clusters
clusters = defaultdict(list)
for e in elements:
if e["group"] == "nodes" and e["data"]["cluster"] is not None and e["classes"] != "non_existing":
clusters[e["data"]["cluster"]].append(e["data"]["id"])
for i, k in enumerate(sorted(clusters.keys())):
g.add_subgraph(name="cluster_{}".format(i), nbunch=clusters[k], rank="min")
# now get positions, heights, widths, and bsplines
g.layout(prog="dot")
# get the y origin. we want the top left of the graph to be a
# fixed coordinate (hopefully (0,0)) so the graph doesn't jump when
# its height changes. Unfortunately, pygraphviz has a bug a gives
# the wrong bbox, so we compute the max y coord.
# bbox = pygraphviz.graphviz.agget(g.handle,'bb')
global y_origin
y_origin = 0.0
for n in g.nodes():
top = float(n.attr["pos"].split(",")[1]) + float(n.attr["height"]) / 2
if top > y_origin:
y_origin = top
if subgraph_boxes:
for sg in g.subgraphs():
top = float(sg.graph_attr["bb"].split(",")[3])
if top > y_origin:
y_origin = top
for e in elements:
if e["group"] == "nodes" and e["classes"] != "non_existing":
attr = g.get_node(e["data"]["id"]).attr
e["position"] = _to_position(attr["pos"])
e["data"]["width"] = 72 * float(attr["width"])
e["data"]["height"] = 72 * float(attr["height"])
elif e["group"] == "edges":
if node_gt(e["data"]["source"], e["data"]["target"]):
attr = g.get_edge(e["data"]["target"], e["data"]["source"], e["data"]["id"]).attr
pos = attr["pos"]
pe = pos.split()
ppe = pe[1:]
ppe.reverse()
pos = " ".join([pe[0].replace("s", "e")] + ppe)
else:
attr = g.get_edge(e["data"]["source"], e["data"]["target"], e["data"]["id"]).attr
pos = attr["pos"]
e["data"].update(_to_edge_position(pos))
if edge_labels and e["data"]["label"] != "":
e["data"]["lp"] = _to_position(attr["lp"])
# g.draw('g.png')
if subgraph_boxes:
for sg in g.subgraphs():
box = cy_elements.add_shape(sg.name, classes="subgraphs")
coords = _to_coord_list(sg.graph_attr["bb"])
box["data"]["coords"] = coords
return cy_elements
class UmlPygraphVizDiagram:
"""
Creates a diagram similar to the class diagrams and objects diagrams from UML using pygraphviz
"""
def __init__(self):
logging.basicConfig()
self.graph = AGraph(directed=True, strict=False)
self.graph.node_attr["shape"] = "record"
self.graph.graph_attr["fontsize"] = "8"
self.graph.graph_attr["fontname"] = "Bitstream Vera Sans"
self.graph.graph_attr["label"] = ""
self.connected_nodes = set()
self.described_nodes = set()
def _add_node(self, node_id, node_label):
self.graph.add_node(node_id, label=node_label)
def add_class_node(self, class_name, attributes):
self.described_nodes.add(class_name)
label = "<{<b>%s</b> | %s }>" % (
class_name,
"<br align='left'/>".join(attributes).strip() + "<br align='left'/>",
)
self.subgraph.add_node(graphviz_id(class_name), label=label)
def add_object_node(self, object_name, class_name, attributes):
self.described_nodes.add(object_name)
if class_name:
label = "<{<b><u>%s (%s)</u></b>| %s }>" % (
object_name,
class_name,
"<br align='left'/>".join(attributes) + "<br align='left'/>",
)
else:
label = "<{<b><u>%s</u></b>| %s }>" % (
object_name,
"<br align='left'/>".join(attributes) + "<br align='left'/>",
)
self.subgraph.add_node(graphviz_id(object_name), label=label)
def add_edge(self, src, dst, name):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(graphviz_id(src), graphviz_id(dst), label=name, arrowhead="open")
def add_cardinality_edge(self, src, dst, name, card):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(
graphviz_id(src),
graphviz_id(dst),
label=name,
arrowhead="open",
labeldistance=2.0,
headlabel=card + "..." + card,
labelangle=-65.0,
)
def add_min_cardinality_edge(self, src, dst, name, card):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(
graphviz_id(src),
graphviz_id(dst),
label=name,
arrowhead="open",
labeldistance=2.0,
headlabel=card + "...*",
labelangle=-65.0,
)
def add_max_cardinality_edge(self, src, dst, name, card):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(
graphviz_id(src),
graphviz_id(dst),
label=name,
arrowhead="open",
labeldistance=2.0,
headlabel="0..." + card,
labelangle=-65.0,
)
def add_min_max_cardinality_edge(self, src, dst, name, min, max):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(
graphviz_id(src),
graphviz_id(dst),
label=name,
arrowhead="open",
labeldistance=2.0,
headlabel=min + "..." + max,
labelangle=-65.0,
)
def add_list_edge(self, src, dst, name):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(
graphviz_id(src),
graphviz_id(dst),
label=name,
arrowtail="ediamond",
dir="back",
headlabel="0...*",
labeldistance=2.0,
labelfontcolor="black",
labelangle=-65.0,
)
# self.graph.add_edge(graphviz_id(src), graphviz_id(dst),label=name,arrowtail="ediamond", dir="back",headlabel="0...*", taillabel=(dst.split(":")[1])+"s",labeldistance=2.0,labelfontcolor="black")
def add_symmetric_edge(self, src, dst, name):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(graphviz_id(src), graphviz_id(dst), label=name, arrowhead="none")
def add_functional_edge(self, src, dst, name):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(
graphviz_id(src),
graphviz_id(dst),
label=name,
arrowhead="open",
headlabel="1...1",
taillabel="0...*",
labeldistance=2.0,
labelfontcolor="black",
labelangle=-65.0,
)
def add_inversefunctional_edge(self, src, dst, name):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(
graphviz_id(src),
graphviz_id(dst),
label=name,
arrowhead="open",
headlabel="0...*",
taillabel="1...1",
labeldistance=2.0,
labelfontcolor="black",
labelangle=-65.0,
)
def add_equivalentclass_edge(self, src, dst):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(
graphviz_id(src), graphviz_id(dst), label="\<\<equivalentClass\>\>", arrowhead="none", style="dashed"
)
def add_unionof_edge(self, src, dst):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(
graphviz_id(src), graphviz_id(dst), label="\<\<unionOf\>\>", arrowhead="open", style="dashed"
)
def add_oneof_edge(self, src, dst):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(
graphviz_id(src), graphviz_id(dst), label="\<\<instanceOf\>\>", arrowhead="open", style="dashed", dir="back"
)
def add_subclass_edge(self, src, dst):
self.connected_nodes.add(src)
self.connected_nodes.add(dst)
self.graph.add_edge(graphviz_id(src), graphviz_id(dst), arrowhead="empty")
def set_label(self, label):
self.graph.graph_attr["label"] = label
def start_subgraph(self, graph_name):
self.subgraph = self.graph.add_subgraph(name="cluster_%s" % graphviz_id(graph_name))
self.subgraph.graph_attr["label"] = graph_name
def add_undescribed_nodes(self):
s = self.connected_nodes - self.described_nodes
for node in s:
self.graph.add_node(graphviz_id(node), label=node)
def write_to_file(self, filename_dot):
f = open(filename_dot, "w")
f.write(self.graph.string())
print("dot file created: " + filename_dot)
def visualize(self, filename, namespaceList=None):
self.graph.layout(prog="dot")
self.graph.draw(filename)
if filename.endswith(".svg"):
self._add_links_to_svg_file(filename, namespaceList)
print("graphic file created: " + filename)
def _add_links_to_svg_file(self, output, namespaceList=None):
# SVG Datei anpassen
svg_string = open(output).read()
# Titel der SVG Datei anpassen
svg_string = svg_string.replace("%3", output)
# Hyperlinks mit den Internetseiten hinzufügen
for ns in namespaceList:
namespace = str(ns[0]) # Präfix des Namespaces
url = str(ns[1]) # URL des Namespaces
regex_str = """%s:(\w+)""" % namespace
regex = re.compile(regex_str)
svg_string = regex.sub("""<a xlink:href='%s\\1'>%s:\\1</a>""" % (url, namespace), svg_string)
# Datei schreiben
svg_file = open(output, "w")
svg_file.write(svg_string)
svg_file.close()
def main():
usage= 'usage: %prog [options] midis'
parser= OptionParser(usage=usage)
parser.add_option('--n-measures', dest='n_measures', default=1, type='int', help='if the partition algorithm is MEASURE, especifies the number of measures to take as a unit')
parser.add_option('-o', dest='outfname', help='the output file')
options, args= parser.parse_args(argv[1:])
if len(args) < 1: parser.error('not enaught args')
outfname= options.outfname
if outfname is None:
parser.error('missing outfname')
infnames= args[:]
parser= MidiScoreParser()
models= []
for infname in infnames:
score= parser.parse(infname)
if not score: import ipdb;ipdb.set_trace() # por que podria devolver None?
#########
# AJUSTES DE PARSING
notes= score.get_first_voice()
notes= [n for n in notes if n.duration > 0]
instr= score.notes_per_instrument.keys()[0]
patch= instr.patch
channel= instr.channel
score.notes_per_instrument= {instr:notes}
#########
interval_size= measure_interval_size(score, options.n_measures)
algorithm= HarmonyHMM(interval_size, instrument=patch, channel=channel)
algorithm.train(score)
algorithm.create_model()
models.append(algorithm.model)
def sim(m1, m2):
"""
calcula H(m1|m2)
"""
from math import log
ans= 0
for s1 in m2.state_transition:
for s2, prob in m1.state_transition.get(s1, {}).iteritems():
ans+= m2.pi[s1]*prob*log(prob)
return -ans
from os import path
def get_node_name(ticks):
n_quarters= 0
while ticks >= score.divisions:
ticks-= score.divisions
n_quarters+= 1
if ticks > 0:
f= Fraction(ticks, score.divisions)
if n_quarters > 0: return "%s + %s" % (n_quarters, f)
else: return repr(f)
return "%s" % n_quarters
for i, m in enumerate(models):
m.pi= m.calc_stationationary_distr()
from pygraphviz import AGraph
from utils.fraction import Fraction
g= AGraph(directed=True, strict=False)
for n1, adj in m.state_transition.iteritems():
n1_name= get_node_name(n1)
for n2, prob in adj.iteritems():
n2_name= get_node_name(n2)
g.add_edge(n1_name, n2_name)
e= g.get_edge(n1_name, n2_name)
e.attr['label']= str(prob)[:5]
model_fname= path.basename(infnames[i]).replace('mid', 'png')
g.draw(model_fname, prog='dot', args='-Grankdir=LR')
sims= defaultdict(dict)
for i, m1 in enumerate(models):
for j in xrange(i+1, len(models)):
m2= models[j]
sims[path.basename(infnames[i])][path.basename(infnames[j])]= sim(m1, m2)
sims[path.basename(infnames[j])][path.basename(infnames[i])]= sim(m2, m1)
import csv
f= open(outfname, 'w')
writer= csv.writer(f)
head= sorted(sims)
head.insert(0, "-")
writer.writerow(head)
for (k, row) in sorted(sims.iteritems(), key=lambda x:x[0]):
row= sorted(row.iteritems(), key=lambda x:x[0])
row= [t[1] for t in row]
row.insert(0, k)
writer.writerow(row)
f.close()
return
from pygraphviz import AGraph
from utils.fraction import Fraction
g= AGraph(directed=True, strict=False)
for infname1, adj in sims.iteritems():
for infname2, sim in adj.iteritems():
if sim>0.2 and sim!=0: continue
g.add_edge(infname1, infname2)
e= g.get_edge(infname1, infname2)
e.attr['label']= str(sim)[:5]
g.draw(outfname, prog='dot')
def recalculate(user):
# remove old ranking
RankedTeam.objects.filter(team__user = user).delete()
for pic in RankingPicture.objects.all():
pic.image.delete()
pic.delete()
color_index = 0
team_graph = Graph()
gvfull = AGraph(directed = True)
for team in user.teams.all():
gvfull.add_node(asciiname(team), label = team.name)
team_graph.add_node(team)
for game in Game.objects.filter(team_1__user = user, team_2__user = user):
team_graph.add_edge(game.winner(), game.loser(), game.jugg_diff())
for source, dest, weight in team_graph.edges():
gvfull.add_edge(asciiname(source), asciiname(dest), label = str(weight))
current_place = 1
gvcircles = AGraph(directed = True)
gvtiebreaker = AGraph(directed = True)
for place in team_graph.topological_sort():
place_list = []
relevant_teams = set()
for circle in place:
relevant_teams |= circle
if len(circle) == 1:
continue
color_index, current_color = getcolor(color_index)
for team in circle:
gvcircles.add_node(asciiname(team), label = team.name, color = current_color, fontcolor = current_color)
gvfull.get_node(asciiname(team)).attr['color'] = current_color
gvfull.get_node(asciiname(team)).attr['fontcolor'] = current_color
for source, dest, weight in team_graph.edges():
if source in circle and dest in circle:
gvcircles.add_edge(asciiname(source), asciiname(dest), label = str(weight), color = current_color, fontcolor = current_color)
gvfull.get_edge(asciiname(source), asciiname(dest)).attr['color'] = current_color
gvfull.get_edge(asciiname(source), asciiname(dest)).attr['fontcolor'] = current_color
place = [[(team.normalized_jugg_diff(relevant_teams), team.name, team) for team in circle] for circle in place]
for circle in place:
circle.sort(reverse = True)
while place:
place_list.append(set())
i = 0
while i < len(place):
circle = place[i]
jd = circle[0][0]
while circle and circle[0][0] == jd:
place_list[-1].add(circle.pop(0))
if not circle:
place.remove(circle)
else:
i += 1
for same_place_set in place_list:
# tie breaker
if len(same_place_set) > 1:
# teams that everyone on this place played against
relevant_teams = team_graph.nodes()
for circ_jugg_diff, name, team in same_place_set:
opponents = set()
for game in team.games():
if game.team_1 == team:
opponents.add(game.team_2)
else:
opponents.add(game.team_1)
relevant_teams &= opponents
if len(relevant_teams) > 0:
color_index, current_color_a = getcolor(color_index)
color_index, current_color_b = getcolor(color_index)
for team in relevant_teams:
gvtiebreaker.add_node("b-" + asciiname(team), label = team.name, color = current_color_b, fontcolor = current_color_b)
for void, void, team in same_place_set:
gvtiebreaker.add_node("a-" + asciiname(team), label = team.name, color = current_color_a, fontcolor = current_color_a)
for game in team.games():
if game.team_1 == team and game.team_2 in relevant_teams:
if game.winner() == team:
gvtiebreaker.add_edge("a-" + asciiname(team), "b-" + asciiname(game.team_2), label = game.jugg_diff(), color = current_color_a, fontcolor = current_color_a)
else:
gvtiebreaker.add_edge("b-" + asciiname(game.team_2), "a-" + asciiname(team), label = game.jugg_diff(), color = current_color_b, fontcolor = current_color_b)
elif game.team_2 == team and game.team_1 in relevant_teams:
if game.winner() == team:
gvtiebreaker.add_edge("a-" + asciiname(team), "b-" + asciiname(game.team_1), label = game.jugg_diff(), color = current_color_a, fontcolor = current_color_a)
else:
gvtiebreaker.add_edge("b-" + asciiname(game.team_1), "a-" + asciiname(team), label = game.jugg_diff(), color = current_color_b, fontcolor = current_color_b)
# jugg differences against relevant teams
rel_jugg_diffs = set()
for team_tuple in same_place_set:
rel_jugg_diffs.add((team_tuple, team_tuple[2].normalized_jugg_diff(relevant_teams)))
# pop all teams, highest relevant jugg difference first
while rel_jugg_diffs:
# current maximum
max_rel_jugg_diff = None
# teams with maximum jugg difference
to_remove = None
for team_tuple, rel_jugg_diff in rel_jugg_diffs:
# new maximum
if max_rel_jugg_diff is None or rel_jugg_diff > max_rel_jugg_diff[0]:
max_rel_jugg_diff = (rel_jugg_diff, {team_tuple})
to_remove = {(team_tuple, rel_jugg_diff)}
# same as maximum
elif rel_jugg_diff == max_rel_jugg_diff[0]:
max_rel_jugg_diff[1].add(team_tuple)
to_remove.add((team_tuple, rel_jugg_diff))
# remove teams with maximum jugg difference
rel_jugg_diffs -= to_remove
# add teams to listing
for (circ_jugg_diff, name, team), rel_jugg_diff in to_remove:
RankedTeam.objects.create(place = current_place, team = team)
current_place += 1
else:
circ_jugg_diff, name, team = same_place_set.pop()
RankedTeam.objects.create(place = current_place, team = team)
current_place += 1
with tempfile.NamedTemporaryFile(suffix = ".png") as tmp:
gvfull.draw(tmp, "png", "dot")
pic = RankingPicture(user = user, image = File(tmp), title = "Full Team Graph")
pic.save()
with tempfile.NamedTemporaryFile(suffix = ".png") as tmp:
gvcircles.draw(tmp, "png", "dot")
pic = RankingPicture(user = user, image = File(tmp), title = "Circles")
pic.save()
with tempfile.NamedTemporaryFile(suffix = ".png") as tmp:
gvtiebreaker.draw(tmp, "png", "dot")
pic = RankingPicture(user = user, image = File(tmp), title = "Tie Breaker")
pic.save()
#! /usr/bin/env python
from ..rankomatic import models
from pygraphviz import AGraph
d = models.Dataset.objects.get(name="cv-grammar")
g = AGraph(directed=True)
for k, v in d.entailments.iteritems():
for entailed in v:
g.add_edge(k, entailed)
g2 = g.copy()
d._collapse_cycles(g)
for i, graph in enumerate([g, g2]):
graph.tred()
fname = "g%d.png" % i
graph.draw(fname, prog="dot")
