def get_example_tree():
# Random tree
t = Tree()
t = Tree(
"(((yessefk),(ad, tuɣal),((teqbaylit),(d,(tutlayt,tunṣibt)))),(((win,yebɣan), (taqbaylit)),(((ad,yissin, (tira,-s))))),(((win,yebɣan), (taqbaylit)),(((yugar) , (ucerrig)), (tafawet))));"
)
# Some random features in all nodes
for n in t.traverse():
n.add_features(weight=random.randint(0, 50))
# Create an empty TreeStyle
ts = TreeStyle()
# Set our custom layout function
ts.layout_fn = layout
# Draw a tree
ts.mode = "c"
# We will add node names manually
ts.show_leaf_name = False
# Show branch data
ts.show_branch_length = True
ts.show_branch_support = True
return t, ts
def buble_tree():
built = False
while not built:
try:
# Random tree
t = ncbi.get_topology(idtaxa, intermediate_nodes=True)
# Some random features in all nodes
for node,weigh in zip(t,weighs):
node.add_features(weight=weigh)
# Create an empty TreeStyle
ts = TreeStyle()
# Set our custom layout function
ts.layout_fn = layout
# Draw a tree
ts.mode = "c"
# We will add node names manually
ts.show_leaf_name = True
# Show branch data
ts.show_branch_length = True
ts.show_branch_support = True
return t, ts
built = True
except KeyError as e:
taxid_not_found = int(e.args[0])
idtaxa.remove(taxid_not_found)
print("the following IDs were not found in NCBI taxonomy database:" + str(taxid_not_found))
pass
def get_example_tree():
# Random tree
t = Tree()
t.populate(20, random_branches=True)
# Some random features in all nodes
for n in t.traverse():
n.add_features(weight=random.randint(0, 50))
# Create an empty TreeStyle
ts = TreeStyle()
# Set our custom layout function
ts.layout_fn = layout
# Draw a tree
ts.mode = "c"
# We will add node names manually
ts.show_leaf_name = False
# Show branch data
ts.show_branch_length = True
ts.show_branch_support = True
return t, ts
def get_example_tree():
# Random tree
t = Tree(tree)
t.populate(20, random_branches=True)
# Some random features in all nodes
for n in t.traverse():
n.add_features(weight=random.randint(0, 50))
# Create an empty TreeStyle
ts = TreeStyle()
# Set our custom layout function
ts.layout_fn = layout
# Draw a tree
ts.mode = "c"
# We will add node names manually
ts.show_leaf_name = False
# Show branch data
ts.show_branch_length = True
ts.show_branch_support = True
return t, ts
def build_tree(one_tree, confidences):
# one_tree - egy lista, amely a szekvenciasorozatokat tartalmazza, amiket lépésekben generál
# confidences - a generálási lépéshez tartozó konfidencia
confidences = np.insert(confidences, 0, 1.0)
tree = Tree()
nodes = {'': [1.0, tree]}
for idx, seq in enumerate(one_tree):
parent = ''
for i in range(len(seq)):
if not str(seq[:i + 1]) in tree:
nodes[str(seq[:i + 1])] = []
nodes[str(seq[:i + 1])].append(confidences[idx] *
nodes[parent][0])
nodes[str(seq[:i + 1])].append(nodes[parent][1].add_child(
name=str(seq), dist=nodes[str(seq[:i + 1])][0]))
else:
parent = str(seq[:i + 1])
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = True
ts.show_branch_support = True
print(tree)
return tree
def generateColoredPDF(tree):
out_tree = os.path.splitext(os.path.basename(sys.argv[1]))[0] + ".pdf"
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_support = True
ts.show_branch_length = False
for n in tree.traverse():
if n.name in eukaryote_seqs:
nstyle = NodeStyle()
nstyle["fgcolor"] = "red"
nstyle["size"] = 15
n.set_style(nstyle)
n.name = name2tax.get(n.name)
elif n.name in bacteria_seqs:
nstyle = NodeStyle()
nstyle["fgcolor"] = "blue"
nstyle["size"] = 13
n.set_style(nstyle)
n.name = name2tax.get(n.name)
elif n.name in archaea_seqs:
nstyle = NodeStyle()
nstyle["fgcolor"] = "green"
nstyle["size"] = 13
n.set_style(nstyle)
n.name = name2tax.get(n.name)
elif n.name in other_seqs:
nstyle = NodeStyle()
nstyle["fgcolor"] = "grey"
nstyle["size"] = 13
n.set_style(nstyle)
n.name = name2tax.get(n.name)
tree.render(out_tree, tree_style=ts)
def show(self): t = Tree(self.newickFormat+";") ts = TreeStyle(self.newickFormat+";") ts.show_leaf_name = True ts.show_branch_length = True ts.show_branch_support = True t.show(tree_style=ts)
def draw_tree(self): # Визуализация дерева в GUI, и сохранение в png файл
style = TreeStyle()
style.show_leaf_name = True
style.show_branch_length = True
style.show_branch_support = True
self.tree.show(tree_style=style)
self.tree.render('tree.png', w=183, units="mm", tree_style=style)
def show_GUI_TREE(ETETree):
ts = TreeStyle()
ts.show_leaf_name = False
ts.show_branch_length = False
ts.show_branch_support = False
ts.show_border = True
ETETree.show(tree_style=ts)
def create_tree_style():
ts = TreeStyle()
ts.title.add_face(TextFace("Randomly pruned data", fsize=20), column=0)
ts.layout_fn = remove_blue_dots
ts.mode = "c"
ts.show_leaf_name = True
ts.show_branch_length = True
ts.show_branch_support = True
return ts
def plot_tree(tree, leafname2data = None , show_support = False, figname = None, outfname_tree = None): def layout(node): nst_internal = NodeStyle() nst_internal['size'] = 1 nst_internal['fgcolor'] = 'black' nst_internal["vt_line_color"] = "black" nst_internal["hz_line_color"] = "black" nst_internal["vt_line_width"] = 1 nst_internal["hz_line_width"] = 1 nst_internal["vt_line_type"] = 0 #0 solid, 1 dashed, 2 dotted nst_internal["hz_line_type"] = 0 node.set_style(nst_internal) if leafname2data != None and node.is_leaf(): if not node.name[0] == '_': print(node.name) nst = NodeStyle() node_data = leafname2data[node.name] node_name = node.name node_shape = None node_color = None if len(node_data) >= 3: node_name = node_data[0] node_shape = node_data[1] node_color = '#'+node_data[2].lower() else: node_shape = node_data[0] node_color = '#'+node_data[1].lower() nst['size'] = 15 nst['shape'] = node_shape nst['fgcolor'] = node_color node.set_style(nst) #node.add_face(TextFace(node_name, ftype='Verdana', fsize=12), column = 0, position = "aligned") ts = TreeStyle() ts.layout_fn = layout ts.show_leaf_name = False if show_support: ts.show_branch_support = True ts.branch_vertical_margin = 10 if outfname_tree != None: tree.write(outfile = outfname_tree) if figname != None: tree.render(figname, layout=layout, w=None, h=None, tree_style=ts, units='px', dpi=300) else: tree.show(tree_style=ts)
def tree_style() -> TreeStyle:
style = TreeStyle()
style.mode = "c" # draw tree in circular mode
# style.scale = 20
# style.branch_vertical_margin = 15
style.root_opening_factor = 0.04
style.show_leaf_name = False
style.show_branch_length = False
style.show_branch_support = False
return style
def draw(tree):
string = tree.as_string(schema="newick")
string = string[4:]
print(string)
t = Tree(string)
ts = TreeStyle()
ts.show_branch_length = True
ts.show_branch_support = True
t.render("mytree.png")
print('done')
def show_tree(self):
self.update_tree_values() # only actually need to update these when showing the tree
ts = TreeStyle()
ts.show_leaf_name = False
ts.show_branch_support = False
# ts.rotation = 90
# ts.title.add_face(TextFace("Hello ETE", fsize=20), column=0)
# each node contains 3 attributes: node.dist, node.name, node.support
self.tree.show(tree_style=ts) # , show_internal=True)
def draw(countriesByGenbank, tree_phy):
geo = Nominatim(user_agent='BioLocation', timeout=2)
plt.figure(figsize=(13, 12))
myMap = Basemap(projection='robin', lon_0=0, lat_0=0)
labels = []
location = []
for (key, value) in countriesByGenbank.items():
temp_location = ('NA', 'NA')
if value != 'NA':
place = geo.geocode(value.split(':')[0])
x, y = myMap(place.longitude, place.latitude)
temp_location = (x, y)
labels.append(key)
location.append(temp_location)
myMap.drawcoastlines()
myMap.drawcountries()
myMap.fillcontinents(color='white')
myMap.drawmapboundary(fill_color='aqua')
longitudes = []
latitudes = []
for longitude, latitude in location:
longitudes.append(longitude)
latitudes.append(latitude)
colors = list(mcolors.TABLEAU_COLORS)
colorsInMap = {}
markersize = 15
for label, xpt, ypt, color in zip(labels, iter(longitudes), iter(latitudes), colors):
if colorsInMap.get((xpt, ypt)):
colorsInMap.get((xpt, ypt)).append(color)
if xpt != 'NA':
myMap.plot(xpt, ypt, marker='o', markerfacecolor=color,
markersize=str(markersize - len(colorsInMap.get((xpt, ypt)))-1 ))
else:
if xpt != 'NA':
colorsInMap[(xpt, ypt)] = [color]
myMap.plot(xpt, ypt, marker='o', markerfacecolor=color, markersize=str(markersize))
nstyle = NodeStyle()
nstyle["fgcolor"] = color.split(':')[1]
tree_phy.get_leaves_by_name(label)[0].set_style(nstyle)
plt.annotate('Nodos no ancestrales', xy=(0, 0), xycoords='axes fraction')
plt.savefig('myMap.png')
ts = TreeStyle()
ts.show_branch_support = True
tree_phy.get_tree_root().render("mytree.png", tree_style=ts)
fig = plt.figure()
img = mpimg.imread('mytree.png')
imgplot = plt.imshow(img)
os.remove('egfr-family.phy.iqtree')
os.remove('egfr-family.phy.contree')
os.remove('egfr-family.phy.model.gz')
os.remove('egfr-family.phy.splits.nex')
os.remove("egfr-family.phy.bionj")
os.remove("egfr-family.phy.ckp.gz")
os.remove("egfr-family.phy.mldist")
def balanceplot(balances, tree,
layout=None,
mode='c'):
""" Plots balances on tree.
Parameters
----------
balances : np.array
A vector of internal nodes and their associated real-valued balances.
The order of the balances will be assumed to be in level order.
tree : skbio.TreeNode
A strictly bifurcating tree defining a hierarchical relationship
between all of the features within `table`.
layout : function, optional
A layout for formatting the tree visualization. Must take a
`ete.tree` as a parameter.
mode : str
Type of display to show the tree. ('c': circular, 'r': rectangular).
Note
----
The `tree` is assumed to strictly bifurcating and
whose tips match `balances.
See Also
--------
TreeNode.levelorder
"""
# The names aren't preserved - let's pray that the topology is consistent.
ete_tree = Tree(str(tree))
# Some random features in all nodes
i = 0
for n in ete_tree.traverse():
if not n.is_leaf():
n.add_features(weight=balances[-i])
i += 1
# Create an empty TreeStyle
ts = TreeStyle()
# Set our custom layout function
if layout is None:
ts.layout_fn = default_layout
else:
ts.layout_fn = layout
# Draw a tree
ts.mode = mode
# We will add node names manually
ts.show_leaf_name = False
# Show branch data
ts.show_branch_length = True
ts.show_branch_support = True
return ete_tree, ts
def draw(self,
file,
colors,
color_internal_nodes=True,
legend_labels=(),
show_branch_support=True,
show_scale=True,
legend_scale=1,
mode="c",
neighbours=None,
neighbours_block=None):
max_color = len(colors)
used_colors = set()
for node in self.tree.traverse():
if not (color_internal_nodes or node.is_leaf()): continue
color = colors[min(node.color, max_color - 1)]
node.img_style['bgcolor'] = color
used_colors.add(color)
ts = TreeStyle()
ts.mode = mode
ts.scale = self.scale
# Disable the default tip names config
ts.show_leaf_name = False
ts.show_branch_support = show_branch_support
# ts.branch_vertical_margin = 20
ts.show_scale = show_scale
cur_max_color = max(v.color for v in self.tree.traverse())
current_colors = colors[0:cur_max_color + 1]
for i, (label, color_) in enumerate(zip(legend_labels,
current_colors)):
if color_ not in used_colors: continue
rf = RectFace(20 * legend_scale, 16 * legend_scale, color_, color_)
rf.inner_border.width = 1
rf.margin_right = 14
rf.margin_left = 14
tf = TextFace(label, fsize=26 * legend_scale)
tf.margin_right = 14
ts.legend.add_face(rf, column=0)
ts.legend.add_face(tf, column=1)
if neighbours:
old_tree = self.tree.copy()
self.draw_neighbours(neighbours, neighbours_block)
self.tree.render(file, w=1000, tree_style=ts)
if neighbours:
self.tree = old_tree
def set_tree_style_extended():
ts = TreeStyle()
# for i in range(16):
# ts.legend.add_face(CircleFace(10, color_dictionary["N{0}".format(i)]), column=0)
ts.show_leaf_name = False
ts.show_branch_length = False
ts.show_branch_support = False
ts.layout_fn = my_layout_extended
return ts
def drawTree(treeFile, ShowBool):
"""
Draw a tree from a phy file
"""
t = Tree(treeFile)
imgFile = treeFile.replace(".tree", ".tree.pdf")
# Basic tree style
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_support = True
ts.scale = 50
# Draws nodes as small red spheres of diameter equal to 10 pixels
nstyle = NodeStyle()
nstyle["shape"] = "sphere"
nstyle["size"] = 10
nstyle["fgcolor"] = "darkred"
#nstyle["faces_bgcolor"] = "pink"
nstyle2 = NodeStyle()
nstyle2["shape"] = "sphere"
nstyle2["size"] = 10
nstyle2["fgcolor"] = "darkblue"
# Gray dashed branch lines
nstyle["hz_line_type"] = 1
nstyle["hz_line_color"] = "#cccccc"
# Applies the same static style to all nodes in the tree. Note that,
# if "nstyle" is modified, changes will affect to all nodes
for n in t.traverse():
if n.is_leaf():
if n.name.split("|")[-1] == "GI":
n.set_style(nstyle)
if n.name.split("|")[-1] == "plasmid":
n.set_style(nstyle2)
gi = n.name.split("|")[1]
n.name = n.name.split("|")[0] #+ " " + n.name.split("|")[1]
n.name = n.name.replace("_tRNA_modification_GTPase_", "")
n.name = n.name.replace("_DNA", "")
n.name = " " + n.name + " "
if n.name[-1] == "_": n.name.rstrip()
taxon, color = taxonToColour(gi)
n.add_face(TextFace(taxon, fgcolor=color, fsize=8),
column=1,
position="branch-right")
#n.img_style["bgcolor"] = color
if ShowBool == True: #permet de flipper les braches pour avoir des topologies similaires
t.show(tree_style=ts)
t.render(imgFile, w=1024, units="mm", tree_style=ts)
def drawTree(treeFile, ShowBool):
"""
Draw a tree from a phy file
"""
t = Tree(treeFile)
imgFile = treeFile.replace(".tree", ".tree.png")
# Basic tree style
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_support = True
ts.scale = 160
# Draws nodes as small red spheres of diameter equal to 10 pixels
nstyle = NodeStyle()
nstyle["shape"] = "sphere"
nstyle["size"] = 10
nstyle["fgcolor"] = "darkred"
#nstyle["faces_bgcolor"] = "pink"
nstyle2 = NodeStyle()
nstyle2["shape"] = "sphere"
nstyle2["size"] = 10
nstyle2["fgcolor"] = "darkblue"
# Gray dashed branch lines
nstyle["hz_line_type"] = 1
nstyle["hz_line_color"] = "#cccccc"
# Applies the same static style to all nodes in the tree. Note that,
# if "nstyle" is modified, changes will affect to all nodes
for n in t.traverse():
if n.is_leaf():
if n.name.split("|")[-1] == "GI":
n.set_style(nstyle)
if n.name.split("|")[-1] == "plasmid":
n.set_style(nstyle2)
gi = n.name.split("|")[1]
n.name = n.name.split("|")[0] #+ " " + n.name.split("|")[1]
n.name = n.name.replace("_tRNA_modification_GTPase_", "")
n.name = n.name.replace("_DNA", "")
n.name = " " + n.name + " "
if n.name[-1] == "_": n.name.rstrip()
taxon, color = taxonToColour(gi)
n.add_face(TextFace(taxon, fgcolor = color, fsize = 8), column=1, position="branch-right")
#n.img_style["bgcolor"] = color
if ShowBool == True: #permet de flipper les braches pour avoir des topologies similaires
t.show(tree_style=ts)
t.render(imgFile, w=393, units="mm", tree_style=ts)
def CreatePhyloGeneticTree(inputfile, outputfile, size):
f = open(inputfile, "r")
data = f.readlines()[0]
f.close()
tree = Tree(data)
tree.set_outgroup(tree.get_midpoint_outgroup())
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = False
ts.show_branch_support = False
ts.optimal_scale_level = "mid"
t = tree.render(str(outputfile), w=size, units="px", tree_style=None)
def get_style():
# Create an empty TreeStyle
ts = TreeStyle()
# Set our custom layout function
ts.layout_fn = layout
# Draw a tree
ts.mode = "c"
# We will add node names manually
ts.show_leaf_name = True
# Show branch data
ts.show_branch_length = True
ts.show_branch_support = True
return ts
def plot_event_tree(self):
t = Tree("((1:0.001, 0.1:0.23, 0.001, >0.001), NIE);")
t = Tree(
"((D: 0.723274, F: 0.567784)1.000000: 0.067192, (B: 0.279326, H: 0.756049)1.000000: 0.807788);"
)
t.support = 0.1
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = True
ts.show_branch_support = True
t.add_face(TextFace(" hola "), column=0, position='branch-right')
t.show(tree_style=ts)
def create_tree(nwk_file, output_png, readme):
"""
Create tree image from a nwk file.
:param nwk_file:
:param output_png:
:return:
"""
nwk = rename_accession_no(nwk_file, readme)
t = Tree(nwk)
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = True
ts.show_branch_support = True
t.render(output_png, dpi=150, units='mm', tree_style=ts)
def tree2img(newick_tree, save_path):
t = Tree(newick_tree, format=1)
ts = TreeStyle()
ts.show_leaf_name = False
ts.show_branch_length = False
ts.show_branch_support = False
def my_layout(node):
F = TextFace(node.name, tight_text=True)
add_face_to_node(F, node, column=0, position="branch-right")
ts.layout_fn = my_layout
ts.branch_vertical_margin = 10
ts.rotation = 90
t.render(save_path+'png', tree_style=ts)
t.render(save_path+'svg', tree_style=ts)
def viewPhylo(sample_info, tree_file, prefix, bootstrap):
'''
This script will utilize ete3 to draw the phylogenetic tree calculated from buildPhylo
'''
#Import the samples that we used for buildPhylo
sampleDict = import_sampleDict(sample_info)
MStree = Tree(tree_file)
#We want to assign colors to the leaves of the tree (this is based on <https://stackoverflow.com/questions/39380907/how-to-color-leaves-on-ete3-tree-python-3>)
for node in MStree.traverse():
nstyle = NodeStyle()
nstyle["vt_line_width"] = 2
nstyle["hz_line_width"] = 2
# node.img_style['size'] = 0 #Hide circles at nodes
if node.is_leaf():
nstyle = NodeStyle()
color = sampleDict[node.name]["clone_color"]
nstyle["fgcolor"] = color
nstyle["size"] = 15
node.set_style(nstyle)
else:
nstyle["size"] = 0
node.img_style = nstyle
# node.img_style["bgcolor"] = color
# name_face = TextFace(node.name, fgcolor=color, fsize=10)
# node.add_face(name_face, column=0, position='branch-right')
ts = TreeStyle()
# ts.show_leaf_name = True
ts.show_leaf_name = False
ts.show_branch_support = True
# ts.mode = "c"
# ts.arc_start = -180 # 0 degrees = 3 o'clock
# ts.arc_span = 180
if bootstrap is True:
ts.show_branch_support = True
MStree.render(prefix + ".viewPhylo.pdf", tree_style=ts)
def set_default_TreeStyle(tree, draw_nodes):
ts = TreeStyle()
ts.mode = "c"
ts.arc_start = -180
ts.arc_span = 180
ts.root_opening_factor = 1
ts.show_branch_length = False
ts.show_branch_support = True
ts.force_topology = False
ts.show_leaf_name = False
ts.min_leaf_separation = 10
ts.root_opening_factor = 1
ts.complete_branch_lines_when_necessary = True
return ts, tree
def set_tree_style():
ts = TreeStyle()
ts.legend.add_face(CircleFace(10, "red"), column=0)
ts.legend.add_face(CircleFace(10, "lime"), column=0)
ts.legend.add_face(CircleFace(10, "cyan"), column=0)
ts.legend.add_face(CircleFace(10, "plum"), column=0)
ts.legend.add_face(CircleFace(10, "lightsalmon"), column=0)
ts.legend.add_face(CircleFace(10, "indigo"), column=0)
ts.legend.add_face(CircleFace(10, "royalblue"), column=0)
ts.legend.add_face(CircleFace(10, "olive"), column=0)
ts.show_leaf_name = False
ts.show_branch_length = False
ts.show_branch_support = False
ts.layout_fn = my_layout
return ts
def my_tree():
ncbi = NCBITaxa()
my_tree = ncbi.get_topology([54263, 8324, 8323, 8327, 8325, 57571, 323754])
for n in my_tree.traverse():
n.add_features(weight=random.randint(0, 50))
ts = TreeStyle()
ts.layout_fn = layout
ts.mode = "c"
ts.show_branch_length = True
ts.show_branch_support = True
my_tree.get_ascii(attributes=["sci_name", "rank"])
return my_tree, ts
def get_tree_style():
ts = TreeStyle()
# ts.mode = 'c'
ts.margin_top = 10
ts.margin_bottom = 10
ts.margin_left = 10
ts.margin_right = 10
ts.show_leaf_name = False
ts.show_branch_length = False
ts.show_branch_support = False
ts.show_scale = False
title = TextFace(" Tax Assignment Tree", fsize=10)
title.hz_align = 2
title.vt_align = 2
ts.title.add_face(TextFace(" "), column=0)
ts.title.add_face(TextFace(" "), column=0)
ts.title.add_face(title, column=0)
return ts
def render_tree(tree, fname):
# Generates tree snapshot
npr_nodestyle = NodeStyle()
npr_nodestyle["fgcolor"] = "red"
for n in tree.traverse():
if hasattr(n, "nodeid"):
n.set_style(npr_nodestyle)
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = True
ts.show_branch_support = True
ts.mode = "r"
iterface = faces.TextFace("iter")
ts.legend.add_face(iterface, 0)
tree.dist = 0
tree.sort_descendants()
tree.render(fname, tree_style=ts, w=700)
def render_tree(tree, fname):
# Generates tree snapshot
npr_nodestyle = NodeStyle()
npr_nodestyle["fgcolor"] = "red"
for n in tree.traverse():
if hasattr(n, "nodeid"):
n.set_style(npr_nodestyle)
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = True
ts.show_branch_support = True
ts.mode = "r"
iterface = faces.TextFace("iter")
ts.legend.add_face(iterface, 0)
tree.dist = 0
tree.sort_descendants()
tree.render(fname, tree_style=ts, w=700)
def tree_layout(tree_file, ps_node_list):
t = EvolTree(tree_file, format=0)
style_other = NodeStyle()
style_other['size'] = 6
style_ps = NodeStyle()
style_ps['fgcolor'] = '#ff0000'
style_ps['size'] = 6
for node in t.iter_descendants():
descendant = t.get_descendant_by_node_id(node.node_id)
if node.node_id in ps_node_list:
descendant.img_style = style_ps
else:
descendant.img_style = style_other
ts = TreeStyle()
ts.layout_fn = layout
ts.show_branch_support = False
ts.show_branch_length = False
ts.show_leaf_name = False
result_picture = os.path.join(output_dir, 'positive_selection_tree.png')
t.render(result_picture, tree_style=ts)
def draw(self,
file,
colors,
color_internal_nodes=True,
legend_labels=(),
show_branch_support=True,
show_scale=True,
legend_scale=1,
mode="c"):
max_color = len(colors)
for node in self.tree.traverse():
if not (color_internal_nodes or node.is_leaf()): continue
color = colors[min(node.color, max_color - 1)]
node.img_style['bgcolor'] = color
ts = TreeStyle()
ts.mode = mode
ts.scale = self.scale
# Disable the default tip names config
ts.show_leaf_name = False
ts.show_branch_support = show_branch_support
# ts.branch_vertical_margin = 20
ts.show_scale = show_scale
cur_max_color = max(v.color for v in self.tree.traverse())
current_colors = colors[0:cur_max_color + 1]
for i, (label, color_) in enumerate(zip(legend_labels,
current_colors)):
ts.legend.add_face(CircleFace(24 * legend_scale, color_), column=0)
ts.legend.add_face(CircleFace(13 * legend_scale, 'White'),
column=1)
ts.legend.add_face(TextFace(label, fsize=53 * legend_scale),
column=2)
ts.legend.add_face(CircleFace(13 * legend_scale, 'White'),
column=3)
# self.tree.render("ete_tree.pdf", dpi=300, tree_style=ts)
self.tree.render(file, w=1000, tree_style=ts)
def newick_to_linkage(filePath):
""" converts newick tree to scipy linkage matrix """
tree = ClusterTree(filePath)
leaves = tree.get_leaf_names()
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = True
ts.show_branch_support = True
idx_dict = {}
idx = 0
for leaf in leaves:
idx_dict[leaf] = idx
idx += 1
idx_labels = [idx_dict.keys()[idx_dict.values().index(i)] for i in range(len(idx_dict))]
dmat = np.zeros((len(leaves), len(leaves))) # FIXME need to understand
for leaf1, leaf2 in combinations(leaves, 2):
d = tree.get_distance(leaf1, leaf2)
dmat[idx_dict[leaf1], idx_dict[leaf2]] = dmat[idx_dict[leaf2], idx_dict[leaf1]] = d
schlink = sch.linkage(scipy.spatial.distance.squareform(dmat),method='average',metric='euclidean')
def get_default_tree_style(color_dict):
ts = TreeStyle()
ts.mode = "c"
# ts.layout_fn = layout
ts.margin_top = 50
ts.margin_bottom = 0
ts.margin_left = 50
ts.margin_right = 50
ts.show_scale = False
ts.show_leaf_name = False
ts.show_branch_length = False
ts.show_branch_support = False
for p, c in color_dict.iteritems():
ts.legend.add_face(TextFace(" ", fsize=30), column=0)
ts.legend.add_face(CircleFace(10, c), column=1)
ts.legend.add_face(TextFace(" %s" % p, fsize=30), column=2)
legend_margin_line = 5
while legend_margin_line:
ts.legend.add_face(TextFace(" "), column=0)
ts.legend.add_face(TextFace(" "), column=1)
ts.legend.add_face(TextFace(" "), column=2)
legend_margin_line -= 1
ts.legend_position = 3
return ts
def balancetest(table, grouping, tree,
significance_test=None,
layout=None,
normalize=True,
mode='c'):
""" Performs statistical test on ilr balances and plots on tree.
Parameters
----------
table : pd.DataFrame
A 2D matrix of strictly positive values (i.e. counts or proportions)
where the rows correspond to samples and the columns correspond to
features.
grouping : pd.Series
Vector indicating the assignment of samples to groups. For example,
these could be strings or integers denoting which group a sample
belongs to. It must be the same length as the samples in `table`.
The index must be the same on `table` and `grouping` but need not be
in the same order.
tree : skbio.TreeNode
A strictly bifurcating tree defining a hierarchical relationship
between all of the features within `table`
significance_test : function, optional
A statistical significance function to test for significance between
classes. This function must be able to accept at least two 1D
array_like arguments of floats and returns a test statistic and a
p-value, or a single statistic. By default ``scipy.stats.f_oneway``
is used.
layout : function, optional
A layout for formatting the tree visualization. Must take a
`ete.tree` as a parameter.
mode : str
Type of display to show the tree. ('c': circular, 'r': rectangular).
Returns
-------
ete_tree : ete.Tree
ETE tree converted from the `skbio.TreeNode` object
ts : ete.TreeStyle
ETE tree style used for formatting the visualized tree,
with the test statistic plotted on each of the internal nodes.
Note
----
The `skbio.TreeNode` is assumed to strictly bifurcating and
whose tips match `table`. Also, it is assumed that none
of the values in `table` are zero. Replace with a pseudocount
if necessary.
See also
--------
skbio.TreeNode.bifurcate
skbio.stats.composition.ilr
skbio.stats.multiplicative_replacement
scipy.stats.f_oneway
"""
if np.any(table <= 0):
raise ValueError('Cannot handle zeros or negative values in `table`. '
'Use pseudo counts or ``multiplicative_replacement``.'
)
if significance_test is None:
significance_test = scipy.stats.f_oneway
sorted_features = [n.name for n in tree.tips()][::-1]
if len(sorted_features) != len(table.columns):
raise ValueError('The number of tips (%d) in the tree must be equal '
'to the number features in the table (%d).' %
(len(sorted_features), len(table.columns)))
table = table.reindex(columns=sorted_features)
mat, cats = check_table_grouping(table, grouping)
basis, nodes = phylogenetic_basis(tree)
ilr_coords = ilr(mat, basis=basis)
ete_tree = Tree(str(tree))
_cats = set(cats)
i = 0
for n in ete_tree.traverse():
if not n.is_leaf():
diffs = [ilr_coords[(cats == x).values, i] for x in _cats]
stat = significance_test(*diffs)
if len(stat) == 2:
n.add_features(weight=-np.log(stat[1]))
elif len(stat) == 1:
n.add_features(weight=stat)
else:
raise ValueError(
"Too many arguments returned by %s" %
significance_test.__name__)
i += 1
# Create an empty TreeStyle
ts = TreeStyle()
# Set our custom layout function
if layout is None:
ts.layout_fn = default_layout
else:
ts.layout_fn = layout
# Draw a tree
ts.mode = mode
# We will add node names manually
ts.show_leaf_name = False
# Show branch data
ts.show_branch_length = True
ts.show_branch_support = True
return ete_tree, ts
def run(args):
if args.text_mode:
from ete3 import Tree
for tindex, tfile in enumerate(args.src_tree_iterator):
#print tfile
if args.raxml:
nw = re.sub(":(\d+\.\d+)\[(\d+)\]", ":\\1[&&NHX:support=\\2]", open(tfile).read())
t = Tree(nw)
else:
t = Tree(tfile)
print(t.get_ascii(show_internal=args.show_internal_names,
attributes=args.show_attributes))
return
import random
import re
import colorsys
from collections import defaultdict
from ete3 import (Tree, PhyloTree, TextFace, RectFace, faces, TreeStyle,
add_face_to_node, random_color)
global FACES
if args.face:
FACES = parse_faces(args.face)
else:
FACES = []
# VISUALIZATION
ts = TreeStyle()
ts.mode = args.mode
ts.show_leaf_name = True
ts.tree_width = args.tree_width
for f in FACES:
if f["value"] == "@name":
ts.show_leaf_name = False
break
if args.as_ncbi:
ts.show_leaf_name = False
FACES.extend(parse_faces(
['value:@sci_name, size:10, fstyle:italic',
'value:@taxid, color:grey, size:6, format:" - %s"',
'value:@sci_name, color:steelblue, size:7, pos:b-top, nodetype:internal',
'value:@rank, color:indianred, size:6, pos:b-bottom, nodetype:internal',
]))
if args.alg:
FACES.extend(parse_faces(
['value:@sequence, size:10, pos:aligned, ftype:%s' %args.alg_type]
))
if args.heatmap:
FACES.extend(parse_faces(
['value:@name, size:10, pos:aligned, ftype:heatmap']
))
if args.bubbles:
for bubble in args.bubbles:
FACES.extend(parse_faces(
['value:@%s, pos:float, ftype:bubble, opacity:0.4' %bubble,
]))
ts.branch_vertical_margin = args.branch_separation
if args.show_support:
ts.show_branch_support = True
if args.show_branch_length:
ts.show_branch_length = True
if args.force_topology:
ts.force_topology = True
ts.layout_fn = lambda x: None
for tindex, tfile in enumerate(args.src_tree_iterator):
#print tfile
if args.raxml:
nw = re.sub(":(\d+\.\d+)\[(\d+)\]", ":\\1[&&NHX:support=\\2]", open(tfile).read())
t = PhyloTree(nw)
else:
t = PhyloTree(tfile)
if args.alg:
t.link_to_alignment(args.alg, alg_format=args.alg_format)
if args.heatmap:
DEFAULT_COLOR_SATURATION = 0.3
BASE_LIGHTNESS = 0.7
def gradient_color(value, max_value, saturation=0.5, hue=0.1):
def rgb2hex(rgb):
return '#%02x%02x%02x' % rgb
def hls2hex(h, l, s):
return rgb2hex( tuple([int(x*255) for x in colorsys.hls_to_rgb(h, l, s)]))
lightness = 1 - (value * BASE_LIGHTNESS) / max_value
return hls2hex(hue, lightness, DEFAULT_COLOR_SATURATION)
heatmap_data = {}
max_value, min_value = None, None
for line in open(args.heatmap):
if line.startswith('#COLNAMES'):
pass
elif line.startswith('#') or not line.strip():
pass
else:
fields = line.split('\t')
name = fields[0].strip()
values = [float(x) if x else None for x in fields[1:]]
maxv = max(values)
minv = min(values)
if max_value is None or maxv > max_value:
max_value = maxv
if min_value is None or minv < min_value:
min_value = minv
heatmap_data[name] = values
heatmap_center_value = 0
heatmap_color_center = "white"
heatmap_color_up = 0.3
heatmap_color_down = 0.7
heatmap_color_missing = "black"
heatmap_max_value = abs(heatmap_center_value - max_value)
heatmap_min_value = abs(heatmap_center_value - min_value)
if heatmap_center_value <= min_value:
heatmap_max_value = heatmap_min_value + heatmap_max_value
else:
heatmap_max_value = max(heatmap_min_value, heatmap_max_value)
# scale the tree
if not args.height:
args.height = None
if not args.width:
args.width = None
f2color = {}
f2last_seed = {}
for node in t.traverse():
node.img_style['size'] = 0
if len(node.children) == 1:
node.img_style['size'] = 2
node.img_style['shape'] = "square"
node.img_style['fgcolor'] = "steelblue"
ftype_pos = defaultdict(int)
for findex, f in enumerate(FACES):
if (f['nodetype'] == 'any' or
(f['nodetype'] == 'leaf' and node.is_leaf()) or
(f['nodetype'] == 'internal' and not node.is_leaf())):
# if node passes face filters
if node_matcher(node, f["filters"]):
if f["value"].startswith("@"):
fvalue = getattr(node, f["value"][1:], None)
else:
fvalue = f["value"]
# if node's attribute has content, generate face
if fvalue is not None:
fsize = f["size"]
fbgcolor = f["bgcolor"]
fcolor = f['color']
if fcolor:
# Parse color options
auto_m = re.search("auto\(([^)]*)\)", fcolor)
if auto_m:
target_attr = auto_m.groups()[0].strip()
if not target_attr :
color_keyattr = f["value"]
else:
color_keyattr = target_attr
color_keyattr = color_keyattr.lstrip('@')
color_bin = getattr(node, color_keyattr, None)
last_seed = f2last_seed.setdefault(color_keyattr, random.random())
seed = last_seed + 0.10 + random.uniform(0.1, 0.2)
f2last_seed[color_keyattr] = seed
fcolor = f2color.setdefault(color_bin, random_color(h=seed))
if fbgcolor:
# Parse color options
auto_m = re.search("auto\(([^)]*)\)", fbgcolor)
if auto_m:
target_attr = auto_m.groups()[0].strip()
if not target_attr :
color_keyattr = f["value"]
else:
color_keyattr = target_attr
color_keyattr = color_keyattr.lstrip('@')
color_bin = getattr(node, color_keyattr, None)
last_seed = f2last_seed.setdefault(color_keyattr, random.random())
seed = last_seed + 0.10 + random.uniform(0.1, 0.2)
f2last_seed[color_keyattr] = seed
fbgcolor = f2color.setdefault(color_bin, random_color(h=seed))
if f["ftype"] == "text":
if f.get("format", None):
fvalue = f["format"] % fvalue
F = TextFace(fvalue,
fsize = fsize,
fgcolor = fcolor or "black",
fstyle = f.get('fstyle', None))
elif f["ftype"] == "fullseq":
F = faces.SeqMotifFace(seq=fvalue, seq_format="seq",
seqtail_format="seq",
height=fsize)
elif f["ftype"] == "compactseq":
F = faces.SeqMotifFace(seq=fvalue, seq_format="compactseq",
seqtail_format="compactseq",
height=fsize)
elif f["ftype"] == "blockseq":
F = faces.SeqMotifFace(seq=fvalue, seq_format="blockseq",
seqtail_format="blockseq",
height=fsize,
fgcolor=fcolor or "slategrey",
bgcolor=fbgcolor or "slategrey",
scale_factor = 1.0)
fbgcolor = None
elif f["ftype"] == "bubble":
try:
v = float(fvalue)
except ValueError:
rad = fsize
else:
rad = fsize * v
F = faces.CircleFace(radius=rad, style="sphere",
color=fcolor or "steelblue")
elif f["ftype"] == "heatmap":
if not f['column']:
col = ftype_pos[f["pos"]]
else:
col = f["column"]
for i, value in enumerate(heatmap_data.get(node.name, [])):
ftype_pos[f["pos"]] += 1
if value is None:
color = heatmap_color_missing
elif value > heatmap_center_value:
color = gradient_color(abs(heatmap_center_value - value), heatmap_max_value, hue=heatmap_color_up)
elif value < heatmap_center_value:
color = gradient_color(abs(heatmap_center_value - value), heatmap_max_value, hue=heatmap_color_down)
else:
color = heatmap_color_center
node.add_face(RectFace(20, 20, color, color), position="aligned", column=col + i)
# Add header
# for i, name in enumerate(header):
# nameF = TextFace(name, fsize=7)
# nameF.rotation = -90
# tree_style.aligned_header.add_face(nameF, column=i)
F = None
elif f["ftype"] == "profile":
# internal profiles?
F = None
elif f["ftype"] == "barchart":
F = None
elif f["ftype"] == "piechart":
F = None
# Add the Face
if F:
F.opacity = f['opacity'] or 1.0
# Set face general attributes
if fbgcolor:
F.background.color = fbgcolor
if not f['column']:
col = ftype_pos[f["pos"]]
ftype_pos[f["pos"]] += 1
else:
col = f["column"]
node.add_face(F, column=col, position=f["pos"])
if args.image:
t.render("t%d.%s" %(tindex, args.image),
tree_style=ts, w=args.width, h=args.height, units=args.size_units)
else:
t.show(None, tree_style=ts)
def draw_tree(tree, conf, outfile):
try:
from ete3 import (add_face_to_node, AttrFace, TextFace, TreeStyle, RectFace, CircleFace,
SequenceFace, random_color, SeqMotifFace)
except ImportError as e:
print(e)
return
def ly_basic(node):
if node.is_leaf():
node.img_style['size'] = 0
else:
node.img_style['size'] = 0
node.img_style['shape'] = 'square'
if len(MIXED_RES) > 1 and hasattr(node, "tree_seqtype"):
if node.tree_seqtype == "nt":
node.img_style["bgcolor"] = "#CFE6CA"
ntF = TextFace("nt", fsize=6, fgcolor='#444', ftype='Helvetica')
add_face_to_node(ntF, node, 10, position="branch-bottom")
if len(NPR_TREES) > 1 and hasattr(node, "tree_type"):
node.img_style['size'] = 4
node.img_style['fgcolor'] = "steelblue"
node.img_style['hz_line_width'] = 1
node.img_style['vt_line_width'] = 1
def ly_leaf_names(node):
if node.is_leaf():
spF = TextFace(node.species, fsize=10, fgcolor='#444444', fstyle='italic', ftype='Helvetica')
add_face_to_node(spF, node, column=0, position='branch-right')
if hasattr(node, 'genename'):
geneF = TextFace(" (%s)" %node.genename, fsize=8, fgcolor='#777777', ftype='Helvetica')
add_face_to_node(geneF, node, column=1, position='branch-right')
def ly_supports(node):
if not node.is_leaf() and node.up:
supFace = TextFace("%0.2g" %(node.support), fsize=7, fgcolor='indianred')
add_face_to_node(supFace, node, column=0, position='branch-top')
def ly_tax_labels(node):
if node.is_leaf():
c = LABEL_START_COL
largest = 0
for tname in TRACKED_CLADES:
if hasattr(node, "named_lineage") and tname in node.named_lineage:
linF = TextFace(tname, fsize=10, fgcolor='white')
linF.margin_left = 3
linF.margin_right = 2
linF.background.color = lin2color[tname]
add_face_to_node(linF, node, c, position='aligned')
c += 1
for n in range(c, len(TRACKED_CLADES)):
add_face_to_node(TextFace('', fsize=10, fgcolor='slategrey'), node, c, position='aligned')
c+=1
def ly_full_alg(node):
pass
def ly_block_alg(node):
if node.is_leaf():
if 'sequence' in node.features:
seqFace = SeqMotifFace(node.sequence, [])
# [10, 100, "[]", None, 10, "black", "rgradient:blue", "arial|8|white|domain Name"],
motifs = []
last_lt = None
for c, lt in enumerate(node.sequence):
if lt != '-':
if last_lt is None:
last_lt = c
if c+1 == len(node.sequence):
start, end = last_lt, c
motifs.append([start, end, "()", 0, 12, "slategrey", "slategrey", None])
last_lt = None
elif lt == '-':
if last_lt is not None:
start, end = last_lt, c-1
motifs.append([start, end, "()", 0, 12, "grey", "slategrey", None])
last_lt = None
seqFace = SeqMotifFace(node.sequence, motifs,
intermotif_format="line",
seqtail_format="line", scale_factor=ALG_SCALE)
add_face_to_node(seqFace, node, ALG_START_COL, aligned=True)
TRACKED_CLADES = ["Eukaryota", "Viridiplantae", "Fungi",
"Alveolata", "Metazoa", "Stramenopiles", "Rhodophyta",
"Amoebozoa", "Crypthophyta", "Bacteria",
"Alphaproteobacteria", "Betaproteobacteria", "Cyanobacteria",
"Gammaproteobacteria",]
# ["Opisthokonta", "Apicomplexa"]
colors = random_color(num=len(TRACKED_CLADES), s=0.45)
lin2color = dict([(ln, colors[i]) for i, ln in enumerate(TRACKED_CLADES)])
NAME_FACE = AttrFace('name', fsize=10, fgcolor='#444444')
LABEL_START_COL = 10
ALG_START_COL = 40
ts = TreeStyle()
ts.draw_aligned_faces_as_table = False
ts.draw_guiding_lines = False
ts.show_leaf_name = False
ts.show_branch_support = False
ts.scale = 160
ts.layout_fn = [ly_basic, ly_leaf_names, ly_supports, ly_tax_labels]
MIXED_RES = set()
MAX_SEQ_LEN = 0
NPR_TREES = []
for n in tree.traverse():
if hasattr(n, "tree_seqtype"):
MIXED_RES.add(n.tree_seqtype)
if hasattr(n, "tree_type"):
NPR_TREES.append(n.tree_type)
seq = getattr(n, "sequence", "")
MAX_SEQ_LEN = max(len(seq), MAX_SEQ_LEN)
if MAX_SEQ_LEN:
ALG_SCALE = min(1, 1000./MAX_SEQ_LEN)
ts.layout_fn.append(ly_block_alg)
if len(NPR_TREES) > 1:
rF = RectFace(4, 4, "steelblue", "steelblue")
rF.margin_right = 10
rF.margin_left = 10
ts.legend.add_face(rF, 0)
ts.legend.add_face(TextFace(" NPR node"), 1)
ts.legend_position = 3
if len(MIXED_RES) > 1:
rF = RectFace(20, 20, "#CFE6CA", "#CFE6CA")
rF.margin_right = 10
rF.margin_left = 10
ts.legend.add_face(rF, 0)
ts.legend.add_face(TextFace(" Nucleotide based alignment"), 1)
ts.legend_position = 3
try:
tree.set_species_naming_function(spname)
annotate_tree_with_ncbi(tree)
a = tree.search_nodes(species='Dictyostelium discoideum')[0]
b = tree.search_nodes(species='Chondrus crispus')[0]
#out = tree.get_common_ancestor([a, b])
#out = tree.search_nodes(species='Haemophilus parahaemolyticus')[0].up
tree.set_outgroup(out)
tree.swap_children()
except Exception:
pass
tree.render(outfile, tree_style=ts, w=170, units='mm', dpi=150)
tree.render(outfile+'.svg', tree_style=ts, w=170, units='mm', dpi=150)
tree.render(outfile+'.pdf', tree_style=ts, w=170, units='mm', dpi=150)
args, unknown = parser.parse_known_args()
t = Tree(args.i)
ts = TreeStyle()
if args.colorleaf:
with open(args.colorleaf,'rU') as file_map:
for line in file_map:
if line:
leaf_color = list(map(str.strip,line.split('\t')))
print leaf_color
for leaf in t.get_leaves_by_name(leaf_color[0]):
leaf.set_style(NodeStyle())
if leaf.name == leaf_color[0]:
leaf.img_style["bgcolor"] = leaf_color[1]
ts.show_leaf_name = not args.noleaf
ts.show_branch_length = not args.nolength
ts.show_branch_support = not args.nosupport
if args.circular:
ts.mode = "c"
ext="svg"
if args.ext:
ext = args.ext
t.render(args.o+ext, w=183, tree_style=ts, units="mm")
from ete3 import Tree,TreeStyle,NodeStyle
import os
for tree in [file for file in os.listdir('.') if file and file.endswith('_phyml_tree.txt')]:
#print tree
try:
with open( tree, 'r') as f: # FIXME boot_trees verus phyml_tree
t = Tree(open(tree,'r').read())
ts = TreeStyle()
ns = NodeStyle()
ns['size']=0
ts.show_leaf_name = True
ts.show_branch_length = False
ts.show_branch_support = True
for n in t.traverse():
n.set_style(ns)
#t.show(tree_style=ts)
t.render( os.getcwd()+'/'+tree.replace('_phyml_tree.txt', '.png'),tree_style = ts)
except:
pass
def main(args):
if args.alignment:
t = PhyloTree(args.tree, alignment=args.alignment, alg_format='fasta')
else:
t = PhyloTree(args.tree)
if args.highlight_new:
runs = read_runs(args.highlight_new)
t.set_outgroup('EM_079422')
t.ladderize()
ts = TreeStyle()
ts.show_leaf_name = False
ts.show_branch_support = False
ts.layout_fn = layout
thick_hz_line = NodeStyle()
thick_hz_line["hz_line_width"] = 8
t.set_style(thick_hz_line)
#t.children[0].set_style(thick_hz_line)
#t.children[1].set_style(thick_hz_line)
thick_vt_line = NodeStyle()
thick_vt_line["vt_line_width"] = 4
t.set_style(thick_vt_line)
# header
if not args.hide_annotations:
ts.aligned_header.add_face(MyTextFace('Sample identifier', fstyle='Bold', fsize=8, tight_text=False), column = 1)
ts.aligned_header.add_face(MyTextFace('Prefecture', fstyle='Bold', fsize=8, tight_text=False), column = 2)
ts.aligned_header.add_face(MyTextFace('Sous-prefecture', fstyle='Bold', fsize=8, tight_text=False), column = 3)
ts.aligned_header.add_face(MyTextFace('Village', fstyle='Bold', fsize=8, tight_text=False), column = 4)
ts.aligned_header.add_face(MyTextFace('Sample received', fstyle='Bold', fsize=8, tight_text=False), column = 5)
if args.positions:
positions = read_positions(args.positions)
alg_header = RulerFace(positions,
col_width=11,
height=0, # set to 0 if dont want to use values
kind="stick",
hlines = [0],
hlines_col = ["white"], # trick to hide hz line
)
ts.aligned_header.add_face(alg_header, 6)
#legend
if args.legend:
legend = {}
for s in samples.values():
legend[s['prefec']] = s['prefec__colour']
for p in sorted(legend.keys()):
ts.legend.add_face(CircleFace(4, legend[p]), column=0)
ts.legend.add_face(MyTextFace(p, fsize=6, tight_text=False), column=1)
ts.legend_position=1
if args.circular:
ts.mode = "c"
ts.arc_start = -180 # 0 degrees = 3 o'clock
ts.arc_span = 180
# t.show(tree_style=ts)
t.render(args.output, tree_style=ts, w=1024)
"""
from ete3 import Tree, TreeStyle, NodeStyle
with open('/Users/diyadas/cdips/Topic-Ontology/SimpleWikiTree_u.txt','r') as f:
treestr = f.readlines()[0]
t = Tree( treestr.rstrip(),format=8)
circular_style = TreeStyle()
circular_style.mode = "c" # draw tree in circular mode
circular_style.scale = 120
circular_style.show_leaf_name = True
circular_style.show_branch_length = True
circular_style.show_branch_support = True
t.render("mytree.png", tree_style=circular_style)
nstyle = NodeStyle()
nstyle["hz_line_width"] = 3
nstyle["vt_line_width"] = 3
# Applies the same static style to all nodes in the tree. Note that,
# if "nstyle" is modified, changes will affect to all nodes
for n in t.traverse():
n.set_style(nstyle)
ts = TreeStyle()