def get_example_tree():
# Set dashed blue lines in all leaves
nst1 = NodeStyle()
nst1["bgcolor"] = "LightSteelBlue"
nst2 = NodeStyle()
nst2["bgcolor"] = "Moccasin"
nst3 = NodeStyle()
nst3["bgcolor"] = "DarkSeaGreen"
nst4 = NodeStyle()
nst4["bgcolor"] = "Khaki"
t = Tree("((((a1,a2),a3), ((b1,b2),(b3,b4))), ((c1,c2),c3));")
for n in t.traverse():
n.dist = 0
n1 = t.get_common_ancestor("a1", "a2", "a3")
n1.set_style(nst1)
n2 = t.get_common_ancestor("b1", "b2", "b3", "b4")
n2.set_style(nst2)
n3 = t.get_common_ancestor("c1", "c2", "c3")
n3.set_style(nst3)
n4 = t.get_common_ancestor("b3", "b4")
n4.set_style(nst4)
ts = TreeStyle()
ts.layout_fn = layout
ts.show_leaf_name = False
ts.mode = "c"
ts.root_opening_factor = 1
return t, ts
def show_tree(experiment_folder):
model = MDPD.Hierachical_MDPD(1)
model.load(os.path.join(experiment_folder, 'model.p'))
width, depth = model.width, model.depth
root = Tree()
cache = [(0, root)]
for i in range(depth + 1):
foo = []
for idx, node in cache:
paren = int((idx - 1) / width)
kid = idx - paren * width
face = faces.ImgFace(os.path.join(experiment_folder, 'images', '{}_{}_{}.png'.format(idx, paren, kid)))
node.add_face(face, 0)
if i < depth:
for k in range(width):
foo.append((idx * width + k + 1, node.add_child()))
cache = foo
ts = TreeStyle()
ts.mode = "c"
root.render(os.path.join(experiment_folder, 'images', 'tree_plot.png'), tree_style=ts)
return root
def createImg(filename, thres=0, samples=1):
count = parseLineage(filename)
suffix, matrix, taxo = getSuffixandMatrixandNewick(count,thres,samples)
newick = convert(taxo,suffix)
newick += ';'
t = Tree(newick, format=1)
ct = ClusterTree(t.write(), text_array=matrix)
addColors(ct)
# nodes are linked to the array table
array = ct.arraytable
# Calculates some stats on the matrix. Needed to establish the color gradients.
matrix_dist = [i for r in xrange(len(array.matrix))for i in array.matrix[r] if np.isfinite(i)]
matrix_max = np.max(matrix_dist)
matrix_min = np.min(matrix_dist)
matrix_avg = (matrix_max+matrix_min)/2
# Creates a profile face that will represent node's profile as a heatmap
profileFace = ProfileFace(matrix_max, matrix_min, matrix_avg, 200, 14, "heatmap",colorscheme=3)
# Creates my own layout function that uses previous faces
def mylayout(node):
# If node is a leaf
if node.is_leaf():
# And a line profile
add_face_to_node(profileFace, node, 0, aligned=True)
node.img_style["size"]=2
# Use my layout to visualize the tree
ts = TreeStyle()
ts.layout_fn = mylayout
# ct.show(tree_style=ts)
filedir = '/'.join(filename.split('/')[:-1])
# t.write(format=9, outfile="output/newick/"+param+".nw")
ct.render(filedir+'/phylo.png',tree_style=ts)
def ete_draw(self, fname=None):
""" Draws the tree and saves it to a file. If `fname` is None,
show the tree instead of saving it.
Args:
fname: filename to save to (default=None)
"""
if Cfg.USE_ETE3:
def layout(node):
faces.add_face_to_node(AttrFace("name"), node, column=0,
position="branch-right")
ts = TreeStyle()
ts.show_leaf_name = False
ts.layout_fn = layout
ts.rotation = 90
tree = EteTree(self.ete_str(), format=8)
if fname:
tree.render(fname, tree_style=ts)
else:
tree.show(tree_style=ts)
else:
# TODO maybe throw an error?
pass
def get_tree_style(self):
ts = TreeStyle()
ts.layout_fn = self.custom_layout
ts.show_leaf_name = False
ts.draw_guiding_lines = True
#ts.guiding_lines_type = 1
self._treestyle = ts
return ts
def get_example_tree():
t = Tree()
ts = TreeStyle()
ts.layout_fn = layout
ts.mode = "r"
ts.show_leaf_name = False
t.populate(10)
return t, ts
def get_example_tree():
t = Tree()
t.populate(10)
ts = TreeStyle()
ts.rotation = 45
ts.show_leaf_name = False
ts.layout_fn = rotation_layout
return t, ts
def get_example_tree():
t = Tree()
ts = TreeStyle()
ts.layout_fn = layout
ts.mode = "c"
ts.show_leaf_name = True
ts.min_leaf_separation = 15
t.populate(100)
return t, ts
def export_tree(tree, filename, insignif_color, signif_color, i_group, width):
'''
exports the given tree to the given filename
'''
ts = TreeStyle()
ts.show_leaf_name = False
ts.show_scale = False
ts.layout_fn = generate_layout(insignif_color, signif_color, i_group)
tree.render(filename, w=width, tree_style=ts)
def get_example_tree():
t = Tree()
t.populate(8, reuse_names=False)
ts = TreeStyle()
ts.layout_fn = master_ly
ts.title.add_face(faces.TextFace("Drawing your own Qt Faces", fsize=15), 0)
return t, 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 get_example_tree():
t = Tree()
t.populate(8)
# Node style handling is no longer limited to layout functions. You
# can now create fixed node styles and use them many times, save them
# or even add them to nodes before drawing (this allows to save and
# reproduce an tree image design)
# Set bold red branch to the root node
style = NodeStyle()
style["fgcolor"] = "#0f0f0f"
style["size"] = 0
style["vt_line_color"] = "#ff0000"
style["hz_line_color"] = "#ff0000"
style["vt_line_width"] = 8
style["hz_line_width"] = 8
style["vt_line_type"] = 0 # 0 solid, 1 dashed, 2 dotted
style["hz_line_type"] = 0
t.set_style(style)
#Set dotted red lines to the first two branches
style1 = NodeStyle()
style1["fgcolor"] = "#0f0f0f"
style1["size"] = 0
style1["vt_line_color"] = "#ff0000"
style1["hz_line_color"] = "#ff0000"
style1["vt_line_width"] = 2
style1["hz_line_width"] = 2
style1["vt_line_type"] = 2 # 0 solid, 1 dashed, 2 dotted
style1["hz_line_type"] = 2
t.children[0].img_style = style1
t.children[1].img_style = style1
# Set dashed blue lines in all leaves
style2 = NodeStyle()
style2["fgcolor"] = "#000000"
style2["shape"] = "circle"
style2["vt_line_color"] = "#0000aa"
style2["hz_line_color"] = "#0000aa"
style2["vt_line_width"] = 2
style2["hz_line_width"] = 2
style2["vt_line_type"] = 1 # 0 solid, 1 dashed, 2 dotted
style2["hz_line_type"] = 1
for l in t.iter_leaves():
l.img_style = style2
ts = TreeStyle()
ts.layout_fn = layout
ts.show_leaf_name = False
return t, ts
def argument(name):
g.name = name
argument_file = "static/inputs/%s.txt" % name
g.argument_tree = "/static/outputs/%s.png" % name
argument_tree = "static/outputs/%s.png" % name
try:
f = open(argument_file) # open the file
except:
abort(404)
g.premises = []
g.conclusion = None
for line in f:
g.premises.append(line.strip())
g.conclusion = g.premises[-1]
g.premises = g.premises[:-1]
stmt_set = main.open_argument(argument_file)
print stmt_set
g.sat, tree = satisfiable.satisfiable(stmt_set)
existing = os.listdir("static/outputs")
for f in existing:
if f == name + ".png":
return render_template("argument.html")
# set teh tree style...
ts = TreeStyle()
# don't show the name of the leaf nodes (which are just a x/o for a open/closed branch) in the final graph
ts.show_leaf_name = False
for child in tree.traverse():
# add a marker with the name of each node, at each node
child.add_face(TextFace(child.name), column=0, position="branch-top")
# render the file and save it
tree.render(argument_tree, tree_style=ts, w=5000)
# crop out the unwanted part of the image...
im = Image.open(argument_tree)
(x, y) = im.size
draw = ImageDraw.Draw(im)
draw.rectangle((0, y*.5, x*.25, y), fill="white")
im.save(argument_tree, "PNG")
return render_template("argument.html")
def get_example_tree():
# Create a random tree and add to each leaf a random set of motifs
# from the original set
t = Tree()
t.populate(10)
# for l in t.iter_leaves():
# seq_motifs = [list(m) for m in motifs] #sample(motifs, randint(2, len(motifs)))
# seqFace = SeqMotifFace(seq, seq_motifs, intermotif_format="line",
# seqtail_format="compactseq", scale_factor=1)
# seqFace.margin_bottom = 4
# f = l.add_face(seqFace, 0, "aligned")
ts = TreeStyle()
ts.layout_fn = layout
return t, 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 draw_tree(tree_string):
t = Tree(tree_string, format=8)
def mylayout(node):
#if node.name != 'L':
file = 'tmp/%s.png' % node.name
new_face = faces.ImgFace(file)
new_face.rotable = True
new_face.rotation = -90
#new_face.margin_top = 50
new_face.margin_left = 15
faces.add_face_to_node(new_face, node, column=0 , position='branch-top')
ts = TreeStyle()
ts.rotation = 90
ts.layout_fn = mylayout
t.show(tree_style = ts)
plt.clf()
def _get_motif_tree(tree, data, circle=True, vmin=None, vmax=None):
try:
from ete3 import Tree, NodeStyle, TreeStyle
except ImportError:
print("Please install ete3 to use this functionality")
sys.exit(1)
t = Tree(tree)
# Determine cutoff for color scale
if not(vmin and vmax):
for i in range(90, 101):
minmax = np.percentile(data.values, i)
if minmax > 0:
break
if not vmin:
vmin = -minmax
if not vmax:
vmax = minmax
norm = Normalize(vmin=vmin, vmax=vmax, clip=True)
mapper = cm.ScalarMappable(norm=norm, cmap="RdBu_r")
m = 25 / data.values.max()
for node in t.traverse("levelorder"):
val = data[[l.name for l in node.get_leaves()]].values.mean()
style = NodeStyle()
style["size"] = 0
style["hz_line_color"] = to_hex(mapper.to_rgba(val))
style["vt_line_color"] = to_hex(mapper.to_rgba(val))
v = max(np.abs(m * val), 5)
style["vt_line_width"] = v
style["hz_line_width"] = v
node.set_style(style)
ts = TreeStyle()
ts.layout_fn = _tree_layout
ts.show_leaf_name= False
ts.show_scale = False
ts.branch_vertical_margin = 10
if circle:
ts.mode = "c"
ts.arc_start = 180 # 0 degrees = 3 o'clock
ts.arc_span = 180
return t, ts
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 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_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 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 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 runcode():
stringArray = [
"CGTGAATTCAT", "GACTTAC", "GATAGCTACTTAC", "GACCCTTTATAC", "GACTTGGGAC"
]
sM = similarityMatrix(stringArray)
score = getSimilarity(sM, 2, 3)
#matrix2CSV( sM, "similarityMatrix.csv")
print score
#t = Tree( "((a,b),c);" )
#t = Tree("(Bovine:0.69395,(Gibbon:0.36079,(Orang:0.33636,(Gorilla:0.17147,(Chimp:0.19268, Human:0.11927):0.08386):0.06124):0.15057):0.54939,Mouse:1.21460):0.10;")
ourStr = mytest()
ourStr += ";"
t = Tree(ourStr)
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = True
#ts.show_branch_support = True
t.show(tree_style=ts)
def make_png(t, bad_nodes, png_name, outgroups=None):
for n in t.traverse():
n.img_style["size"] = 0
if n in bad_nodes:
nstyle = NodeStyle()
nstyle["hz_line_color"] = "red"
nstyle["hz_line_width"] = 3
n.set_style(nstyle)
if n.is_leaf():
if outgroups:
if n.name in outgroups:
name_face = TextFace(n.name, fgcolor="blue")
else:
name_face = TextFace(n.name, fgcolor="black")
else:
name_face = TextFace(n.name, fgcolor="black")
n.add_face(name_face, 0, "branch-right")
if len(bad_nodes) > 0:
ts = TreeStyle()
ts.show_leaf_name = False
gene_name = png_name
ts.title.add_face(TextFace(gene_name, fsize=15, bold=True), 0)
my_png = t.render(png_name, tree_style=ts)
def render_tree(T, out):
from ete3 import TreeStyle
ts = TreeStyle()
ts.show_leaf_name = False
ts.mode = "c"
ts.scale = 200
ts.show_scale = False
T.render(out, tree_style=ts, layout=layout_black_circles)
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 ete_draw(t,fname=None,title='',mode='r',outfile='ete_tree.png'):
from ete3 import Tree, TreeStyle, Phyloxml, TextFace
t.children
ts = TreeStyle()
#ts.branch_vertical_margin = 10
ts.show_scale=False
ts.scale = 800
ts.show_leaf_name = False
ts.mode = mode
ts.title.add_face(TextFace(title, fsize=20), column=0)
t.render(outfile,dpi=300,h=800,tree_style=ts)
return 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 main(argv):
t = Tree(argv[1])
save=int(argv[2])
ts=TreeStyle()
# ts.tree_width = 50
#t.show(tree_style=ts)
if(save==1):
if os.path.exists("crud/static/crud/Tree1.png"):
os.remove("crud/static/crud/Tree1.png")
t.render("crud/static/crud/Tree1.png", tree_style=ts)
else:
if os.path.exists("crud/static/crud/Tree2.png"):
os.remove("crud/static/crud/Tree2.png")
t.render("crud/static/crud/Tree2.png", tree_style=ts)
def make_tree_figure(nw_file):
## build tree ##
nw_format = open(nw_file)
nw_read = nw_format.read()
nw_format.close()
print(nw_read)
t = Tree(nw_read, format=1)
ts = TreeStyle()
ts.show_leaf_name = False
ts.show_scale = False
ts.show_leaf_name = False
ts.show_scale = False
t.render("label_tree.png", my_layout, tree_style=ts, dpi=150, w=600)
def run_action_change_style(self, tree, a_data):
#print "action change style called.."
if tree.tree_style == self._treestyle:
ts2 = TreeStyle()
ts2.layout_fn = self.custom_layout
ts2.show_leaf_name = False
ts2.draw_guiding_lines = True
ts2.guiding_lines_type = 0 #solid line
ts2.guiding_lines_color = a_data
tree.tree_style = ts2
self._treestyle = ts2
else:
tree.tree_style = self._treestyle
def on_actionOpen_triggered(self):
d = QtGui.QFileDialog()
d._conf = _open_newick.Ui_OpenNewick()
d._conf.setupUi(d)
d.exec_()
return
fname = QtGui.QFileDialog.getOpenFileName(
self,
"Open File",
"/home",
)
try:
t = Tree(str(fname))
except Exception as e:
print(e)
else:
self.scene.tree = t
self.img = TreeStyle()
self.redraw()
def draw_ete3_tree(organism, snplist, tree_file_name, config, c):
'''Draws a phylogenetic tree using ETE3
Keyword arguments:
organism -- the organism of which to make a tree
snplist -- a list of the SNP names, positions and state
file_name -- the name of the out-file _tree.pdf will be added
'''
newick = tree_to_newick(organism, config, c)
tree = Tree(newick, format=1)
tree_depth = int(tree.get_distance(tree.get_farthest_leaf()[0]))
for n in tree.traverse():
# Nodes are set to red colour
nstyle = NodeStyle()
nstyle["fgcolor"] = "#BE0508"
nstyle["size"] = 10
nstyle["vt_line_color"] = "#000000"
nstyle["hz_line_color"] = "#000000"
nstyle["vt_line_type"] = 0
nstyle["hz_line_type"] = 0
nstyle["vt_line_width"] = 2
nstyle["hz_line_width"] = 2
## ['B.3', 'T', 'C', 'A']
for snp in snplist.keys():
if n.name == snp and snplist[snp] == 0:
# If the SNP is missing due to a gap, make it grey
nstyle["fgcolor"] = "#DDDDDD"
nstyle["size"] = 10
nstyle["vt_line_color"] = "#DDDDDD"
nstyle["hz_line_color"] = "#DDDDDD"
nstyle["vt_line_type"] = 1
nstyle["hz_line_type"] = 1
elif n.name == snp and snplist[snp] == 1:
nstyle["fgcolor"] = "#99FF66"
nstyle["size"] = 15
nstyle["vt_line_color"] = "#000000"
nstyle["hz_line_color"] = "#000000"
nstyle["vt_line_type"] = 0
nstyle["hz_line_type"] = 0
n.set_style(nstyle)
ts = TreeStyle()
ts.show_leaf_name = False # Do not print(leaf names, they are added in layout)
ts.show_scale = False # Do not show the scale
ts.layout_fn = self.CanSNPer_tree_layout # Use the custom layout
ts.optimal_scale_level = 'full' # Fully expand the branches of the tree
if config["dev"]:
print("#[DEV] Tree file: %s" % tree_file_name)
tree.render(tree_file_name, tree_style=ts, width=tree_depth * 500)
def plot_tree(tree, save=False, path=''):
# style
ts = TreeStyle()
ts.show_leaf_name = True
ts.mode = "c"
ts.arc_start = -180
ts.arc_span = 360
#plot tree
if save:
tree.render(file_name=path, tree_style=ts)
tree.show(tree_style=ts)
def get_example_tree():
t = Tree("((a,b),c);")
right_c0_r0 = TextFace("right_col0_row0")
right_c0_r1 = TextFace("right_col0_row1")
right_c1_r0 = TextFace("right_col1_row0")
right_c1_r1 = TextFace("right_col1_row1")
right_c1_r2 = TextFace("right_col1_row2")
top_c0_r0 = TextFace("top_col0_row0")
top_c0_r1 = TextFace("top_col0_row1")
bottom_c0_r0 = TextFace("bottom_col0_row0")
bottom_c1_r0 = TextFace("bottom_col1_row0")
aligned_c0_r0 = TextFace("aligned_col0_row0")
aligned_c0_r1 = TextFace("aligned_col0_row1")
aligned_c1_r0 = TextFace("aligned_col1_row0")
aligned_c1_r1 = TextFace("aligned_col1_row1")
t.add_face(right_c0_r1, column=1, position="branch-right")
t.add_face(right_c0_r0, column=0, position="branch-right")
t.add_face(right_c1_r2, column=2, position="branch-right")
t.add_face(right_c1_r1, column=1, position="branch-right")
t.add_face(right_c1_r0, column=0, position="branch-right")
t.add_face(top_c0_r1, column=1, position="branch-top")
t.add_face(top_c0_r0, column=0, position="branch-top")
t.add_face(bottom_c0_r0, column=0, position="branch-bottom")
t.add_face(bottom_c1_r0, column=1, position="branch-bottom")
for leaf in t.iter_leaves():
leaf.add_face(aligned_c0_r1, 0, "aligned")
leaf.add_face(aligned_c0_r0, 0, "aligned")
leaf.add_face(aligned_c1_r1, 0, "aligned")
leaf.add_face(aligned_c1_r0, 0, "aligned")
return t, TreeStyle()
def visualize(self, group1=None, group2=None):
import matplotlib
import matplotlib.pyplot as plt
# annotate the cluster roots with their fractions
if group1 or group2:
for i, cluster_root in enumerate(self.cluster_roots):
# count downstream conditions in the leafs
datapoints_in_cluster = list(self.nodes2leaves[cluster_root])
cluster_root.add_face(
TextFace(f"Group1: {len(group1)}// Group2:{len(group2)}"),
column=0,
position="branch-right")
def _custom_layout(node):
cmap_cluster = plt.cm.tab10(
np.linspace(0, 1, len(self.cluster_roots)))
cmap_treated = plt.cm.viridis(np.linspace(0, 1, 2))
if node.is_leaf():
c_cluster = matplotlib.colors.rgb2hex(
cmap_cluster[node.clustering, :])
c_treat = matplotlib.colors.rgb2hex(
cmap_treated[node.treated, :])
node.img_style["fgcolor"] = c_treat
node.img_style["bgcolor"] = c_cluster
if 'is_cluster_root' in node.features:
c_cluster = matplotlib.colors.rgb2hex(
cmap_cluster[node.is_cluster_root, :])
node.img_style["bgcolor"] = c_cluster
node.img_style["draw_descendants"] = False
node.add_face(TextFace(f"#data:{node.n_datapoints}"),
column=0,
position="branch-right")
ts = TreeStyle()
ts.mode = "r"
ts.show_leaf_name = False
ts.arc_start = -180 # 0 degrees = 3 o'clock
ts.arc_span = 270
ts.layout_fn = _custom_layout
self.tree.show(tree_style=ts)
def network_size_view(tree, orthologous_groups, save_dir):
# Set the size of each node
for node in tree.traverse():
# Count the number of genes likely to be regulated in this node
num_regulated = len([
grp for grp in orthologous_groups
if grp.most_likely_state_at(node.name) == '1'
])
nstyle = NodeStyle()
nstyle['size'] = 0
node.set_style(nstyle)
circle_face = CircleFace(radius=num_regulated,
color='green',
style='sphere',
label={
'text': str(num_regulated),
'color': 'black'
})
node.add_face(circle_face, column=2)
ts = TreeStyle()
tree.render(os.path.join(save_dir, 'network_size.svg'), tree_style=ts)
def view_by_gene(tree, orthologous_grp, save_file):
# Make a copy of the tree
tree = copy.deepcopy(tree)
for node in tree.traverse():
percents = [orthologous_grp.regulation_states[(node.name, s)] * 100
for s in ['1', '0', 'A']]
stacked_bar_face = StackedBarFace(percents, width=30, height=15,
colors=['green', 'red', 'blue'])
stacked_bar_face.margin_left = 5
stacked_bar_face.margin_right = 5
node.add_face(stacked_bar_face, column=1)
# Add locus tag if the genome has the gene from this orthologous group
if node.is_leaf():
# Check if the orthologous group contains any gene of the genome
gene = orthologous_grp.member_from_genome(node.name)
if gene:
node.add_face(TextFace(text='[%s]' % gene.locus_tag), column=2)
ts = TreeStyle()
ts.title.add_face(TextFace(text=orthologous_grp.description), column=1)
tree.render(save_file, tree_style=ts)
def get_tree_shape(newick, graph, lower_threshold, higher_threshold):
t = Tree(newick, format=8)
for n in t.traverse():
nstyle = NodeStyle()
nstyle["fgcolor"] = "yellow"
name = newick_to_name(n.name)
if name != '':
if graph.nodes[name]["val"] > higher_threshold:
nstyle["fgcolor"] = "green"
elif graph.nodes[name]["val"] < lower_threshold:
nstyle["fgcolor"] = "red"
nstyle["size"] = 5
n.set_style(nstyle)
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = False
ts.min_leaf_separation = 0.5
ts.mode = "c"
ts.root_opening_factor = 0.75
return t, ts
def writeTrees(trees, label):
"""
Now that we have branch lengths, write out new Newick trees with the
branch lengths included. Note that ete3 does not seem to write out
the length of the root automatically, so we add it in by hand.
"""
ts = TreeStyle()
ts.show_leaf_name = False
ts.show_branch_length = False
ts.branch_vertical_margin = 20
ts.scale = 0.05
outtrees = open(lengthdir + label + ".newick", "w")
for index, tree in enumerate(trees):
#print(tree)
#If needed: round the branch lengths
# for branch in tree.traverse():
# branch.dist = round(branch.dist)
line = tree.write(format=1)
rootlen = round(tree.get_tree_root().dist)
line = line[:-1] + ":" + str(rootlen) + ";"
outtrees.write(line + "\n")
if (showTrees):
for branch in tree.traverse():
if branch.name != "":
name_face = AttrFace("name", fsize=30)
branch.add_face(name_face,
column=0,
position="branch-right")
if branch.dist != 0:
if branch.name == "":
text_face = TextFace(str(round(branch.dist, 2)),
fsize=30)
branch.add_face(text_face,
column=1,
position="branch-top")
else:
print("Branch found of length zero but not a tip in tree",
label)
print(branch)
filename = label
if len(trees) > 1:
filename += "_" + str(index)
filename += ".png"
tree.render(lengthdir + filename, tree_style=ts)
#foo()
outtrees.close()
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 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 __init__(self, root_text):
# Inicializa la estructura árbol
tree = Tree()
# Formateamos el árbol indicandole un estilo
style = TreeStyle()
style.show_leaf_name = True
style.show_scale = False
style.scale = 100
style.branch_vertical_margin = 30
style.rotation = 0
style.orientation = 0
self.style = style
self.tree = tree
# Le damos estilo a la raíz del árbol
self.tree.add_face(TextFace(root_text, fsize=10, fgcolor='darkred'),
column=0,
position='branch-right')
self.tree.set_style(NodeStyle(size=20, hz_line_width=2,
fgcolor='blue'))
# Almacenamos la raíz del árbol como nodo actual
self.curr_node = self.tree
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 draw_tree(pstrains, names=False, subset=None):
evol = {x.rstrip() for x in open('input/evolution_experiment.txt')}
tree = get_tree('input/tree.nwk')
strains = {x.name for x in tree.traverse() if x.name != ''}
if subset is None:
subset = strains
evol_tree = {x.name for x in tree.traverse() if x.name in evol}
commensals = {}
for x in strains:
if pstrains[x] == 'Commensal strain':
commensals[x] = colors.cnames['blue']
elif pstrains[x] == 'Pathogenic strain':
commensals[x] = colors.cnames['red']
else:
commensals[x] = colors.cnames['white']
ref = NodeStyle()
ref['fgcolor'] = sns.xkcd_rgb['light red']
inner = NodeStyle()
inner['size'] = 0
for n in tree.traverse():
if not n.is_leaf():
n.set_style(inner)
continue
if n.name not in subset:
continue
if not names:
r = RectFace(10, 3, commensals[n.name], commensals[n.name])
n.add_face(r, 0, position="aligned")
ev = NodeStyle()
ev["fgcolor"] = "black"
ev['size'] = 3
n.set_style(ev)
circular_style = TreeStyle()
circular_style.mode = "c"
if not names:
circular_style.scale = 1300
else:
circular_style.scale = 7300
circular_style.show_leaf_name = names
return tree, circular_style
def treeLayout(self):
# Add a tree style and a legend
self.ts = TreeStyle()
self.ts.show_scale = False
self.ts.show_leaf_name = False
self.ts.extra_branch_line_type = 0
self.ts.extra_branch_line_color = 'black'
self.ts.layout_fn = self.layout
self.ts.branch_vertical_margin = -10
self.ts.legend_position = 4
self.ts.legend.add_face(TextFace(
datetime.now().strftime('%a, %d.%m.%Y; %H:%M:%S'), fsize=8),
column=1)
self.ts.legend.add_face(TextFace('Tree: ' + self.treefile, fsize=8),
column=1)
self.ts.legend.add_face(TextFace('Pruning: ' + self.prune, fsize=8),
column=1)
# Order the graphical tree output from highly branched nodes on top and less branched nodes to the bottom
self.t.ladderize(1)
def plot_newick(aug_cluster_list, mode='c', db=-1):
circular_style = TreeStyle()
circular_style.mode = mode # draw tree in circular mode
circular_style.scale = 20
circular_style.arc_span = 360
if db > 0:
newick = convert_to_newick_db(aug_cluster_list,
len(aug_cluster_list) - 1, db)
circular_style.mode = mode
else:
newick = convert_to_newick(aug_cluster_list, len(aug_cluster_list) - 1)
newick = newick + ':0;'
t = Tree(newick, format=1)
t.show(tree_style=circular_style)
if False:
t.render('tree3.png', w=100, units='in', tree_style=circular_style)
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 treeLayout(self):
# Add a tree style and a legend
self.ts = TreeStyle()
self.ts.show_scale = False
self.ts.show_leaf_name = False
self.ts.extra_branch_line_type = 0
self.ts.extra_branch_line_color = 'black'
self.ts.layout_fn = self.layout
self.ts.branch_vertical_margin = -10
self.ts.legend_position = 4
for feature, color in zip(sorted(self.featurenames.keys()),
self.colors):
self.ts.legend.add_face(CircleFace(10, color), column=0)
self.ts.legend.add_face(TextFace(self.featurenames[feature]),
column=1)
if self.empty:
self.ts.legend.add_face(CircleFace(10, self.colors[-1]), column=0)
self.ts.legend.add_face(TextFace('none'), column=1)
self.ts.legend.add_face(TextFace(
datetime.now().strftime('%a, %d.%m.%Y; %H:%M:%S'), fsize=8),
column=1)
self.ts.legend.add_face(TextFace('Tree: ' + self.treefile, fsize=8),
column=1)
self.ts.legend.add_face(TextFace('Clusters: ' + self.loadfile,
fsize=8),
column=1)
self.ts.legend.add_face(TextFace('Pruning: ' + self.prune, fsize=8),
column=1)
# Order the graphical tree output from highly branched nodes on top and less branched nodes to the bottom
self.t.ladderize(1)
def make_plot():
df = pd.read_csv(f'{args.output}/aa_comp.tsv', sep="\t")
df = df.set_index('Taxon')
z = shc.linkage(df, method='ward')
t = distance_matrix2tree(z, df.index.values)
t.write(outfile=f'{args.output}/distance_matrix.tre')
# Basic tree style
ts = TreeStyle()
ts.show_leaf_name = False
ts.mode = "c"
ts.show_scale = False
ts.layout_fn = mylayout
# PDF rendering
t.render(f'{args.output}/aa_comp_calculator.pdf',
w=183,
units="mm",
tree_style=ts)
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 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
metadata = get_meta_new(metadata, big_tree)
colourDict = get_colours(clusters, big_tree, colours)
# remove dodgy sample
big_tree.search_nodes(name="'EBOV|EMLab-RT|IPDPFHGINSP_GUI_2015_5339||GIN|Conakry|?|MinION_LQ05|2015-04-08'")[0].delete(
preserve_branch_length=True
)
# root the same as the MCC tree
ancestor = big_tree.get_common_ancestor(
"'EBOV|EMLab|EM_079422|KR817187|GIN|Macenta|?||2014-03-27'",
"'EBOV|EMLab|Gueckedou-C05|KJ660348|GIN|Gueckedou|?||2014-03-19'",
)
big_tree.set_outgroup(ancestor)
big_tree.ladderize()
ts = TreeStyle()
ts.show_leaf_name = False
# ts.show_branch_support = True
ts.scale = 100000
if mode == "small":
ts.scale = 750000
# add legend
for each in colourDict.keys():
ts.legend.add_face(CircleFace(radius=size[mode] / 2, color=colourDict[each]), column=0)
ts.legend.add_face(TextFace(each, ftype="Helvetica", fsize=size[mode]), column=1)
ts.legend.add_face(CircleFace(radius=size[mode] / 2, color="#F1F1F1"), column=0)
ts.legend.add_face(TextFace("Guinea", ftype="Helvetica", fsize=size[mode]), column=1)
ts.legend.add_face(RectFace(width=size[mode], height=size[mode], bgcolor="#D3D3D3", fgcolor="#FFFFFF"), column=0)
ts.legend.add_face(TextFace("Sierra Leone", ftype="Helvetica", fsize=size[mode]), column=1)
ts.legend.add_face(
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)
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
#!/usr/bin/python #figure IES loss from __future__ import print_function from ete3 import Tree, NodeStyle, TreeStyle from pyies.userOptions import basePath import os.path import string geneFamily = '4137' analysis = '2' phyldogResultsPath = "analysis/phyldogT" + analysis + "/results" treeF = os.path.join(basePath, 'analysis', 'phyldogT' + analysis, 'results', geneFamily + ".ReconciledTree" ) alnF = os.path.join(basePath, 'analysis', 'msas', 'filtered', 'cluster.' + geneFamily + '.nucl.fa') t = Tree(treeF) ts = TreeStyle() ts.scale = 500 nstyle = NodeStyle() nstyle["size"] = 0 for n in t.traverse(): n.set_style(nstyle) #seqs = SeqGroup(sequences = alnF, format = "fasta") # for leaf in t: # geneId = leaf.name # seq = seqs.get_seq(geneId) # seq = seq.translate(None, string.ascii_lowercase) # keep only CDS # #iesmotif = [[1, len(seq), "line", 2, 5, None, None, None]] # #seqFace = SeqMotifFace(seq = seq, gap_format = "blank", seq_format = "line") # seqFace = SequenceFace(seq, seqtype = 'dna')
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)
[6,5,7,3],
[7,5,7,3]],
dtype=np.int16)
#root = Tree( "((a,b),c);" )
[rows, columns] = treeStruct.shape
root = Tree()
node_cur = root
'''#######################
Tree Style Begin
'''
ts = TreeStyle()
ts.title.add_face(TextFace("Tree example", fsize=8), column=0)
ts.scale = 50
ts.mode = 'r'
# left or right
ts.orientation = 1
ts.rotation = 270
ts.show_leaf_name = False
ts.show_branch_length = True
#ts.show_branch_length = True
'''
Tree Style End
#######################'''
@author: diyadas
This script plots trees of our wikipedia data.
"""
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():
Rangifer_tarandus,http://media.eol.org/content/2014/05/02/09/88803_98_68.jpg,109.09,herbivore
Cervus_elaphus,http://media.eol.org/content/2013/02/22/16/31998_98_68.jpg,240.87,herbivore
Bos_taurus,http://media.eol.org/content/2014/09/29/06/46535_98_68.jpg,618.64,herbivore
Ovis_orientalis,http://media.eol.org/content/2015/01/04/05/30107_98_68.jpg,39.1,herbivore
Suricata_suricatta,http://media.eol.org/content/2012/06/19/04/84840_98_68.jpg,0.73,carnivore
Mephitis_mephitis,http://media.eol.org/content/2012/08/30/16/23686_98_68.jpg,2.4,omnivore"""
tip2info = {}
for line in tip_info_csv.split('\n'):
if line:
name, url, mass, habit = map(str.strip, line.split(','))
tip2info[name] = [url, mass, habit]
# Server configuration
ts = TreeStyle()
ts.layout_fn = custom_layout
ts.show_leaf_name = False
ts2 = TreeStyle()
actions = NodeActions()
actions.add_action('Root here', show_action_root, run_action_root, None)
actions.add_action('Highlight', show_action_highlight, run_action_highlight, None)
actions.add_action('Change style', show_action_change_style, run_action_change_style, None)
actions.add_action('EOL link', show_eol_link, None, eol_link)
actions.add_action('Change color', show_action_linecolor, None, change_linecolor)
start_server(node_actions=actions, tree_style=ts)
