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 custom_treestyle():
ts = TreeStyle()
ts.layout_fn = custom_layout
ts.show_leaf_name = False
ts.branch_vertical_margin = 0
ts.min_leaf_separation = 0
return ts
def generate_type_tree_figure(output_file):
""" Generate type_tree.png image.
It needs ETE dependencies installed
cf http://etetoolkit.org/new_download/ or use anaconda
:param output_file: str
"""
try:
from ete3 import faces, TextFace, TreeStyle
except ImportError as e:
logger.warning(
'ImportError : %s Generation of type_tree figure need ETE dependencies to '
'be installed Use from anaconda, or look at installation procedure on '
'http://etetoolkit.org/new_download/', e)
return
# Define custom tree style
ts = TreeStyle()
ts.show_leaf_name = False
ts.show_scale = False
ts.orientation = 1
ts.branch_vertical_margin = 20
def my_layout(node):
F = TextFace(node.name, fsize=16, ftype='Courier', bold=True)
faces.add_face_to_node(F, node, column=10, position="branch-right")
ts.layout_fn = my_layout
TYPES_STRING_TREE.render(output_file, tree_style=ts)
def get_tree(tree1, abundance):
for n in tree1.iter_leaves():
face1 = CircleFace(abundance[n.name][0],
abundance[n.name][1],
style='sphere')
face2 = TextFace(n.name,
ftype='Verdana',
fsize=10,
fgcolor='black',
penwidth=0,
fstyle='normal',
tight_text=False,
bold=False)
face1.opacity = 0.9
n.add_face(face1, column=0)
n.add_face(
face2, column=0,
position="branch-right") #branch-top branch-bottom branch-right
tree1.ladderize()
ts = TreeStyle()
ts.mode = 'r'
ts.scale = scale1
ts.show_leaf_name = False
return tree1, 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 plot_uncorrected_phylogeny(tree, species, latin_names, species_history):
"""
Generates a PDF figure of the input tree with same length for all branches.
:param tree: input tree from configuration file
:param species: the current focal species
:param latin_names: a dictionary-like data structure that associates each informal species name to its latin name
:param species_history: the list of ancestor nodes of the focal species, including the focal species and going up to the root.
"""
label_leaves_with_latin_names(tree, latin_names)
node_and_branch_style(tree)
ts = TreeStyle()
# ts.title.add_face(TextFace(" Input phylogenetic tree", ftype="Arial", fsize=18), column=0)
ts.orientation = 1
ts.branch_vertical_margin = 14
ts.show_leaf_name = False # because there is a Face showing it
ts.show_branch_length = False
ts.margin_left = 25
ts.margin_right = 25
ts.margin_top = 25
ts.margin_bottom = 25
ts.scale = 200
ts.show_scale = False
tree.render(os.path.join("rate_adjustment", f"{species}",
f"{_TREE.format(species)}"),
w=4.5,
units="in",
tree_style=ts)
def traitTreeMinimal(traits, mapper):
### Take dict of traits and [R,G,B]-returning function
### Draw a tree with the continuous trait painted on via a colormapping function
def rgb2hex(r, g, b):
hex = "#{:02x}{:02x}{:02x}".format(r, g, b)
return hex
ts = TreeStyle()
ts.show_leaf_name = False
ts.rotation = 270
ts.complete_branch_lines_when_necessary = False
#ts.optimal_scale_level = "full"
ts.scale = 800
# default NodeStyle
nstyle = NodeStyle()
nstyle["size"] = 0
nstyle["hz_line_color"] = "grey"
nstyle["vt_line_color"] = "grey"
nstyle["hz_line_width"] = 3
nstyle["vt_line_width"] = 3
for n in tree.traverse():
chroma = rgb2hex(*[
int(val) for val in mapper(traits[n.ND], gamma=0.8, scaleMax=255)
]) # setup for wl2RGB
nf = CircleFace(radius=10, color='none', style='circle', label=None)
n.set_style(nstyle)
n.add_face(nf, column=0, position='branch-top')
outFile = args.output + "/test_trees/cont_trait.pdf"
tree.render(outFile, tree_style=ts)
print >> sys.stderr, outFile
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 writeTrees(trees, label):
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")
#round the branch lengths
for index, tree in enumerate(trees):
#print(tree)
for branch in tree.traverse():
branch.dist = round(branch.dist)
line = tree.write(format=1)
outtrees.write(line + "\n")
if (showTrees):
for branch in tree.traverse():
if branch.dist != 0:
text_face = TextFace(str(round(branch.dist, 2)), fsize=30)
branch.add_face(text_face, column=1, position="branch-top")
elif branch.name != "":
name_face = AttrFace("name", fsize=30)
branch.add_face(name_face,
column=0,
position="branch-right")
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 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 show_and_render_tree(tree, output_file_name, mut_order):
# The following makes it show internal nodes
def my_layout(node):
if hasattr(node, 'has_face'):
return
if node.is_leaf():
# If terminal node, draws its name
name_face = AttrFace("name", fsize=12)
node.add_face(name_face, column=0, position="branch-right")
else:
# If internal node, draws label with smaller font size
if node.name == 'root':
label = 'root'
else:
label = str(mut_order[int(node.name)])
name_face = TextFace(label, fsize=10)
node.add_face(name_face, column=0, position="branch-top")
node.add_feature('has_face', True)
# Adds the name face to the image at the preferred position
#faces.add_face_to_node(name_face, node, column=0, position="branch-top")
ts = TreeStyle()
# Do not add leaf names automatically
ts.show_leaf_name = False
# Use my custom layout
ts.layout_fn = my_layout
tree.show(tree_style=ts)
tree.render(output_file_name, tree_style=ts, dpi=180)
def plot_trees(tree_fn, output_fn):
""" Plot a tree """
os.environ['QT_QPA_PLATFORM'] = 'offscreen'
style = TreeStyle()
style.mode = "c"
style.show_leaf_name = True
# Set Node Styles
rstyle = NodeStyle()
rstyle["shape"] = "sphere"
rstyle["size"] = 15
rstyle["fgcolor"] = "blue"
nstyle = NodeStyle()
nstyle["shape"] = "sphere"
nstyle["size"] = 0
sstyle = NodeStyle()
sstyle["shape"] = "sphere"
sstyle["size"] = 15
sstyle["fgcolor"] = "red"
#Create the tree object
ct = Tree(tree_fn)
for n in ct.traverse():
if n.name == "Wuhan" or n.name == "Wuhan|402124":
n.set_style(rstyle)
elif n.name == "Sample":
n.set_style(sstyle)
elif not n.is_leaf():
n.set_style(nstyle)
#Draw the tree and write to a file
ct.render(output_fn, tree_style=style)
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(tree, color_dict=None, annot_dict=None, col=None):
used_colours = set()
for n in tree.traverse():
if n.is_leaf():
if n.name in annot_dict:
n.img_style["bgcolor"] = color_dict[annot_dict[n.name]]
used_colours.add(annot_dict[n.name])
ts = TreeStyle()
ts.layout_fn = layout
ts.show_leaf_name = False
ts.mode = "c"
# ts.arc_start = -180 # 0 degrees = 3 o'clock
# ts.arc_span = 180
# ts.root_opening_factor = 1
# print (used_colours)
for k,v in color_dict.items():
# Check that the specific colour was actually present in the tree we're annotating
if k in used_colours:
ts.legend.add_face(CircleFace(100, v), column=0)
ts.legend.add_face(TextFace(k, fsize=50), column=1)
# Add title
ts.title.add_face(TextFace("Colouring tips on " + col, fsize=100), column=0)
return tree, ts
def make_tree(t):
ts = TreeStyle()
## make the tree in to a cladogram
most_distant_leaf, tree_length = t.get_farthest_leaf()
current_dist = 0
for postorder, node in t.iter_prepostorder():
if postorder:
current_dist -= node.dist
else:
if node.is_leaf():
node.dist += tree_length - (current_dist + node.dist)
elif node.up: # node is internal
current_dist += node.dist
## Rotate and color the lables
def rotation_layout(node):
if node.is_leaf():
if node.name == 'X':
F = TextFace(node.name, tight_text=True, fgcolor='Blue')
F.rotation = 90
add_face_to_node(F, node, column=0, position="branch-right")
elif node.name == 'Y':
F = TextFace(node.name, tight_text=True, fgcolor='Red')
F.rotation = 90
add_face_to_node(F, node, column=0, position="branch-right")
elif node.name == 'A':
F = TextFace("")
add_face_to_node(F, node, column=0, position="branch-right")
else:
F = TextFace(node.name, tight_text=True, fgcolor='Green')
F.rotation = 90
add_face_to_node(F, node, column=0, position="branch-right")
## Format the tree image
nstyle = NodeStyle()
nstyle["hz_line_type"] = 0
nstyle["vt_line_color"] = "#ffffff"
nstyle["hz_line_color"] = "#ffffff"
nstyle["vt_line_width"] = 4
nstyle["hz_line_width"] = 4
nstyle["size"] = 0
for n in t.traverse():
n.set_style(nstyle)
## Set background
t.img_style["bgcolor"] = "#2e3440"
## Tree 'shape'
ts.min_leaf_separation = 20
ts.show_leaf_name = False
ts.layout_fn = rotation_layout
ts.rotation = -90
ts.show_scale = False
#t.show(tree_style=ts)
t.render(f"{t.name}.svg", tree_style=ts, dpi=900)
def actualRun():
start = time.time()
#stringArray = ["CGTGAATTCAT", "GACTTAC", "GATAGCTACTTAC", "GACCCTTTATAC", "GACTTGGGAC"]
nameArray = []
stringArray = parseXML(nameArray)
for i in range(0, len(nameArray)):
print "{}:{}".format(i, nameArray[i])
sM = similarityMatrix(stringArray)
#printMatrix(sM, len(stringArray))
fullMat = wholeMat(sM)
#printMatrix(fullMat, len(stringArray))
#score = getSimilarity( sM , 2, 3)
#print score
mat = invertNumMat(fullMat)
printMatrix(mat, len(stringArray))
items = len(stringArray)
#print items
ourStr = properRun(mat, items)
ourStr += ";"
t = Tree(ourStr)
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = True
#ts.show_branch_support = True
end = time.time()
print "time: {}".format(end - start)
t.show(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_raw_tree(filename: str) -> None:
"""Draws a raw tree from ete3 representation
stored in a file
Parameters
----------
filename : str
a name of the file
Returns
-------
None
"""
ts = TreeStyle()
ts.show_leaf_name = False
ts.layout_fn = layout_raw
ts.rotation = 90
ts.branch_vertical_margin = 10
ts.show_scale = False
ts.scale = 50
ts.title.add_face(TextFace(" ", fsize=20), column=0)
ete3_desc = read_ete3_from_file(filename)
tree = Tree(ete3_desc, format=1)
# tree.show(tree_style=ts)
return tree.render("%%inline",tree_style=ts)
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 plot_marker_tree(tree, marker, resize_nodes=False, save=True):
supplementary_data = pd.read_csv('../Suppl.Table2.CODEX_paper_MRLdatasetexpression.csv')
supplementary_data.rename(columns={'X.X': 'X', 'Y.Y': 'Y', 'Z.Z': 'Z'}, inplace=True)
supplementary_data['CD45_int'] = supplementary_data['CD45'].astype(int)
ids_to_names = pd.read_csv('ClusterIDtoName.txt', sep='\t')
cell_lines = list(ids_to_names['ID'].values)
ids_to_names = dict(zip(ids_to_names['ID'].values, ids_to_names['Name'].values))
# remove dirt from supplementary data
supplementary_annotations = pd.read_excel('../Suppl.Table2.cluster annotations and cell counts.xlsx')
dirt = supplementary_annotations.loc[supplementary_annotations['Imaging phenotype (cell type)'] == 'dirt',
'X-shift cluster ID']
supplementary_data = supplementary_data[~supplementary_data['Imaging phenotype cluster ID'].isin(dirt)]
supplementary_data['sample'] = supplementary_data['sample_Xtile_Ytile'].apply(lambda x: x.split('_')[0])
suppl_converted = convert_coordinates(supplementary_data)[['X', 'Y', 'Z', 'sample', marker]]
new_tree = TreeNode(name = tree.name)
new_tree.img_style['size'] = 1 if resize_nodes else 10
new_tree.img_style['fgcolor'] = hls2hex(0, 0, 0)
new_tree.img_style['shape'] = 'sphere'
marker_avgs = []
old_layer = [tree]
new_layer = [new_tree]
layer_num = 0
while old_layer:
next_old_layer, next_new_layer = [], []
for ind, node in enumerate(old_layer):
for child in node.children:
next_old_layer.append(child)
new_child = TreeNode(name = child.name)
marker_avg = get_node_markers(child, marker, suppl_converted)
new_child.add_features(marker_avg=marker_avg)
marker_avgs.append(marker_avg)
new_layer[ind].add_child(new_child)
next_new_layer.append(new_child)
old_layer = next_old_layer
new_layer = next_new_layer
layer_num += 1
marker_min, marker_max = np.min(marker_avgs), np.max(marker_avgs)
for node in new_tree.iter_descendants():
norm_marker = (node.marker_avg - marker_min) / (marker_max - marker_min)
node.add_features(marker_avg=norm_marker)
node.add_features(color=hls2hex(0, norm_marker, norm_marker*0.5))
for node in new_tree.iter_descendants():
node.img_style['size'] = 1 + 10 * node.marker_avg if resize_nodes else 10
node.img_style['fgcolor'] = node.color
node.img_style['shape'] = 'sphere'
ts = TreeStyle()
ts.show_leaf_name = False
ts.rotation = 90
ts.title.add_face(TextFace(marker, fsize=20), column=0)
save_dir = 'Marker_Trees' if resize_nodes else 'Marker_Trees_Same_Size'
if save:
new_tree.render(save_dir + '/marker_tree_{}.png'.format(marker), tree_style=ts)
else:
return new_tree.render('%%inline', tree_style=ts)
def render_tree(species_tree, bipart1, num_alt, png_fn, replace_taxon=None):
color1 = "blue"
color2 = "black"
ts = TreeStyle()
ts.show_leaf_name = False
ts.show_scale = False
nstyle = NodeStyle()
nstyle["size"] = 0
ts.title.add_face(
TextFace("{} bipartition in {} gene trees".format(png_fn, num_alt),
fsize=15,
bold=True), 0)
plot_tree = species_tree
for node in plot_tree.traverse():
node.set_style(nstyle)
if node.name in bipart1:
name_face = TextFace(node.name, fgcolor=color1)
else:
name_face = TextFace(node.name, fgcolor=color2)
node.add_face(name_face, 0, 'branch-right')
if replace_taxon:
for leaf in plot_tree.get_leaves:
try:
leaf.name = taxon_subst[leaf.name]
except KeyError:
continue
plot_tree.convert_to_ultrametric()
plot_tree.render(png_fn, tree_style=ts, w=600)
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 draw_tree(self, iters=10):
"""This method generates an interactive phylogenetic tree from a
super alignement file. It calculates a newick tree with RAxML and then
visualizes it using ETEtoolkit.
Parameters
-------
iters : int, optional
Number of repetitions for bootstrap. The default is 10.
"""
bootstrap_tree = Clusterizer.tree_generator(self.super_alignement,
bootstrap=iters)
t = Tree('../data/phylogeny/%s' % bootstrap_tree)
ts = TreeStyle()
ts.show_leaf_name = True
nstyle = NodeStyle()
nstyle["shape"] = "sphere"
nstyle["size"] = 10
nstyle["fgcolor"] = "darkred"
nstyle["hz_line_type"] = 1
nstyle["hz_line_color"] = "#cccccc"
for n in t.traverse():
n.set_style(nstyle)
t.show(tree_style=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 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()
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 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 tree_style_with_data(self, data={}, order=None, force_topology=False):
"""
newick: text or file
render_in: default %%inline for notebooks
data: {leaf -> col -> value}
"""
ts = TreeStyle()
if data:
if not order:
# order = list(data.keys())
first = data.keys()
first = list(first)[0]
order = data[first].keys()
ts.show_leaf_name = True
ts.draw_guiding_lines = True
ts.force_topology = force_topology
for i, x in enumerate(order):
tf = TextFace(x)
tf.margin_left = 5
ts.aligned_header.add_face(tf, column=i)
if data:
for leaf in self.tree.get_leaves():
for i, col in enumerate(order):
tf = TextFace(data[leaf.name][col])
tf.margin_left = 5
leaf.add_face(tf, column=i, position="aligned")
return 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 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 tree_render_minimum(tree):
'''Set the minimum settings on a ete3 tree for rendering a GCtree.'''
ts = TreeStyle()
ts.show_leaf_name = False
ts.rotation = 90
tree.ladderize()
return tree, ts
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 to_diagram(self):
t = self.program.to_tree_node()
ts = TreeStyle()
ts.show_leaf_name = False
ts.show_scale = False
ts.rotation = 90
t.render(f"./diagrams/{FUNCTION_NAME}_{self.fitness}.png",
tree_style=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 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()
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 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():
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 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_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 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 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_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 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 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')
node.img_style["bgcolor"] = "LightCyan"
if "improve" in node.features:
color = "orange" if float(node.improve) < 0 else "green"
if float(node.improve) == 0:
color = "blue"
support_face = faces.CircleFace(200, color)
faces.add_face_to_node(support_face, node, 0, position="float-behind")
try:
from ete3 import TreeStyle, NodeStyle, faces
from ete3.treeview import random_color
NPR_TREE_STYLE = TreeStyle()
NPR_TREE_STYLE.layout_fn = npr_layout
NPR_TREE_STYLE.show_leaf_name = False
except ImportError:
TreeStyle, NodeStyle, faces, random_color = [None]*4
NPR_TREE_STYLE = None
# CONVERT shell colors to the same curses palette
COLORS = {
"wr": '\033[1;37;41m', # white on red
"wo": '\033[1;37;43m', # white on orange
"wm": '\033[1;37;45m', # white on magenta
"wb": '\033[1;37;46m', # white on blue
"bw": '\033[1;37;40m', # black on white
"lblue": '\033[1;34m', # light blue
"lred": '\033[1;31m', # light red
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")
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 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
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(
RectFace(triangle=True, width=size[mode], height=size[mode], bgcolor="#939393", fgcolor="#FFFFFF"), column=0
def format( tree , genedict , detection , includenames , filename , speciescolors = None):
print 'final output...'
red = Color('red')
blue = Color('blue')
colorvec = list(red.range_to(blue, len(genedict.keys())))
colormap = {}
columnmap = {}
for i,ref in enumerate(genedict):
if ref not in detection:
columnmap[ref] = 3
if 'hybrid' in ref.lower():
columnmap[ref] = 0
if 'eff' in ref.lower():
columnmap[ref] = 1
if 'hap' in ref.lower():
columnmap[ref] = 2
colormap[ref] = colorvec[i].hex
for i,ref in enumerate(detection):
columnmap[ref] = 3 + i
colormap[ref] = colorvec[i].hex
print columnmap
print colormap
circledict = {}
for n in t.traverse():
nst = NodeStyle()
nst["size"] = 0
nst["fgcolor"] = 'black'
nst["hz_line_width"] = 4
nst["vt_line_width"]= 4
nst.show_name = False
if n.is_leaf():
if speciescolors != None and n.name in speciescolors:
nst["bgcolor"] = colors[n.name]
nst.show_name = True
n.add_face( AttrFace(attr = 'name', ftype='Helvetica', fgcolor='black', fsize =18 ,fstyle = 'normal' ), column =0 )
refs = json.loads(n.refs)
for ref in genedict:
if ref in refs and ref in detection:
n.add_face( CircleFace ( 10 , colormap[ref]), column = 2 + columnmap[ref] )
n.img_style = nst
if ref in refs and ref not in detection:
n.add_face( RectFace ( 20 , 20 , colormap[ref], colormap[ref] ), column = 2 + columnmap[ref] )
n.img_style = nst
if ref not in refs and ref not in detection:
n.add_face( RectFace ( 20 , 20 , colormap[ref], 'white' ), column = 2 + columnmap[ref] )
n.img_style = nst
###color by species
if n.name in speciescolors:
nst['bgcolor'] = speciescolors[n.name]
else:
if n.name.strip() in includenames:
n.add_face( AttrFace(attr = 'name', ftype='Helvetica', fgcolor='black', fsize =20 ,fstyle = 'normal' ), column =0 )
nst.size = 2
n.img_style = nst
else:
nst.size = 0
n.img_style = nst
ts = TreeStyle()
for i,ref in enumerate(colormap.keys()):
if 'ubi' not in ref:
ts.title.add_face(TextFace(ref, fsize=12), column=0)
ts.title.add_face( RectFace(10 , 10 , colormap[ref] , colormap[ref]), column = 1)
ts.show_leaf_name=False
"""ts.mode = "c"
ts.arc_start = 270
ts.arc_span = 359
ts.root_opening_factor = 1
"""
ts.scale = 190
t.show(tree_style = ts)
t.render(filename + ".png", tree_style = ts)
t.render( filename +".svg" , 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)
import random
from ete3 import Tree, TreeStyle, NodeStyle, faces, AttrFace, TreeFace
# Tree Style used to render small trees used as leaf faces
small_ts = TreeStyle()
small_ts.show_leaf_name = True
small_ts.scale = 10
def layout(node):
if node.is_leaf():
# Add node name to laef nodes
N = AttrFace("name", fsize=14, fgcolor="black")
faces.add_face_to_node(N, node, 0)
t = Tree()
t.populate(10)
T = TreeFace(t, small_ts)
# Let's make the sphere transparent
T.opacity = 0.8
# And place as a float face over the tree
faces.add_face_to_node(T, node, 1, position="aligned")
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))
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
faces.add_face_to_node(pie,mynode, 0, position="branch-right")
concord_text = faces.TextFace(str(int(concord_dict[mynode.name]))+' ',fsize=20)
conflict_text = faces.TextFace(str(int(conflict_dict[mynode.name]))+' ',fsize=20)
faces.add_face_to_node(concord_text,mynode,0,position = "branch-top")
faces.add_face_to_node(conflict_text,mynode,0,position="branch-bottom")
else:
F = faces.TextFace(mynode.name,fsize=20)
faces.add_face_to_node(F,mynode,0,position="aligned")
#Plot Pie Chart
ts = TreeStyle()
ts.show_leaf_name = False
ts.layout_fn = phyparts_pie_layout
nstyle = NodeStyle()
nstyle["size"] = 0
for n in plot_tree.traverse():
n.set_style(nstyle)
n.img_style["vt_line_width"] = 0
ts.draw_guiding_lines = True
ts.guiding_lines_color = "black"
ts.guiding_lines_type = 0
ts.scale = 30
ts.branch_vertical_margin = 10
plot_tree.convert_to_ultrametric()
plot_tree.ladderize(direction=1)
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)
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():
n.set_style(nstyle)
