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
else:
noisy_tree.write(format=1, features=["ND","T","C"],outfile="%s/annotated_tree_est.nhx"%(self.reptree),format_root_node=True)
self.tree_fn_est = self.reptree + "/noisy_root_tree.nhx"
self.treeconv_fn_est = self.reptree + "/noisy_root_tree_conv.nhx"
self.annotated_tree_fn_est = "%s/annotated_tree_est.nhx" %(self.reptree)
return
# Basic tree style
tree_style = TreeStyle()
tree_style.show_leaf_name = True
tree_style.show_branch_length = True
tree_style.min_leaf_separation = 4
tree_style.branch_vertical_margin = 2
nstyle_T = NodeStyle()
nstyle_T["fgcolor"] = "orange"
#nstyle_T["shape"] = "square"
nstyle_T["size"] = 5
nstyle_T["vt_line_color"] = "orange"
nstyle_T["hz_line_color"] = "orange"
nstyle_T["vt_line_width"] = 2
nstyle_T["hz_line_width"] = 2
nstyle_C = NodeStyle()
nstyle_C["fgcolor"] = "orange"
nstyle_C["size"] = 5
nstyle_C["vt_line_color"] = "orange"
position="branch-top")
#AciJub+PumCon
(t & "Anc1").add_features(label="5 ")
(t & "Anc1").add_face(TextFace((t & "Anc1").label, ftype='Arial'),
column=0,
position="branch-top")
#PriBen+PriViv
(t & "Anc2").add_features(label="15 ")
(t & "Anc2").add_face(TextFace((t & "Anc2").label, ftype='Arial'),
column=0,
position="branch-top")
for node in t.traverse():
node.img_style['size'] = 0
if node.is_leaf():
name_face = TextFace(' ' + node.name,
ftype='Arial',
fstyle='italic',
fsize=10)
node.add_face(name_face, column=0, position="branch-right")
#t.get_ascii(attributes=["name", "label"])
ts = TreeStyle()
ts.scale = 12000 # 12000 pixels per branch length unit
#t.show(tree_style=ts)
ts.show_leaf_name = False
ts.branch_vertical_margin = 10
#ts.show_branch_support = True
#t.get_ascii(attributes=["name", "label"])
t.render('tree.pdf', tree_style=ts)
def plot_tree(tree_newick, tree_title):
tree = Tree(tree_newick, format=1)
# set tree parameters
ts = TreeStyle()
ts.mode = "r" # tree model: 'r' for rectangular, 'c' for circular
ts.show_leaf_name = 0
# set tree title text parameters
ts.title.add_face(TextFace(tree_title,
fsize=8,
fgcolor='black',
ftype='Arial',
tight_text=False),
column=0) # tree title text setting
# set layout parameters
ts.rotation = 0 # from 0 to 360
ts.show_scale = False
ts.margin_top = 10 # top tree image margin
ts.margin_bottom = 10 # bottom tree image margin
ts.margin_left = 10 # left tree image margin
ts.margin_right = 10 # right tree image margin
ts.show_border = False # set tree image border
ts.branch_vertical_margin = 3 # 3 pixels between adjancent branches
# set tree node style
for each_node in tree.traverse():
# leaf node parameters
if each_node.is_leaf():
ns = NodeStyle()
ns["shape"] = "circle" # dot shape: circle, square or sphere
ns["size"] = 0 # dot size
ns['hz_line_width'] = 0.5 # branch line width
ns['vt_line_width'] = 0.5 # branch line width
ns['hz_line_type'] = 0 # branch line type: 0 for solid, 1 for dashed, 2 for dotted
ns['vt_line_type'] = 0 # branch line type
ns["fgcolor"] = "blue" # the dot setting
each_node.add_face(TextFace(each_node.name,
fsize=5,
fgcolor='black',
tight_text=False,
bold=False),
column=0,
position='branch-right'
) # leaf node the node name text setting
each_node.set_style(ns)
# non-leaf node parameters
else:
nlns = NodeStyle()
nlns["size"] = 0 # dot size
#nlns["rotation"] = 45
each_node.add_face(
TextFace(each_node.name[:12],
fsize=4,
fgcolor='black',
tight_text=False,
bold=False),
column=5,
position='branch-top') # non-leaf node name text setting)
each_node.set_style(nlns)
tree.render('/Users/songweizhi/Desktop/Tree_' + tree_title + '.png',
w=900,
units="px",
tree_style=ts) # set figures size
def plotting_tree(species, latin_names, original_tree, correction_table,
consensus_strategy_for_multi_outgroups, ortholog_db,
peak_stats, nextflow_flag):
"""
Generate a PDF figure of the input tree with branch lengths equal to Ks distances.
If it is not possible to compute the branch length for a branch, the branch line is dashed. This happens when some\\
ortholog data to compute the branch-specific Ks contribution are missing.
: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 original_tree: Newick tree format of the phylogenetic tree among the involved species
:param correction_table: adjustment results in DataFrame format (contains both possible types of consensus strategy for how to deal with multiple outgroups)
:param consensus_strategy_for_multi_outgroups: user choice about which consensus strategy to use when dealing with multiple outgroups
:para ortholog_db: ortholog peak database used to get ortholog data for the relative rate test; if not available, will be ignored
:param peak_stats: flag to specify whether the ortholog distribution peak is the mode or the median
:param nextflow_flag: boolean flag to state whether the script is run in the Nextflow pipeline or not
"""
# Get an equivalent tree where the focal species is the top leaf
tree = reorder_tree_leaves(original_tree, species)
node_and_branch_style(tree)
species_node = get_species_node(species, tree)
labeling_internal_nodes(species_node)
species_history = get_species_history(species_node)
rate_species_dict, rate_sister_dict = {}, {}
for ancestor_node in species_history[:-2]:
# NOTE: at the moment the following function is only used to fill in the dictionaries of branch-specific Ks contributions
average_peak_of_divergence_event, margin_error_box, error_text = get_branch_length_and_errorbox(
species, ancestor_node, correction_table,
consensus_strategy_for_multi_outgroups, latin_names,
rate_species_dict, rate_sister_dict)
# Adding the branch length to the focal species node, otherwise it lacks it
if ancestor_node.name == species:
ancestor_node.dist = rate_species_dict[species]
draw_branch_length_label(ancestor_node, known_distance=True)
# Adding as TextFaces both the divergent Ks of the node (as mean) and the error range (left-most and right-most boundaries)
divergence_node = ancestor_node.up # getting parent node, where the current divergence takes place
divergence_node.add_feature("rate_species", rate_species_dict[species])
divergence_node.add_feature("avg_peak",
round(average_peak_of_divergence_event, 2))
divergence_node.add_feature("margins",
f"({error_text[0]}, {error_text[1]})")
### divergence_node.add_face(AttrFace("margins", fsize=5), column=0, position="branch-right") [ NOT USED FOR NOW ]
# Setting the branch length of the nodes belonging to the speciation history of the focal species
for divergence_node in species_history[1:]:
parent_node = divergence_node.up
try:
divergence_node.dist = round(
parent_node.rate_species - divergence_node.rate_species, 3)
draw_branch_length_label(divergence_node, known_distance=True)
except Exception:
divergence_node.dist = 10 # impossible number to flag an unknown length
draw_branch_length_label(divergence_node, known_distance=False)
unknown_branch_len_style(divergence_node)
if ortholog_db.empty: # branch-specific Ks contributions can be obtained only from adjustment_tables
logging.info(
"Getting branch-specific Ks contributions from rate-adjustment table data"
)
else: # if the ortholog DB is available, we can try to compute the branch-specific Ks contributions from there too
logging.info(
"Getting branch-specific Ks contributions from rate-adjustment table data"
)
logging.info(
"Computing branch-specific Ks contributions from ortholog peak data in database by applying principles of the relative rate test"
)
rate_dict = {}
get_rates_from_current_analysis(rate_dict, correction_table, species,
species_history, latin_names)
# Setting the branch length of the other remaining nodes
missing_ortholog_data_from_database = False
missing_ortholog_data_from_correction_table = False
for node in species_history[:-1]:
sister_node = node.get_sisters(
) # is a list containing the sister NODE (it's only ONE node)
if not ortholog_db.empty: # if there is an ortholog database that can help with computing the missing branch lengths
if len(sister_node[0].get_leaves()) > 1:
missing_ortholog_data_from_database = get_rates_from_ortholog_peak_db(
rate_dict, sister_node, latin_names, ortholog_db,
peak_stats, missing_ortholog_data_from_database)
else:
if sister_node[0].name in rate_sister_dict.keys(
): # if leaf has known length
sister_node[0].dist = rate_sister_dict[sister_node[0].name]
draw_branch_length_label(sister_node[0],
known_distance=True)
else: # if the leaf has unknown length
sister_node[
0].dist = 10 # impossible number to flag an unknown length
draw_branch_length_label(sister_node[0],
known_distance=False)
unknown_branch_len_style(sister_node[0])
else: # if ortholog database not available (the variable was previously set as an empty dataframe)
if len(sister_node[0].get_leaves()) > 1:
missing_ortholog_data_from_correction_table = True # correction_tables is not enough to know all branch lengths!
sister_node[
0].dist = 10 # impossible number to flag an unknown length
draw_branch_length_label(sister_node[0], known_distance=False)
unknown_branch_len_style(sister_node[0])
for node in sister_node[0].get_descendants():
node.dist = 10 # impossible number to flag an unknown length
draw_branch_length_label(node, known_distance=False)
unknown_branch_len_style(node)
else:
leaf = sister_node[0].get_leaves()[0] # there is only one leaf
if leaf.name in rate_sister_dict.keys():
leaf.dist = rate_sister_dict[leaf.name]
draw_branch_length_label(leaf, known_distance=True)
else: # if the leaf has unknown length
leaf.dist = 10 # impossible number to flag an unknown length
draw_branch_length_label(leaf, known_distance=False)
unknown_branch_len_style(leaf)
# If the ortholog peak database is lacking some required data (must have been deleted by the user) or
# if the peak database has been deleted and only the correction_table has been used for the branch contributions, gives a warning
if missing_ortholog_data_from_database or missing_ortholog_data_from_correction_table:
logging.warning("")
logging.warning(
"One or more branch lengths are unknown (dashed line) due to missing ortholog distribution peak data"
)
# If in Nextflow mode, tell the user to wait until the pipeline is finished in order to have all branch lengths
if nextflow_flag:
if missing_ortholog_data_from_database:
logging.info(
f"As soon as new ortholog data will become available, the tree branch lengths will be updated"
)
# If manual mode, tell the user how to get a complete branch tree (probably they deleted some data in the peak database)
else:
if missing_ortholog_data_from_database or missing_ortholog_data_from_correction_table:
logging.warning(
f"It's necessary to run a new Nextflow (or manual) pipeline to complete the tree branch length information"
)
label_leaves_with_latin_names(tree, latin_names)
adapt_unknown_branch_length(tree)
ts = TreeStyle()
# ts.title.add_face(TextFace(" Input tree with branch length equal to Ks distances ", 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.scale = 200
#ts.scale_length = # to set a fixed scale branch length
root_of_corrected_tree = species_history[-1]
root_of_corrected_tree.render(os.path.join(
"rate_adjustment", f"{species}",
f"{_TREE_BRANCH_DISTANCES.format(species)}"),
w=4.5,
units="in",
tree_style=ts)
def draw_lifting_tree_inline(filename: str) -> None:
ts = TreeStyle()
ts.show_leaf_name = False
ts.layout_fn = layout_lift
ts.rotation = 90
ts.branch_vertical_margin = 10
ts.show_scale = False
ts.scale = 50
ts.title.add_face(TextFace(" ", fsize=20), column=0)
ts.legend.add_face(TextFace(" "), column=0)
ts.legend.add_face(TextFace(" "), column=1)
ts.legend.add_face(TextFace(" "), column=2)
ts.legend.add_face(TextFace(" "), column=3)
ts.legend.add_face(TextFace(" "), column=0)
ts.legend.add_face(TextFace("Node shape and size:"), column=1)
ts.legend.add_face(TextFace(" "), column=2)
ts.legend.add_face(TextFace("Node color - membership value:"), column=3)
ts.legend.add_face(TextFace(" "), column=0)
ts.legend.add_face(TextFace(" "), column=1)
ts.legend.add_face(TextFace(" "), column=2)
ts.legend.add_face(TextFace(" "), column=3)
ts.legend.add_face(PieChartFace([100], 20, 20, colors=['white'], line_color='black'), column=0)
ts.legend.add_face(TextFace(" topics that relate to the cluster"), column=1)
ts.legend.add_face(RectFace(30, 10, "#90ee90", "#90ee90"), column=2)
ts.legend.add_face(TextFace(" topic with minor membership 0<u(t)<=0.2"), column=3)
ts.legend.add_face(TextFace(" "), column=0)
ts.legend.add_face(TextFace(" "), column=1)
ts.legend.add_face(TextFace(" "), column=2)
ts.legend.add_face(TextFace(" "), column=3)
ts.legend.add_face(PieChartFace([100], 40, 40, colors=['white'], line_color='black'), column=0)
ts.legend.add_face(TextFace(" head subject"), column=1)
ts.legend.add_face(RectFace(30, 10, "green", "green"), column=2)
ts.legend.add_face(TextFace(u" topic with medium membership 0.2<u(t)<=0.4 "), column=3)
ts.legend.add_face(TextFace(" "), column=0)
ts.legend.add_face(TextFace(" "), column=1)
ts.legend.add_face(TextFace(" "), column=2)
ts.legend.add_face(TextFace(" "), column=3)
ts.legend.add_face(RectFace(20, 20, "black", "white"), column=0)
ts.legend.add_face(TextFace(" topics that don't refer to cluster "), \
column=1)
ts.legend.add_face(RectFace(30, 10, "#004000", "#004000"), column=2)
ts.legend.add_face(TextFace(" topic with high membership u(t)>0.4"), column=3)
ts.legend.add_face(TextFace(" "), column=0)
ts.legend.add_face(TextFace(" "), column=1)
ts.legend.add_face(TextFace(" "), column=2)
ts.legend.add_face(TextFace(" "), column=3)
ts.legend.add_face(TextFace(" "), column=1)
ts.legend.add_face(TextFace(" "), column=1)
ts.legend.add_face(RectFace(30, 10, "red", "red"), column=2)
ts.legend.add_face(TextFace(" topic with no membership (u(t)=0)"), column=3)
ts.legend_position = 3
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 plot_species_tree(tree_newick, tree_type, gene_name, tree_file_name,
name_list, tree_image_folder):
# set tree parameters
tree = Tree(tree_newick, format=2)
ts = TreeStyle()
ts.mode = "r" # tree model: 'r' for rectangular, 'c' for circular
ts.show_leaf_name = False
tree_title = tree_type + ' (' + gene_name + ')' # define tree title
# set tree title text parameters
ts.title.add_face(TextFace(tree_title,
fsize=8,
fgcolor='black',
ftype='Arial',
tight_text=False),
column=0) # tree title text setting
# set layout parameters
ts.rotation = 0 # from 0 to 360
ts.show_scale = False
ts.margin_top = 10 # top tree image margin
ts.margin_bottom = 10 # bottom tree image margin
ts.margin_left = 10 # left tree image margin
ts.margin_right = 10 # right tree image margin
ts.show_border = False # set tree image border
ts.branch_vertical_margin = 3 # 3 pixels between adjancent branches
# set tree node style
for each_node in tree.traverse():
# leaf node parameters
if each_node.is_leaf():
ns = NodeStyle()
ns['shape'] = 'circle' # dot shape: circle, square or sphere
ns['size'] = 0 # dot size
ns['hz_line_width'] = 0.5 # branch line width
ns['vt_line_width'] = 0.5 # branch line width
ns['hz_line_type'] = 0 # branch line type: 0 for solid, 1 for dashed, 2 for dotted
ns['vt_line_type'] = 0 # branch line type
if each_node.name in name_list:
ns['fgcolor'] = 'red' # the dot setting
each_node.add_face(
TextFace(each_node.name,
fsize=8,
fgcolor='red',
tight_text=False,
bold=False),
column=0,
position='branch-right') # the node name text setting
each_node.set_style(ns)
else:
ns['fgcolor'] = 'blue' # the dot setting
each_node.add_face(
TextFace(each_node.name,
fsize=8,
fgcolor='black',
tight_text=False,
bold=False),
column=0,
position='branch-right') # the node name text setting
each_node.set_style(ns)
# non-leaf node parameters
else:
nlns = NodeStyle()
nlns['size'] = 0 # dot size
each_node.add_face(
TextFace(each_node.name,
fsize=4,
fgcolor='black',
tight_text=False,
bold=False),
column=5,
position='branch-top') # non-leaf node name text setting)
each_node.set_style(nlns)
# set figures size
tree.render('%s/%s.png' % (tree_image_folder, tree_file_name),
w=900,
units='px',
tree_style=ts)
def create_tree(tree, tree_root_key, filepath, patient, phylogeny, drivers=None):
"""
Takes a networkx tree and creates an ete3 tree and creates a PDF, SVG or PNG according to the given filename at
the given path
:param tree: inferred cancer phylogeny encoded as networkx tree
:param tree_root_key: key of root in networkx tree
:param filepath: path to output file (excluding file extension)
:param patient: data structure around patient
:param phylogeny: inferred cancer phylogeny
:param drivers: defaultdict with mutation IDs and instance of driver class to be highlighted on edges
:return path to the generated ete3 PNG file
"""
# generate ete3 tree
rt = Tree() # generate root
rt.name = 'Germline {}'.format(patient.name)
_generate_ete_tree(tree, tree_root_key, rt, 0, patient, phylogeny,
gene_names=patient.gene_names, drivers=drivers)
ts = TreeStyle()
ts.layout_fn = ete_layout
ts.show_leaf_name = False
ts.show_branch_length = False
ts.show_branch_support = False
ts.show_scale = False
ts.extra_branch_line_color = 'Black'
# ts.complete_branch_lines_when_necessary = False
# Find the maximal number of variants present in a single sample to determine the optimal ETE3 scale level
max_muts = max(no_pres_vars for no_pres_vars in patient.no_present_vars.values())
def round_to_1(x):
"""
Round to one significant digit
:param x:
:return:
"""
return round(x, -int(math.floor(math.log10(abs(x)))))
# XX pixels per branch length unit
# if max_muts > 20000:
# ts.scale = 0.02
# elif max_muts > 10000:
# ts.scale = 0.05
# elif max_muts > 5000:
# ts.scale = 0.1
# elif max_muts > 2000:
# ts.scale = 0.2
# elif max_muts > 1000:
# ts.scale = 0.5
# elif max_muts > 500:
# ts.scale = 1
# elif max_muts > 200:
# ts.scale = 2
# elif max_muts > 100:
# ts.scale = 5
# elif max_muts > 50:
# ts.scale = 5
# else:
# ts.scale = 10
ts.scale = round_to_1(600 / max_muts)
ts.branch_vertical_margin = 15 # XX pixels between adjacent branches
# rt.show(tree_style=ts)
ete_tree_plot = filepath+'.png'
rt.render(ete_tree_plot, w=183, units="mm", tree_style=ts, dpi=300)
rt.render(filepath+'.pdf', w=183, units="mm", tree_style=ts, dpi=300)
return ete_tree_plot
def deepbiome_draw_phylogenetic_tree(
log,
network_info,
path_info,
num_classes,
file_name="%%inline",
img_w=500,
branch_vertical_margin=20,
arc_start=0,
arc_span=360,
node_name_on=True,
name_fsize=10,
tree_weight_on=True,
tree_weight=None,
tree_level_list=['Genus', 'Family', 'Order', 'Class', 'Phylum'],
weight_opacity=0.4,
weight_max_radios=10,
phylum_background_color_on=True,
phylum_color=[],
phylum_color_legend=False,
show_covariates=True,
verbose=True):
"""
Draw phylogenetic tree
Parameters
----------
log (logging instance) :
python logging instance for logging
network_info (dictionary) :
python dictionary with network_information
path_info (dictionary):
python dictionary with path_information
num_classes (int):
number of classes for the network. 0 for regression, 1 for binary classificatin.
file_name (str):
name of the figure for save.
- "*.png", "*.jpg"
- "%%inline" for notebook inline output.
default="%%inline"
img_w (int):
image width (pt)
default=500
branch_vertical_margin (int):
vertical margin for branch
default=20
arc_start (int):
angle that arc start
default=0
arc_span (int):
total amount of angle for the arc span
default=360
node_name_on (boolean):
show the name of the last leaf node if True
default=False
name_fsize (int):
font size for the name of the last leaf node
default=10
tree_weight_on (boolean):
show the amount and the direction of the weight for each edge in the tree by circle size and color.
default=True
tree_weight (ndarray):
reference tree weights
default=None
tree_level_list (list):
name of each level of the given reference tree weights
default=['Genus', 'Family', 'Order', 'Class', 'Phylum']
weight_opacity (float):
opacity for weight circle
default= 0.4
weight_max_radios (int):
maximum radios for weight circle
default= 10
phylum_background_color_on (boolean):
show the background color for each phylum based on `phylumn_color`.
default= True
phylum_color (list):
specify the list of background colors for phylum level. If `phylumn_color` is empty, it will arbitrarily assign the color for each phylum.
default= []
phylum_color_legend (boolean):
show the legend for the background colors for phylum level
default= False
show_covariates (boolean):
show the effect of the covariates
default= True
verbose (boolean):
show the log if True
default=True
Returns
-------
Examples
--------
Draw phylogenetic tree
deepbiome_draw_phylogenetic_tree(log, network_info, path_info, num_classes, file_name = "%%inline")
"""
os.environ[
'QT_QPA_PLATFORM'] = 'offscreen' # for tree figure (https://github.com/etetoolkit/ete/issues/381)
reader_class = getattr(readers,
network_info['model_info']['reader_class'].strip())
reader = reader_class(log, path_info, verbose=verbose)
data_path = path_info['data_info']['data_path']
try:
count_path = path_info['data_info']['count_path']
x_list = np.array(
pd.read_csv(path_info['data_info']['count_list_path'],
header=None).iloc[:, 0])
x_path = np.array([
'%s/%s' % (count_path, x_list[fold])
for fold in range(x_list.shape[0]) if '.csv' in x_list[fold]
])
except:
x_path = np.array([
'%s/%s' % (data_path, path_info['data_info']['x_path'])
for fold in range(1)
])
reader.read_dataset(x_path[0], None, 0)
network_class = getattr(
build_network, network_info['model_info']['network_class'].strip())
network = network_class(network_info,
path_info,
log,
fold=0,
num_classes=num_classes,
tree_level_list=tree_level_list,
is_covariates=reader.is_covariates,
covariate_names=reader.covariate_names,
verbose=False)
if len(phylum_color) == 0:
colors = mcolors.CSS4_COLORS
colors_name = list(colors.keys())
if reader.is_covariates and show_covariates:
phylum_color = np.random.choice(
colors_name,
network.phylogenetic_tree_info['Phylum_with_covariates'].
unique().shape[0])
else:
phylum_color = np.random.choice(
colors_name,
network.phylogenetic_tree_info['Phylum'].unique().shape[0])
basic_st = NodeStyle()
basic_st['size'] = weight_max_radios * 0.5
basic_st['shape'] = 'circle'
basic_st['fgcolor'] = 'black'
t = Tree()
root_st = NodeStyle()
root_st["size"] = 0
t.set_style(root_st)
tree_node_dict = {}
tree_node_dict['root'] = t
upper_class = 'root'
lower_class = tree_level_list[-1]
lower_layer_names = tree_weight[-1].columns.to_list()
layer_tree_node_dict = {}
phylum_color_dict = {}
for j, val in enumerate(lower_layer_names):
t.add_child(name=val)
leaf_t = t.get_leaves_by_name(name=val)[0]
leaf_t.set_style(basic_st)
layer_tree_node_dict[val] = leaf_t
if lower_class == 'Phylum' and phylum_background_color_on:
phylum_st = copy.deepcopy(basic_st)
phylum_st["bgcolor"] = phylum_color[j]
phylum_color_dict[val] = phylum_color[j]
leaf_t.set_style(phylum_st)
tree_node_dict[lower_class] = layer_tree_node_dict
upper_class = lower_class
upper_layer_names = lower_layer_names
for i in range(len(tree_level_list) - 1):
lower_class = tree_level_list[-2 - i]
if upper_class == 'Disease' and show_covariates == False:
lower_layer_names = network.phylogenetic_tree_info[
lower_class].unique()
else:
lower_layer_names = tree_weight[-i - 1].index.to_list()
layer_tree_node_dict = {}
for j, val in enumerate(upper_layer_names):
parient_t = tree_node_dict[upper_class][val]
if upper_class == 'Disease':
child_class = lower_layer_names
else:
child_class = network.phylogenetic_tree_info[lower_class][
network.phylogenetic_tree_info[upper_class] ==
val].unique()
for k, child_val in enumerate(child_class):
parient_t.add_child(name=child_val)
leaf_t = parient_t.get_leaves_by_name(name=child_val)[0]
if lower_class == 'Phylum' and phylum_background_color_on:
phylum_st = copy.deepcopy(basic_st)
phylum_st["bgcolor"] = phylum_color[k]
phylum_color_dict[child_val] = phylum_color[k]
leaf_t.set_style(phylum_st)
else:
leaf_t.set_style(basic_st)
if tree_weight_on:
edge_weights = np.array(tree_weight[-1 - i])
edge_weights *= (weight_max_radios / np.max(edge_weights))
if upper_class == 'Disease':
upper_num = 0
else:
upper_num = network.phylogenetic_tree_dict[
upper_class][val]
if upper_class == 'Disease' and reader.is_covariates == True and show_covariates:
lower_num = network.phylogenetic_tree_dict[
'%s_with_covariates' % lower_class][child_val]
else:
lower_num = network.phylogenetic_tree_dict[
lower_class][child_val]
leaf_t.add_features(weight=edge_weights[lower_num,
upper_num])
layer_tree_node_dict[child_val] = leaf_t
tree_node_dict[lower_class] = layer_tree_node_dict
upper_class = lower_class
upper_layer_names = lower_layer_names
def layout(node):
if "weight" in node.features:
# Creates a sphere face whose size is proportional to node's
# feature "weight"
color = {1: "RoyalBlue", 0: "Red"}[int(node.weight > 0)]
C = CircleFace(radius=node.weight, color=color, style="circle")
# Let's make the sphere transparent
C.opacity = weight_opacity
# And place as a float face over the tree
faces.add_face_to_node(C, node, 0, position="float")
if node_name_on & node.is_leaf():
# Add node name to laef nodes
N = AttrFace("name", fsize=name_fsize, fgcolor="black")
faces.add_face_to_node(N, node, 0)
ts = TreeStyle()
ts.show_leaf_name = False
ts.mode = "c"
ts.arc_start = arc_start
ts.arc_span = arc_span
ts.layout_fn = layout
ts.branch_vertical_margin = branch_vertical_margin
ts.show_scale = False
if phylum_color_legend:
for phylum_name in np.sort(list(phylum_color_dict.keys())):
color_name = phylum_color_dict[phylum_name]
ts.legend.add_face(CircleFace(weight_max_radios * 1, color_name),
column=0)
ts.legend.add_face(TextFace(" %s" % phylum_name, fsize=name_fsize),
column=1)
return t.render(file_name=file_name, w=img_w, tree_style=ts)
# #########################################################################################################################
# if __name__ == "__main__":
# argdict = argv_parse(sys.argv)
# try: gpu_memory_fraction = float(argdict['gpu_memory_fraction'][0])
# except: gpu_memory_fraction = None
# try: max_queue_size=int(argdict['max_queue_size'][0])
# except: max_queue_size=10
# try: workers=int(argdict['workers'][0])
# except: workers=1
# try: use_multiprocessing=argdict['use_multiprocessing'][0]=='True'
# except: use_multiprocessing=False
# ### Logger ############################################################################################
# logger = logging_daily.logging_daily(argdict['log_info'][0])
# logger.reset_logging()
# log = logger.get_logging()
# log.setLevel(logging_daily.logging.INFO)
# log.info('Argument input')
# for argname, arg in argdict.items():
# log.info(' {}:{}'.format(argname,arg))
# ### Configuration #####################################################################################
# config_data = configuration.Configurator(argdict['path_info'][0], log)
# config_data.set_config_map(config_data.get_section_map())
# config_data.print_config_map()
# config_network = configuration.Configurator(argdict['network_info'][0], log)
# config_network.set_config_map(config_network.get_section_map())
# config_network.print_config_map()
# path_info = config_data.get_config_map()
# network_info = config_network.get_config_map()
# test_evaluation, train_evaluation, network = deepbiome_train(log, network_info, path_info, number_of_fold=20)
def show_dom_MSA_tree(self):
'''
Plot the gene tree with a MSA+domains aligned next to it,
or alternatively dump the tree to a file (if self.out was defined)
'''
if not self.tree_path:
# if no tree was specified, use a "star-shaped" newick tree
# as a substitute (all species have the same relatedness)
newick_star = '({});'.format(','.join(sorted(
self.get_gene_list())))
t = Tree(newick_star)
ts = TreeStyle()
ts.show_branch_length = False
ts.show_branch_support = False
ts.branch_vertical_margin = 10
ts.scale = 0 # 0 pixels per branch length unit
# make the tree disappear:
nstyle = NodeStyle()
nstyle['size'] = 0
nstyle['hz_line_color'] = 'white'
nstyle['vt_line_color'] = 'white'
for n in t.traverse():
n.set_style(nstyle)
else:
t = Tree(self.tree_path)
ts = TreeStyle()
ts.show_branch_length = True
ts.show_branch_support = True
ts.scale = 120 # 120 pixels per branch length unit
ts.show_leaf_name = True
ts.show_scale = False
if self.outgroup_node_for_rooting:
assert self.tree_path, ('Rooting doesn\'t make sense if '
'you don\'t specify a tree file!')
self.root_tree(t)
if self.msa_path:
self.add_background_color_to_nodes(t)
self.add_msa_with_domains_to_tree(t)
else:
self.add_background_color_to_nodes(t)
self.add_domains_to_tree(t)
if self.hide_nodes:
for word2hide in self.hide_nodes:
nodes_hidden = []
print(
'\nRemoving these terminal nodes because they contain the '
'word "{}":'.format(word2hide))
for leaf in t.traverse():
if word2hide in leaf.name:
nodes_hidden.append(leaf.name)
leaf.delete()
print(', '.join(nodes_hidden))
if self.out:
file_ext = os.path.splitext(self.out.upper())[1]
if file_ext not in ('.SVG', '.PDF', '.PNG'):
raise Exception('Output image file name must end with '
'".SVG", ".PDF" or ".PNG".')
t.render(self.out, tree_style=ts)
print('Wrote output image to', self.out)
else:
t.show(tree_style=ts)
return
def showTree(delimitation,
scale=500,
render=False,
fout="",
form="svg",
show_support=False):
"""delimitation: species_setting class"""
tree = delimitation.root
style0 = NodeStyle()
style0["fgcolor"] = "#000000"
style0["vt_line_color"] = "#0000aa"
style0["hz_line_color"] = "#0000aa"
style0["vt_line_width"] = 2
style0["hz_line_width"] = 2
style0["vt_line_type"] = 0
style0["hz_line_type"] = 0
style0["size"] = 0
#tree.clear_face()
tree._faces = _FaceAreas()
for node in tree.get_descendants():
node.set_style(style0)
node.img_style["size"] = 0
node._faces = _FaceAreas()
#node.clear_face()
tree.set_style(style0)
tree.img_style["size"] = 0
style1 = NodeStyle()
style1["fgcolor"] = "#000000"
style1["vt_line_color"] = "#ff0000"
style1["hz_line_color"] = "#0000aa"
style1["vt_line_width"] = 2
style1["hz_line_width"] = 2
style1["vt_line_type"] = 0
style1["hz_line_type"] = 0
style1["size"] = 0
style2 = NodeStyle()
style2["fgcolor"] = "#0f0f0f"
style2["vt_line_color"] = "#ff0000"
style2["hz_line_color"] = "#ff0000"
style2["vt_line_width"] = 2
style2["hz_line_width"] = 2
style2["vt_line_type"] = 0
style2["hz_line_type"] = 0
style2["size"] = 0
for node in delimitation.active_nodes:
node.set_style(style1)
node.img_style["size"] = 0
for des in node.get_descendants():
des.set_style(style2)
des.img_style["size"] = 0
for node in delimitation.root.traverse(strategy='preorder'):
if show_support and hasattr(node, "bs"):
if node.bs == 0.0:
node.add_face(TextFace("0", fsize=8),
column=0,
position="branch-top")
else:
node.add_face(TextFace("{0:.2f}".format(node.bs), fsize=8),
column=0,
position="branch-top")
ts = TreeStyle()
"""scale pixels per branch length unit"""
ts.scale = scale
ts.branch_vertical_margin = 7
if render:
tree.render(fout + "." + form, tree_style=ts)
else:
tree.show(tree_style=ts)
def showTree(delimitation, scale = 500, render = False, fout = "", form = "svg", show_support = False):
"""delimitation: species_setting class"""
tree = delimitation.root
style0 = NodeStyle()
style0["fgcolor"] = "#000000"
style0["vt_line_color"] = "#0000aa"
style0["hz_line_color"] = "#0000aa"
style0["vt_line_width"] = 2
style0["hz_line_width"] = 2
style0["vt_line_type"] = 0
style0["hz_line_type"] = 0
style0["size"] = 0
#tree.clear_face()
tree._faces = _FaceAreas()
for node in tree.get_descendants():
node.set_style(style0)
node.img_style["size"] = 0
node._faces = _FaceAreas()
#node.clear_face()
tree.set_style(style0)
tree.img_style["size"] = 0
style1 = NodeStyle()
style1["fgcolor"] = "#000000"
style1["vt_line_color"] = "#ff0000"
style1["hz_line_color"] = "#0000aa"
style1["vt_line_width"] = 2
style1["hz_line_width"] = 2
style1["vt_line_type"] = 0
style1["hz_line_type"] = 0
style1["size"] = 0
style2 = NodeStyle()
style2["fgcolor"] = "#0f0f0f"
style2["vt_line_color"] = "#ff0000"
style2["hz_line_color"] = "#ff0000"
style2["vt_line_width"] = 2
style2["hz_line_width"] = 2
style2["vt_line_type"] = 0
style2["hz_line_type"] = 0
style2["size"] = 0
for node in delimitation.active_nodes:
node.set_style(style1)
node.img_style["size"] = 0
for des in node.get_descendants():
des.set_style(style2)
des.img_style["size"] = 0
for node in delimitation.root.traverse(strategy='preorder'):
if show_support and hasattr(node, "bs"):
if node.bs == 0.0:
node.add_face(TextFace("0", fsize = 8), column=0, position = "branch-top")
else:
node.add_face(TextFace("{0:.2f}".format(node.bs), fsize = 8), column=0, position = "branch-top")
ts = TreeStyle()
"""scale pixels per branch length unit"""
ts.scale = scale
ts.branch_vertical_margin = 7
if render:
tree.render(fout+"."+form, tree_style=ts)
else:
tree.show(tree_style=ts)
def run(args):
if args.text_mode:
from ete3 import Tree
for tindex, tfile in enumerate(args.src_tree_iterator):
#print tfile
if args.raxml:
nw = re.sub(":(\d+\.\d+)\[(\d+)\]", ":\\1[&&NHX:support=\\2]", open(tfile).read())
t = Tree(nw)
else:
t = Tree(tfile)
print(t.get_ascii(show_internal=args.show_internal_names,
attributes=args.show_attributes))
return
import random
import re
import colorsys
from collections import defaultdict
from ete3 import (Tree, PhyloTree, TextFace, RectFace, faces, TreeStyle,
add_face_to_node, random_color)
global FACES
if args.face:
FACES = parse_faces(args.face)
else:
FACES = []
# VISUALIZATION
ts = TreeStyle()
ts.mode = args.mode
ts.show_leaf_name = True
ts.tree_width = args.tree_width
for f in FACES:
if f["value"] == "@name":
ts.show_leaf_name = False
break
if args.as_ncbi:
ts.show_leaf_name = False
FACES.extend(parse_faces(
['value:@sci_name, size:10, fstyle:italic',
'value:@taxid, color:grey, size:6, format:" - %s"',
'value:@sci_name, color:steelblue, size:7, pos:b-top, nodetype:internal',
'value:@rank, color:indianred, size:6, pos:b-bottom, nodetype:internal',
]))
if args.alg:
FACES.extend(parse_faces(
['value:@sequence, size:10, pos:aligned, ftype:%s' %args.alg_type]
))
if args.heatmap:
FACES.extend(parse_faces(
['value:@name, size:10, pos:aligned, ftype:heatmap']
))
if args.bubbles:
for bubble in args.bubbles:
FACES.extend(parse_faces(
['value:@%s, pos:float, ftype:bubble, opacity:0.4' %bubble,
]))
ts.branch_vertical_margin = args.branch_separation
if args.show_support:
ts.show_branch_support = True
if args.show_branch_length:
ts.show_branch_length = True
if args.force_topology:
ts.force_topology = True
ts.layout_fn = lambda x: None
for tindex, tfile in enumerate(args.src_tree_iterator):
#print tfile
if args.raxml:
nw = re.sub(":(\d+\.\d+)\[(\d+)\]", ":\\1[&&NHX:support=\\2]", open(tfile).read())
t = PhyloTree(nw)
else:
t = PhyloTree(tfile)
if args.alg:
t.link_to_alignment(args.alg, alg_format=args.alg_format)
if args.heatmap:
DEFAULT_COLOR_SATURATION = 0.3
BASE_LIGHTNESS = 0.7
def gradient_color(value, max_value, saturation=0.5, hue=0.1):
def rgb2hex(rgb):
return '#%02x%02x%02x' % rgb
def hls2hex(h, l, s):
return rgb2hex( tuple([int(x*255) for x in colorsys.hls_to_rgb(h, l, s)]))
lightness = 1 - (value * BASE_LIGHTNESS) / max_value
return hls2hex(hue, lightness, DEFAULT_COLOR_SATURATION)
heatmap_data = {}
max_value, min_value = None, None
for line in open(args.heatmap):
if line.startswith('#COLNAMES'):
pass
elif line.startswith('#') or not line.strip():
pass
else:
fields = line.split('\t')
name = fields[0].strip()
values = [float(x) if x else None for x in fields[1:]]
maxv = max(values)
minv = min(values)
if max_value is None or maxv > max_value:
max_value = maxv
if min_value is None or minv < min_value:
min_value = minv
heatmap_data[name] = values
heatmap_center_value = 0
heatmap_color_center = "white"
heatmap_color_up = 0.3
heatmap_color_down = 0.7
heatmap_color_missing = "black"
heatmap_max_value = abs(heatmap_center_value - max_value)
heatmap_min_value = abs(heatmap_center_value - min_value)
if heatmap_center_value <= min_value:
heatmap_max_value = heatmap_min_value + heatmap_max_value
else:
heatmap_max_value = max(heatmap_min_value, heatmap_max_value)
# scale the tree
if not args.height:
args.height = None
if not args.width:
args.width = None
f2color = {}
f2last_seed = {}
for node in t.traverse():
node.img_style['size'] = 0
if len(node.children) == 1:
node.img_style['size'] = 2
node.img_style['shape'] = "square"
node.img_style['fgcolor'] = "steelblue"
ftype_pos = defaultdict(int)
for findex, f in enumerate(FACES):
if (f['nodetype'] == 'any' or
(f['nodetype'] == 'leaf' and node.is_leaf()) or
(f['nodetype'] == 'internal' and not node.is_leaf())):
# if node passes face filters
if node_matcher(node, f["filters"]):
if f["value"].startswith("@"):
fvalue = getattr(node, f["value"][1:], None)
else:
fvalue = f["value"]
# if node's attribute has content, generate face
if fvalue is not None:
fsize = f["size"]
fbgcolor = f["bgcolor"]
fcolor = f['color']
if fcolor:
# Parse color options
auto_m = re.search("auto\(([^)]*)\)", fcolor)
if auto_m:
target_attr = auto_m.groups()[0].strip()
if not target_attr :
color_keyattr = f["value"]
else:
color_keyattr = target_attr
color_keyattr = color_keyattr.lstrip('@')
color_bin = getattr(node, color_keyattr, None)
last_seed = f2last_seed.setdefault(color_keyattr, random.random())
seed = last_seed + 0.10 + random.uniform(0.1, 0.2)
f2last_seed[color_keyattr] = seed
fcolor = f2color.setdefault(color_bin, random_color(h=seed))
if fbgcolor:
# Parse color options
auto_m = re.search("auto\(([^)]*)\)", fbgcolor)
if auto_m:
target_attr = auto_m.groups()[0].strip()
if not target_attr :
color_keyattr = f["value"]
else:
color_keyattr = target_attr
color_keyattr = color_keyattr.lstrip('@')
color_bin = getattr(node, color_keyattr, None)
last_seed = f2last_seed.setdefault(color_keyattr, random.random())
seed = last_seed + 0.10 + random.uniform(0.1, 0.2)
f2last_seed[color_keyattr] = seed
fbgcolor = f2color.setdefault(color_bin, random_color(h=seed))
if f["ftype"] == "text":
if f.get("format", None):
fvalue = f["format"] % fvalue
F = TextFace(fvalue,
fsize = fsize,
fgcolor = fcolor or "black",
fstyle = f.get('fstyle', None))
elif f["ftype"] == "fullseq":
F = faces.SeqMotifFace(seq=fvalue, seq_format="seq",
seqtail_format="seq",
height=fsize)
elif f["ftype"] == "compactseq":
F = faces.SeqMotifFace(seq=fvalue, seq_format="compactseq",
seqtail_format="compactseq",
height=fsize)
elif f["ftype"] == "blockseq":
F = faces.SeqMotifFace(seq=fvalue, seq_format="blockseq",
seqtail_format="blockseq",
height=fsize,
fgcolor=fcolor or "slategrey",
bgcolor=fbgcolor or "slategrey",
scale_factor = 1.0)
fbgcolor = None
elif f["ftype"] == "bubble":
try:
v = float(fvalue)
except ValueError:
rad = fsize
else:
rad = fsize * v
F = faces.CircleFace(radius=rad, style="sphere",
color=fcolor or "steelblue")
elif f["ftype"] == "heatmap":
if not f['column']:
col = ftype_pos[f["pos"]]
else:
col = f["column"]
for i, value in enumerate(heatmap_data.get(node.name, [])):
ftype_pos[f["pos"]] += 1
if value is None:
color = heatmap_color_missing
elif value > heatmap_center_value:
color = gradient_color(abs(heatmap_center_value - value), heatmap_max_value, hue=heatmap_color_up)
elif value < heatmap_center_value:
color = gradient_color(abs(heatmap_center_value - value), heatmap_max_value, hue=heatmap_color_down)
else:
color = heatmap_color_center
node.add_face(RectFace(20, 20, color, color), position="aligned", column=col + i)
# Add header
# for i, name in enumerate(header):
# nameF = TextFace(name, fsize=7)
# nameF.rotation = -90
# tree_style.aligned_header.add_face(nameF, column=i)
F = None
elif f["ftype"] == "profile":
# internal profiles?
F = None
elif f["ftype"] == "barchart":
F = None
elif f["ftype"] == "piechart":
F = None
# Add the Face
if F:
F.opacity = f['opacity'] or 1.0
# Set face general attributes
if fbgcolor:
F.background.color = fbgcolor
if not f['column']:
col = ftype_pos[f["pos"]]
ftype_pos[f["pos"]] += 1
else:
col = f["column"]
node.add_face(F, column=col, position=f["pos"])
if args.image:
t.render("t%d.%s" %(tindex, args.image),
tree_style=ts, w=args.width, h=args.height, units=args.size_units)
else:
t.show(None, tree_style=ts)
def 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)
current_color %= len(colors)
style = NodeStyle()
style['vt_line_color'] = colors[current_color]
style['hz_line_color'] = colors[current_color]
style['size'] = 0
style['fgcolor'] = '#000000'
style["vt_line_width"] = 2
style["hz_line_width"] = 2
for gg in g.traverse():
if not gg.coloured:
gg.set_style(style)
gg.coloured = True
source_style = NodeStyle(style)
source_style['size'] = 5
source_style['fgcolor'] = '#C01000'
g.set_style(source_style)
tstyle = TreeStyle()
#tstyle.show_leaf_name = False
tstyle.scale = 28
tstyle.branch_vertical_margin = 6
tstyle.show_branch_length = False
# tstyle.show_branch_support = True
tstyle.show_scale = False
if ultrametric == 1:
gene_tree.convert_to_ultrametric()
gene_tree.show(tree_style=tstyle)
# species_tree.show()
circular_style.show_branch_length = True
circular_style.show_branch_support = True
t.render("mytree.png", tree_style=circular_style)
nstyle = NodeStyle()
nstyle["hz_line_width"] = 3
nstyle["vt_line_width"] = 3
# Applies the same static style to all nodes in the tree. Note that,
# if "nstyle" is modified, changes will affect to all nodes
for n in t.traverse():
n.set_style(nstyle)
ts = TreeStyle()
ts.branch_vertical_margin = 10
ts.show_leaf_name = True
ts.rotation = 90
ts.scale=100
t.render("tree_test100.png",tree_style=ts)
ts.scale=1000
t.render("tree_test1000.png",tree_style=ts)
## compare to
#t = Tree( '("[a,b]",c);' )
#t.show()
# []
def get_example_tree():
t = PhyloTree('partition.nxs.treefile')
# delete nodes supported less than 70% in Bootstrap
#for node in t.get_descendants():
#if not node.is_leaf() and node.support <= 90:
#node.delete()
#set size to 0
#list_remove = []
#for node in t.get_descendants():
#if node.dist>0:
#list_remove.append(node.name)
#str_list = [x for x in list_remove if x]
#t.prune(str_list)
#style2 = NodeStyle()
#style2["fgcolor"] = "#000000"
#style2["shape"] = "circle"
#style2["size"]=0
#for l in t.iter_leaves():
#l.img_style = style2
#set the box around the commmon ancestor
#nst1 = NodeStyle()
#nst1["bgcolor"] = "LightSteelBlue"
#nst2 = NodeStyle()
#nst2["bgcolor"] = "SteelBlue"
#nst3 =NodeStyle()
#nst3["bgcolor"] = "PaleTurquoise"
#nst4 = NodeStyle()
#nst4["bgcolor"] = "PowderBlue"
#n1 = t.get_common_ancestor("CMW50197_Raffaelea_kentii_sp._nov.", "CMW49902_Raffaelea_kentii_sp._nov.")
#n1.set_style(nst1)
#n2 = t.get_common_ancestor("Raffaelea_sulphurea", "Raffaelea_quercivora")
#n2.set_style(nst2)
#n3 = t.get_common_ancestor("Raffaelea_cyclorhipidia", "Raffaelea_subalba")
#n3.set_style(nst3)
#n4 = t.get_common_ancestor("Raffaelea_lauricola", "Raffaelea_brunnea")
#n4.set_style(nst4)
# Set the path in which images are located
#img_path = "./"
#Raff_Ai = faces.ImgFace(img_path + "Fig2_CMW49901.png")
# Specify the boundaries of the Image, how big do you want it
# Raff_Ai.width = 200
# Raff_Ai.height = 200
# How much to the left do you want the Image
# Raff_Ai.margin_left = 200
ts = TreeStyle()
ts.show_branch_length = False # show branch length
ts.show_branch_support = True # show support
ts.show_leaf_name = False
ts.branch_vertical_margin = 1 # 1 pixels between adjacent branches
ts.scale = 2000 # 2000 pixels per branch length unit
ts.layout_fn = layout
return t, ts
