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 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 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("( 🌲,( 🥑,(( 🌷, ( 🌴, ( 🍌, ( 🍍, ( 🌽, ( 🎋, 🌾 )))))),(( 🍇, ((( 🥜, ☘️), ((( 🌹, 🍓 ), (( 🍎, 🍐 ), ( 🍑, (🌸, 🍒) ))), ( 🌰, ( 🎃, ( 🍉, ( 🥒, 🍈)))))), (( 🌺, 🥦 ), (( 🍊, 🍋 ), ( 🍁, 🥭))))),( 🌵, ( 🥝, (( 🍠, ( 🌶️, (🍆, ( 🥔, 🍅)))), ( 🥕,( 🥬, ( 🌻, 🌼)))))))));")
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 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 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 set_default_TreeStyle(tree):
ts = TreeStyle()
ts.mode = "c"
ts.root_opening_factor = 1
ts.show_branch_length = True
ts.show_branch_support = True
ts.force_topology = True
ts.show_leaf_name = False
ts.min_leaf_separation = 10
ts.root_opening_factor = 1
ts.complete_branch_lines_when_necessary = True
ns = NodeStyle()
ns["size"] = 6
ns["fgcolor"] = "Black"
ns["hz_line_width"] = 8
ns["vt_line_width"] = 8
for node in tree.traverse("postorder"):
# if not node.is_leaf():
node.set_style(ns)
tree.set_style(ts)
return ts, tree
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 showTreeStructure(inputfile):
t = ClusterTree(
"./OUTPUT/%s/NWK/HIER_CLUST_%s.nwk" %
((inputfile.split("_")[0]).upper(), inputfile.split(".")[0]))
def mylayout(node):
global flag
#print node.left
# print "node",len(node )
#if len(node)!=1:# and flag == 1:
# if flag == 1:
# pidlist= getpid(node)
#print pidlist
# dcs=DoCS(pidlist,PRO_pfam)
#print dcs
# if dcs>=0.5:
# flag=0
# print pidlist,len(node),dcs
# print "_____________________"
if node.is_leaf():
node.img_style["shape"] = "sphere"
node.img_style["size"] = 10
node.img_style["fgcolor"] = 'purple'
t.dist = 0
t.convert_to_ultrametric(1, strategy="fixed")
ts = TreeStyle()
ts.scale = 230
ts.root_opening_factor = 5.0
ts.mode = "c"
ts.layout_fn = mylayout
#print mylayout
t.show(tree_style=ts)
print("--------------------------------")
print("completed")
def bub_tree(tree, fasta, outfile1, root, types, c_dict, show, size, colours,
field1, field2, scale, multiplier, dna):
"""
:param tree: tree object from ete
:param fasta: the fasta file used to make the tree
:param outfile1: outfile suffix
:param root: sequence name to use as root
:param types: tree type: circular (c) or rectangle (r)
:param c_dict: dictionary mapping colour to time point (from col_map)
:param show: show the tree in a gui (y/n)
:param size: scale the terminal nodes by frequency information (y/n)
:param colours: if using a matched fasta file, colour the sequence by charge/IUPAC
:param field1: the field that contains the size/frequency value
:param field2: the field that contains the size/frequency value
:param scale: how much to scale the x axis
:param multiplier
:param dna true/false, is sequence a DNA sequence?
:param t_list list of time points
:return: None, outputs svg/pdf image of the tree
"""
if multiplier is None:
mult = 500
else:
mult = multiplier
if dna:
dna_prot = 'dna'
bg_c = {
'A': 'green',
'C': 'blue',
'G': 'black',
'T': 'red',
'-': 'grey',
'X': 'white'
}
fg_c = {
'A': 'black',
'C': 'black',
'G': 'black',
'T': 'black',
'-': 'black',
'X': 'white'
}
else:
dna_prot = 'aa'
bg_c = {
'K': '#145AFF',
'R': '#145AFF',
'H': '#8282D2',
'E': '#E60A0A',
'D': '#E60A0A',
'N': '#00DCDC',
'Q': '#00DCDC',
'S': '#FA9600',
'T': '#FA9600',
'L': '#0F820F',
'I': '#0F820F',
'V': '#0F820F',
'Y': '#3232AA',
'F': '#3232AA',
'W': '#B45AB4',
'C': '#E6E600',
'M': '#E6E600',
'A': '#C8C8C8',
'G': '#EBEBEB',
'P': '#DC9682',
'-': 'grey',
'X': 'white'
}
fg_c = {
'K': 'black',
'R': 'black',
'H': 'black',
'E': 'black',
'D': 'black',
'N': 'black',
'Q': 'black',
'S': 'black',
'T': 'black',
'L': 'black',
'I': 'black',
'V': 'black',
'Y': 'black',
'F': 'black',
'W': 'black',
'C': 'black',
'M': 'black',
'A': 'black',
'G': 'black',
'P': 'black',
'-': 'grey',
'X': 'white'
}
if colours == 3:
bg_c = None
fg_c = None
# outfile3 = str(outfile1.replace(".svg", ".nwk"))
tstyle = TreeStyle()
tstyle.force_topology = False
tstyle.mode = types
tstyle.scale = scale
tstyle.min_leaf_separation = 0
tstyle.optimal_scale_level = 'full' # 'mid'
# tstyle.complete_branch_lines_when_necessary = False
if types == 'c':
tstyle.root_opening_factor = 0.25
tstyle.draw_guiding_lines = False
tstyle.guiding_lines_color = 'slateblue'
tstyle.show_leaf_name = False
tstyle.allow_face_overlap = True
tstyle.show_branch_length = False
tstyle.show_branch_support = False
TreeNode(format=0, support=True)
# tnode = TreeNode()
if root is not None:
tree.set_outgroup(root)
# else:
# r = tnode.get_midpoint_outgroup()
# print("r", r)
# tree.set_outgroup(r)
time_col = []
for node in tree.traverse():
# node.ladderize()
if node.is_leaf() is True:
try:
name = node.name.split("_")
time = name[field2]
kind = name[3]
# print(name)
except:
time = 'zero'
name = node.name
print("Incorrect name format for ", node.name)
if size is True:
try:
s = 20 + float(name[field1]) * mult
except:
s = 20
print("No frequency information for ", node.name)
else:
s = 20
colour = c_dict[time]
time_col.append((time, colour))
nstyle = NodeStyle()
nstyle["fgcolor"] = colour
nstyle["size"] = s
nstyle["hz_line_width"] = 10
nstyle["vt_line_width"] = 10
nstyle["hz_line_color"] = colour
nstyle["vt_line_color"] = 'black'
nstyle["hz_line_type"] = 0
nstyle["vt_line_type"] = 0
node.set_style(nstyle)
if root is not None and node.name == root: # place holder in case you want to do something with the root leaf
print('root is ', node.name)
# nstyle["shape"] = "square"
# nstyle["fgcolor"] = "black"
# nstyle["size"] = s
# nstyle["shape"] = "circle"
# node.set_style(nstyle)
else:
nstyle["shape"] = "circle"
node.set_style(nstyle)
if fasta is not None:
seq = fasta[str(node.name)]
seqFace = SequenceFace(seq,
seqtype=dna_prot,
fsize=10,
fg_colors=fg_c,
bg_colors=bg_c,
codon=None,
col_w=40,
alt_col_w=3,
special_col=None,
interactive=True)
# seqFace = SeqMotifFace(seq=seq, motifs=None, seqtype=dna_prot, gap_format=' ', seq_format='()', scale_factor=20,
# height=20, width=50, fgcolor='white', bgcolor='grey', gapcolor='white', )
# seqFace = SeqMotifFace(seq, seq_format="seq", fgcolor=fg_c, bgcolor=bg_c) #interactive=True
(tree & node.name).add_face(seqFace, 0, "aligned")
else:
nstyle = NodeStyle()
nstyle["size"] = 0.1
nstyle["hz_line_width"] = 10
nstyle["vt_line_width"] = 10
node.set_style(nstyle)
continue
tree.ladderize()
# tnode.ladderize()
legendkey = sorted(set(time_col))
legendkey = [(tp, col) for tp, col in legendkey]
# legendkey.insert(0, ('Root', 'black'))
legendkey.append(('', 'white'))
for tm, clr in legendkey:
tstyle.legend.add_face(faces.CircleFace(30, clr), column=0)
tstyle.legend.add_face(faces.TextFace('\t' + tm,
ftype='Arial',
fsize=60,
fgcolor='black',
tight_text=True),
column=1)
if show is True:
tree.show(tree_style=tstyle)
tree.render(outfile1, dpi=600, tree_style=tstyle)
newt = ete3.Tree(format=0)
R = newt.add_child(
name="R", dist=up.dist) #, dist = int_leaf.get_distance(int_leaf.name))
CLL = R.add_child(name=close_leaf_name, dist=0.0)
#print(newt)
DL = R.add_child(name=dist_leaf_name, dist=0.5)
INT = R.add_child(name=int_leaf.name, dist=minimal_dist)
#newt.set_outgroup(R)
print(newt)
#newt.show()
##visualize
ts = TreeStyle()
ts.branch_vertical_margin = 1
ts.root_opening_factor = 1
ts.scale = 50
ts.show_leaf_name = False
ts.layout_fn = layout
#nstyle = NodeStyle()
rnstyle = NodeStyle()
lnstyle = NodeStyle()
dlstyle = NodeStyle()
#color = random_color()
for rn in newt.traverse():
rnstyle["vt_line_width"] = 1
rnstyle["hz_line_width"] = 1
rnstyle["size"] = 0
rn.set_style(rnstyle)
if rn.is_leaf() and "Russia" in rn.name:
#lnstyle["bgcolor"] = '#bdbdbd'
def plot(self, placement, togjson, outdir, cfg):
"""
plot a plcement in the tree
show all pplacer placements and the LCA and HCA node
as well as the inferred lineage
"""
from ete3 import NodeStyle, TreeStyle
from ete3 import CircleFace, TextFace, RectFace
logging.debug("Plotting trees now")
# with no X display this needs to be set
os.environ["QT_QPA_PLATFORM"] = "offscreen"
info = self.loadInfo(togjson)
def defaultNodeStyle():
return NodeStyle()
nodeStyles = defaultdict(defaultNodeStyle)
no = 0
for LCAp, HPAp in zip(placement["LCA"], placement["HPA"]):
plotpath = os.path.join(outdir, f"tree_{no}.png")
# make shallow copy
t = self.t
LCA = LCAp["node"]
HPA = HPAp["node"]
# define basic tree style
ts = TreeStyle()
# hide leave names
ts.show_leaf_name = False
ts.root_opening_factor = 1
# circular tree
ts.mode = "c"
ts.rotation = 210
ts.arc_start = 0 # 0 degrees = 3 o'clock
ts.arc_span = 350
highlightsize = 80
nodesize = 10
# define styles for special nodes
# at the moment hard coded, but could be accesible for the user
# LCA style
LCAstyle = NodeStyle()
LCAstyle["fgcolor"] = "#33a02c"
LCAstyle["bgcolor"] = "#b2df8a"
LCAstyle["size"] = highlightsize
# HPA style
HPAstyle = NodeStyle()
HPAstyle["fgcolor"] = "#1f78b4"
HPAstyle["bgcolor"] = "#a6cee3"
HPAstyle["size"] = highlightsize
# default node
defaultStyle = NodeStyle()
defaultStyle["fgcolor"] = "gray"
defaultStyle["size"] = nodesize
# add legend
ts.legend_position = 1
ts.legend.add_face(CircleFace(40, LCAstyle["fgcolor"]), column=1)
ts.legend.add_face(TextFace(f"LCA", fsize=50), column=2)
ts.legend.add_face(CircleFace(40, HPAstyle["fgcolor"]), column=1)
ts.legend.add_face(TextFace(f"HPA", fsize=50), column=2)
i = 1
ts.legend.add_face(TextFace(f"p = {i}", fsize=50), column=1)
while i > 0:
temp_face = RectFace(60,
10,
fgcolor=p_to_color(i),
bgcolor=p_to_color(i))
temp_face.margin_top = -4
ts.legend.add_face(temp_face, column=1)
i -= 0.01
ts.legend.add_face(TextFace(f"p = {cfg['minPlacementLikelyhood']}",
fsize=50),
column=1)
# add highlights for each placed protein
for n in t.traverse():
if n.name.startswith("PTHR"):
# set color based on posterior prob:
x = (info[n.name]["post_prob"] -
cfg["minPlacementLikelyhood"]) / (
1 - cfg["minPlacementLikelyhood"])
# orange to purple gradient from 0 to 1 posterior propability
he = p_to_color(x)
nodeStyles[he]["bgcolor"] = he
# define back color of locations
n.set_style(nodeStyles[he])
elif n.name == LCA:
n.set_style(LCAstyle)
elif n.name == HPA:
n.set_style(HPAstyle)
else:
n.set_style(defaultStyle)
# plot to disk
_ = t.render(plotpath, w=320, units="mm", tree_style=ts)
no = no + 1
