def render_tree(args, tree):
"""Render tree in ASCII and graphviz"""
with codecs.open("{0}/{1}.txt".format(args.output_dir, constants.TREE),
"w",
encoding="utf8") as txt_file:
for pre, _, node in anytree.RenderTree(tree):
txt_file.write("%s%s: %s (%s: %s)\n" %
(pre, node.name, node.description.title(),
args.effect_name, str(node.effect_size)))
graph_options = [
] # Example: graph_options = ["dpi=300.0;", "style=filled;", "bgcolor=yellow;"]
DotExporter(tree,
options=graph_options,
nodeattrfunc=lambda node: nodeattrfunc(args, node)).to_dotfile(
"{0}/{1}.dot".format(args.output_dir, constants.TREE))
try:
DotExporter(
tree,
options=graph_options,
nodeattrfunc=lambda node: nodeattrfunc(args, node)).to_picture(
"{0}/{1}.png".format(args.output_dir, constants.TREE))
except FileNotFoundError:
raise FileNotFoundError(
"Error during tree rendering - is Graphviz installed on your system?\n"
)
def visualization_path(model,
path,
target_node,
type_analysis,
filename,
rankdir='TB'):
"""
Visualize dominant path
Parameters
----------
model: pysb.Model
pysb model used for analysis
path: list
list that have the tree structure of the path, generated by the discretization step.
target_node: str
Species target used to obtain the dominant paths
type_analysis: str
Type of analysis done to obtain the path. It can either be `production` or `consumption`
filename: str
File name including the extension of the image file
Returns
-------
"""
generate_equations(model)
def find_numbers(dom_r_str):
n = map(int, re.findall('\d+', dom_r_str))
return n
def nodenamefunc(node):
node_idx = list(find_numbers(node.name))[0]
node_sp = model.species[node_idx]
node_name = parse_name(node_sp)
return node_name
def edgeattrfunc(node, child):
return 'dir="back"'
root = _create_tree(target_node, path)
if type_analysis == 'production':
DotExporter(root,
graph='strict digraph',
options=["rankdir={};".format(rankdir)],
nodenamefunc=nodenamefunc,
edgeattrfunc=edgeattrfunc).to_picture(filename)
elif type_analysis == 'consumption':
DotExporter(root,
graph='strict digraph',
options=["rankdir={};".format(rankdir)],
nodenamefunc=nodenamefunc,
edgeattrfunc=None).to_picture(filename)
else:
raise ValueError('Type of visualization not implemented')
def home():
# arr = randomize()
global arr
goal_state =np.array([1,2,3,4,12,13,14,5,11,0,15,6,10,9,8,7]).reshape((4,4))
# goal_state = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]).reshape((4,4))
if 'random' in request.form:
arr = random_state()
return render_template('test.html',arr=arr)
elif 'custom' in request.form:
var = request.form['textbox']
ls = var.split(',')
results = list(map(int, ls))
arr = np.array(results).reshape((4,4))
print("arr",arr)
goal_state = goal_state.tolist()
return render_template('test.html',arr=arr)
#
if request.form.get('bfs') == '1' and request.form['search'] == 'find':
# arr = arr.tolist()
goal_state = goal_state.tolist()
print('Goal State :', goal_state)
path , count = pz.best_first_search(arr,goal_state)
print(path)
DotExporter(path).to_picture("static/images/tree.png")
# make_transparent()
full_filename = os.path.join(app.config['UPLOAD_FOLDER'], 'tree.png')
print(full_filename)
return render_template('test.html', tree=full_filename , arr = goal_state, count = count)
if request.form.get('bfs') == '2' and request.form['search'] == 'find':
# arr = np.array([1,3,4,5,12,2,14,6,11,0,8,15,10,13,9,7]).reshape((4,4))
arr = np.array(arr)
Puzzle1 = astar.Puzzle()
path,counter = Puzzle1.process(arr,goal_state)
print(path)
DotExporter(path).to_picture("static/images/tree.png")
# make_transparent()
fname = os.path.join(app.config['UPLOAD_FOLDER'], 'tree.png')
print(fname)
# im = Image(path.create_png())
# display(im)
return render_template('test.html', tree= fname, arr= goal_state, count = counter)
# pass # do something
# elif 'watch' in request.form:
# pass # do something else
return render_template('test.html', arr= arr)
def export(tree, filename, ext='json', **kwargs):
parent = _get_printable_tree(tree)
if ext == 'json':
with io.open(f'{filename}.json', mode='w+', encoding='utf-8') as fp:
JsonExporter(**kwargs).write(parent, fp)
else:
DotExporter(parent, **kwargs).to_picture(f'{filename}.{ext}')
def generate_parse_tree(self, tokens):
Global.token_stream[:] = tokens
Global.cursor = 0
tree_root = Node('program')
print(Global.code_objs['decl_list'].check(tree_root))
print(RenderTree(tree_root))
DotExporter(tree_root).to_picture('../parse_tree.png')
def getRequisits(id):
r = requests.get(url + '/assignatures/requisits' + pack).json()
assig = Node(id)
resultat = cerca(id, assig, r)
print(assig)
print(RenderTree(assig))
DotExporter(assig).to_picture("tree.png")
def drawExpressionTree(postfix):
"""Draw expression tree in console and output to file"""
stack = []
index = 0
for i in postfix:
if type(i) is float or i == 'x':
stack.append(Node(index, parent=None, val=i))
index += 1
else:
if i == 'sqrt':
child = stack.pop()
parent = Node(index, parent=None, val=i)
index += 1
child.parent = parent
stack.append(parent)
elif i == '-' and len(stack) == 1:
child = stack.pop
parent = Node(index, parent=None,
val=i) index += 1 child.parent = parent
stack.append(parent)
else:
right = stack.pop()
left = stack.pop()
parent = Node(index, parent=None, val=i)
index += 1
left.parent = parent
right.parent = parent
stack.append(parent)
root = stack.pop()
DotExporter(root, graph="graph", nodeattrfunc=nodeattrfunc,
edgetypefunc=edgetypefunc).to_dotfile("tree.dot")
print("\nExpression Tree:")
print(RenderTree(root, style=DoubleStyle).by_attr(attrname='val'))
def takeTempPolicy(self):
li = [[0, 0, 1, 0], [0, 2, 1, 0], [1, 2, 1, 0], [1, 3, 1, 0],
[0, 3, 0, 0], [1, 4, 1, 0], [0, 4, 0, 1]]
if (len(li) == 0):
return
nodes = [
AnyNode(name="temp", parent=self.root, dim=0, part=0, inheritedN=0)
for i in range(len(li))
]
parentNode = self.root
TreeTravDirec = li[0][0]
#print(TreeTravDirec)
for i in range(len(li)):
if (li[i][0] != TreeTravDirec):
TreeTravDirec = li[i][0]
parentNode = nodes[i - 1]
inheritedN = self.g.childNodeN(parentNode.inheritedN)
nodes[i].name = str(i)
nodes[i].dim = str(li[i][0])
nodes[i].val = str(li[i][1])
nodes[i].parent = parentNode
nodes[i].inheritedN = inheritedN
self.takeAction(li[i][0], li[i][1], li[i][3], inheritedN)
self.g.renderEnv()
#print(nameNode,"yo")
#AnyNode(name="sub0B", parent=s0, index=1, partition=9)
DotExporter(self.root).to_picture("TreeDiag/root.png")
def print_population_tree(self,
image: bool = False,
path: str or None = None):
"""
Print population tree to stdout or save as an image if 'image' is True.
Parameters
----------
image: bool (default=False)
Save tree as a png image
path: str (optional)
File path for image, ignored if 'image' is False.
Defaults to working directory.
Returns
-------
None
"""
root = self.tree['root']
if image:
from anytree.exporter import DotExporter
path = path or f'{os.getcwd()}/{self.id}_population_tree.png'
DotExporter(root).to_picture(path)
for pre, fill, node in anytree.RenderTree(root):
print('%s%s' % (pre, node.name))
def render(tree, tree_size, filename=decision_tree_picture_path):
tree_to_render = build_tree(tree.root, tree_size)
DotExporter(
tree_to_render,
nodeattrfunc=lambda node: 'label="{}"'.format(node.display_name),
edgeattrfunc=lambda p, c: 'label="{}"'.format(c.edge)).to_picture(
filename)
def visualise(self, filename):
"""
Produces a .png file of the tree (this node and its children) with the
name filename
Parameters
----------
filename : str
filename to output, must end in ".png"
"""
# check that filename ends in .png.
if filename[-4:] != ".png":
raise ValueError("filename should end in .png")
new_node, counter = self.relabel_tree(self, 0)
try:
DotExporter(new_node,
nodeattrfunc=lambda node: 'label="{}"'.format(
node.label)).to_picture(filename)
except FileNotFoundError:
# raise error but only through logger so that test passes
pybamm.logger.error(
"Please install graphviz>=2.42.2 to use dot exporter")
def Imprimir_solucao(solucao,filename,mapa):
node_list = []
parent = solucao
while (parent):
node_list.append(parent)
parent = parent.parent
list_solucao = []
custo_total = 0
list_id = []
for node in reversed(node_list):
name = [x.strip() for x in node.name.split(',')][0]
list_id.append(node.city_id)
if(node.parent):
list_solucao.append(Node(name,parent = list_solucao[-1]))
custo_total += calc_dist_haversine(mapa.change_id2pos(node.city_id),mapa.change_id2pos(node.parent.city_id))
else:
list_solucao.append(Node(name))
DotExporter(list_solucao[0]).to_dotfile(filename)
render('dot', 'pdf', filename)
print("Altura da Arvore de busca: ",node_list[-1].height)
print("Numero de nós da Arvore de busca",len(node_list[-1].descendants) +1)
print("Custo Total: ",custo_total)
print("IDS: ",list_id)
def program(self):
result = self.combined_calculation()
#Visualization
root = Node("Data")
for i in range(0, len(result[0])):
label_bayes = "Bayes {}".format(result[0][i])
label_ctr = "CTR {}".format(result[1][i])
label_chance = "Chance {}".format(result[2][i])
label_suff = "Sufficiency {}".format(result[3][i])
label_glob = "Glob {}".format(result[4])
label_prob = "Probability {}".format(result[5])
bayes = Node(label_bayes, parent=root)
ctr = Node(label_ctr, parent=bayes)
prob = Node(label_chance, parent=ctr)
logsuff = Node(label_suff, parent=prob)
glob = Node(label_glob, parent=logsuff)
prob = Node(label_prob, parent=glob)
#for line in DotExporter(root):
# print(line)
DotExporter(root).to_dotfile("tree.dot")
(graph, ) = pydot.graph_from_dot_file('tree.dot')
graph.write_png('tree.png')
def export(self, full=False):
"""
Export tree into graphviz format in both *.dot file and image *.png file
Parameters
----------
full: boolean value, if True also the regex mappings are printed in the resulting file
"""
def nodeattr_fn(node):
return f'style=filled color={COLOR_SCHEME[node.depth]}'
def nodename_fn(node):
nl = "\n"
name = node.name
if hasattr(node, "regex"):
name = f"""
{node.name}
-----------
{nl.join(node.regex)}
"""
return name
root = self.nodes[self.root_key]
dot = DotExporter(
root,
nodenamefunc=nodename_fn if full else None,
nodeattrfunc=nodeattr_fn,
options=[
'graph [layout = dot, ranksep="1.5", nodesep="0.7"]',
'rankdir ="LR"',
'node [fontname="Arial"]'
]
)
dot.to_dotfile(f"./{self.root_key}.dot")
dot.to_picture(f"./{self.root_key}.png")
def render_fm_tree(root_node, filename='tree.png'):
# Function to format nodes in FM tree
def format_box(node):
# https://graphviz.org/doc/info/shapes.html
if node.level_id == 0:
# Item Level Node
return "fixedsize=false, shape=rect, fillcolor=lightgrey, style=filled"
else:
if not node.policy_tc:
# Error? missing policy_tc entry for this Node
return "fixedsize=false, shape=ellipse, fillcolor=pink, style=filled"
elif len(node.policy_tc) > 1:
# Node with multiple layers
return "fixedsize=false, shape=rect, fillcolor=orange, style=filled"
else:
# Cov or loc nodes
return "fixedsize=false, shape=ellipse, fillcolor=lightblue, style=filled"
# Function to add weighted 'by layer number' edges
def layered_edge(node, child):
# https://anytree.readthedocs.io/en/latest/tricks/weightededges.html
if hasattr(child, 'layer_max'):
if child.layer_max > 1:
return 'dir=back, style=bold, label=" {} Layers"'.format(child.layer_max)
return "dir=back"
# Render tree to png
dot_data = DotExporter(
root_node,
edgeattrfunc=layered_edge,
nodeattrfunc=format_box)
dot_data.to_picture(filename)
def test_tree2():
"""Tree2."""
root = Node("root")
s0 = Node("sub0", parent=root, edge=2)
Node("sub0B", parent=s0, foo=4, edge=109)
Node("sub0A", parent=s0, edge="")
s1 = Node("sub1", parent=root, edge="")
Node("sub1A", parent=s1, edge=7)
Node("sub1B", parent=s1, edge=8)
s1c = Node("sub1C", parent=s1, edge=22)
Node("sub1Ca", parent=s1c, edge=42)
def nodenamefunc(node):
return '%s:%s' % (node.name, node.depth)
def edgeattrfunc(node, child):
return 'label="%s:%s"' % (node.name, child.name)
r = DotExporter(root,
options=["rankdir=LR;"],
nodenamefunc=nodenamefunc,
nodeattrfunc=lambda node: "shape=box",
edgeattrfunc=edgeattrfunc)
r.to_dotfile(join(GENPATH, "tree2.dot"))
assert cmp(join(GENPATH, "tree2.dot"), join(REFPATH, "tree2.dot"))
def visualize_tree_dot(tree, mode, node_to_class, node_to_classes, filename):
tree = deepcopy(tree)
if mode == 'ids':
pass
elif isinstance(mode, dict):
for node in PreOrderIter(tree):
if not node.is_leaf:
node.name = mode.get(node_to_class[node.name], 'root') + '_' + \
str(node.name)
else:
node.name = mode.get(node_to_classes[node.name][0], 'root') + '_' + \
str(node.name)
elif mode == 'classes':
for node in PreOrderIter(tree):
node.name = ''.join([
str(node_to_class.get(node.name, 'root')),
':',
str(node_to_classes[node.name]).replace(' ', ''),
'\n',
])
else:
raise ValueError(f'No mode named {mode}')
DotExporter(tree).to_picture(filename)
return filename
def render_tree(opts, tree):
"""Render tree in ASCII and graphviz"""
with codecs.open(
f"{opts.output_dir}/{constants.FEATURE_IMPORTANCE_HIERARCHY}.txt",
"w",
encoding="utf8") as txt_file:
for pre, _, node in anytree.RenderTree(tree):
txt_file.write("%s%s: %s (%s: %s)\n" %
(pre, node.name, node.description.title(),
opts.effect_name, str(node.effect_size)))
graph_options = [
] # Example: graph_options = ["dpi=300.0;", "style=filled;", "bgcolor=yellow;"]
exporter = DotExporter(tree,
options=graph_options,
nodeattrfunc=lambda node: nodeattrfunc(opts, node))
exporter.to_dotfile(
f"{opts.output_dir}/{constants.FEATURE_IMPORTANCE_HIERARCHY}.dot")
try:
output_filename = f"{opts.output_dir}/{constants.FEATURE_IMPORTANCE_HIERARCHY}.png"
exporter.to_picture(output_filename)
print(f"Feature importance visualization: {output_filename}")
except FileNotFoundError:
print(
"Feature importance visualization: error during tree rendering. Is Graphviz installed on your system?"
)
def tree_to_png(self, generation):
if not os.path.exists('./outputs/GEN-{}'.format(generation)):
os.mkdir('./outputs//GEN-{}'.format(generation))
DotExporter(self.phenotype,
nodeattrfunc=lambda node: 'label="{}", style=filled, color="{}", fillcolor="{}"'.format(node.label, node.border, node.color),
edgeattrfunc=lambda node,child: 'color="{}"'.format(node.border)
).to_picture("./outputs/GEN-{}/{}-{}.png".format(generation, self.cid, str(self).rsplit('<Chromosome.Chromosome object at ')[1][:-1]))
def main():
if '-h' in sys.argv or '--help' in sys.argv:
help_msg()
elif len(sys.argv) <= 2:
help_msg()
else:
url = sys.argv[1]
url = url_fixer(url)
data = []
for link in collect_links(url):
data.append(link)
data = clean_data(data, url)
if len(data):
sitetree = list_to_anytree(data)
if '-o' in sys.argv:
filename = slugify(url)
DotExporter(sitetree,
nodeattrfunc=lambda node: "shape=box").to_picture(
f'{filename}.png')
for pre, fill, node in RenderTree(sitetree):
print(f"{pre}{node.name}")
def dbgPrintTreeToImage(inputNode, rootFolder=None, subFolder=None):
"""Debug: print tree relation to image
for single (root) node: print to single relation image file
for top node list: print each single top node to single relation image file
Args:
inputNode (Node/list): if Node, is single (noramlly root) tree node; if list, is tree top node list
rootFolder (str): output root folder. Default None. If None, use current folder from os.getcwd()
subFolder (str): output sub folder
Returns:
Raises:
"""
if not rootFolder:
rootFolder = os.getcwd()
isTopNodeList = False
if isinstance(inputNode, list):
isTopNodeList = True
topNodeList = inputNode
else:
currentNode = inputNode
if subFolder:
outputFolder = os.path.join(rootFolder, subFolder)
else:
outputFolder = rootFolder
if isTopNodeList:
topNodeSubFolder = "topNode"
outputFolder = os.path.join(outputFolder, topNodeSubFolder)
createFolder(outputFolder)
if isTopNodeList:
for curTopNode in topNodeList:
curNodeRealtionFile = "TopNode_Relation_%s.png" % (curTopNode.name)
curNodeRealtionImg = os.path.join(outputFolder,
curNodeRealtionFile)
# 'output/20210622/current/topNode/RelationTopNode_aaaaaaaa5522.png'
print("Generating %s" % curNodeRealtionImg)
DotExporter(curTopNode).to_picture(curNodeRealtionImg)
else:
allNodeOutputFilename = "AllNode_Relation.png"
allNodeOutputFullPath = os.path.join(outputFolder,
allNodeOutputFilename)
print("Generating %s" % allNodeOutputFullPath)
DotExporter(currentNode).to_picture(allNodeOutputFullPath)
def createTree(root):
DotExporter(
root,
graph="graph",
nodenamefunc=nodenamefunc,
# nodeattrfunc= lambda node: "shape=box",
# edgeattrfunc=edgeattrfunc,
edgetypefunc=edgetypefunc).to_picture("tree.pdf")
def show_tree(tree, path=None):
if (path):
DotExporter(tree,
nodeattrfunc=lambda node: 'label="{}"'.format(node.value)
).to_dotfile(path)
else:
for pre, fill, node in RenderTree(tree):
print("%s%s" % (pre, node.value))
def ipaddress():
path = os.path.dirname(__file__)
with open('{}/test_files/ipaddress.py'.format(path), 'r') as f:
code = f.read()
parse_tree = Parser().parse(code)
root = SimplifiedParsedTreeTransformer().visit(parse_tree)
from anytree.exporter import DotExporter
DotExporter(root).to_picture("{}/test_files/ipaddress.png".format(path))
def plot_tree(self, file_path):
# for pre, fill, node in self:
# print("%s%s" % (pre, node.name))
DotExporter(
self.node,
edgeattrfunc=lambda p, c: "label=<" + c.label + ">").to_picture(
"t2.pdf")
return
def dot(self):
'''
Return the BOM tree structure from :py:attr:`BOM.BOM.tree` in DOT graph
format (Graphiz)
:rtype: str
'''
return '\n'.join([line for line in DotExporter(self)])
def test_esc():
"""Test proper escape of quotes."""
n = Node(r'6"-6\"')
eq_(tuple(DotExporter(n)), (
r'digraph tree {',
r' "6\"-6\\\"";',
r'}'
))
def export_trie(
trie, img_filename='trie.png', graphviz_filename=None
):
if not trie.empty():
words = trie.list_words()
for i in range(len(words)):
words[i] = '*' + words[i]
nodes = {}
root = None
count = 0
for word in words:
parent_node = None
parent_node_label = ""
for i, val in enumerate(word):
if i not in nodes:
nodes[i] = {}
key = parent_node_label + val
count += 1
if key not in nodes[i]:
nodes[i][key] = Node(
key, parent=parent_node, display_name=val
)
if root is None:
root = nodes[i][key]
parent_node = nodes[i][key]
parent_node_label += val
DotExporter(
nodes[0]["*"],
nodeattrfunc=lambda node: 'label="{}"'.format(node.display_name)
).to_dotfile(
'trie.graphviz.txt' if graphviz_filename is None
else graphviz_filename
)
DotExporter(
nodes[0]["*"],
nodeattrfunc=lambda node: 'label="{}"'.format(node.display_name)
).to_picture(img_filename)
if graphviz_filename is None:
os.remove('trie.graphviz.txt')
def draw_activity_tree(root: Node, rules) -> DotExporter:
fig = DotExporter(
root,
options=["rankdir = LR;"],
nodenamefunc=lambda n: f"{n.name}\ncount={n.count}",
nodeattrfunc=lambda node: f'penwidth={5 if node.is_activity else 1}')
st.graphviz_chart(''.join(fig))
return fig
def run(self):
# checking if we have * in names
if self.algorithm_name[-1] == '*':
path = "./treeImages/" + str(
self.algorithm_name[0:-1]) + " tree.png"
else:
path = "./treeImages/" + str(self.algorithm_name) + " tree.png"
DotExporter(self.tree).to_picture(path)
self.signal.emit(path)
