def main():
args = parser.parse_args()
beta_metrics = args.beta_metrics.split(',')
otu_widths = args.otu_widths.split(',')
input_dir = args.input_dir
output_fp = args.output_fp
tree_fp = args.tree_fp
nrows = len(beta_metrics)
ncols = len(otu_widths)
results_dict, labels_list = load_rug_dict(input_dir, beta_metrics,
otu_widths)
try:
tree = Tree(tree_fp, format=3)
except:
tree = add_tip_branches(tree_fp)
annotate_tree_with_rugs(tree, results_dict, labels_list)
ts = TreeStyle()
for row in range(len(labels_list)):
for col in range(len(labels_list[row])):
ts.legend.add_face(TextFace(labels_list[row][col], fsize=20),
column=col)
tree.render(output_fp, tree_style=ts)
tree.show(tree_style=ts)
def render(self, fname, layout=None, tree_style=None, palette=None):
"""
Renders the locus tree and writes the image to file.
:param fname: str
Output file path
:param layout:
:param tree_style:
:param palette:
:return: None
"""
if not palette:
palette = ['#1F77B4', '#AEC7E8', '#FF7F0E',
'#FFBB78', '#2CA02C', '#98DF8A',
'#D62728', '#FF9896', '#9467BD',
'#C5B0D5', '#8C564B', '#C49C94',
'#E377C2', '#F7B6D2', '#7F7F7F',
'#C7C7C7', '#BCBD22', '#DBDB8D',
'#17BECF', '#9EDAE5']
if not self.colorized:
self._colorize(palette)
self.colorized = True
if not tree_style:
from ete2 import TreeStyle
tree_style = TreeStyle() # imported during colorizing tree
# tstyle.show_leaf_name = False
tree_style.scale = 28
tree_style.branch_vertical_margin = 6
tree_style.show_branch_length = False
# tstyle.show_branch_support = True
tree_style.show_scale = False
self.L.convert_to_ultrametric()
self.L.render(file_name=fname, tree_style=tree_style)
def showTreeInGrid(gid, biome, grid_level=14, taxonomic_level='sp'):
"""
Performs a selection, spatial filter and returns an image.
grid_level is the grid layer.
taxonomic_level is the taxonomic level to be shown. Options are:
sp, gns, fam, ord, cls, phy, king
"""
mesh = initMesh(grid_level)
try:
cell = mesh.objects.get(id=id)
except:
logger.error("Selected id does not exist in selected grid")
return None
gb = GriddedTaxonomy(biome, cell, generate_tree_now=True)
forest = gb.taxonomies[0].forest
ts = TreeStyle()
ts.show_leaf_name = True
ts.mode = "c"
ts.arc_start = -180 # 0 degrees = 3 o'clock
ts.arc_span = 360
forest[taxonomic_level].show(tree_style=ts)
return 'Parece que se tiene que ver algo'
def print_colored_host_tree(host_tree_fp, host_colors, output_fp, treefmt=5):
with open(host_tree_fp) as tree_f:
treestring = remove_newick_node_labels(tree_f.readline().strip())
tree = Tree(newick=treestring, format=treefmt)
for host in host_colors:
if tree.get_leaves_by_name(host) == []:
tip = "'%s'" % host
else:
tip = host
node = tree.get_leaves_by_name(tip)[0]
node.add_face(AttrFace("name", fsize=14, fgcolor=host_colors[host]), 0)
# remove stupid blue circles on nodes
style = NodeStyle()
style["size"] = 0
for l in tree.traverse():
l.set_style(style)
# get rid of default rendered leaf labels
ts = TreeStyle()
ts.show_leaf_name = False
tree.render(output_fp, tree_style=ts)
return
def ete_tree(aln):
"""Tree showing alleles"""
from ete2 import Tree, PhyloTree, TreeStyle, NodeStyle
t = Tree('temp.dnd')
ts = TreeStyle()
ts.show_leaf_name = True
ts.mode = "c"
ts.arc_start = -180
ts.arc_span = 180
cutoff = 0.25
def func(node):
if node.name == 'NoName': #or not node.name in metric:
return False
#if metric[node.name]<=cutoff:
# return True
matches = filter(func, t.traverse())
print(len(matches), "nodes have distance <=%s" % cutoff)
nst1 = NodeStyle()
nst1["bgcolor"] = "Yellow"
for n in matches:
n.set_style(nst1)
nst2 = NodeStyle()
nst2["bgcolor"] = "LightGreen"
#hlanodes = [t.get_leaves_by_name(name=r)[0] for r in refalleles]
#for n in hlanodes:
# n.set_style(nst2)
t.show(tree_style=ts)
return
def show(self, tree_style=None, palette=None):
"""
Starts an interactive session to visualize the decomposition.
:return: None
"""
if not palette:
palette = ['#1F77B4', '#AEC7E8', '#FF7F0E',
'#FFBB78', '#2CA02C', '#98DF8A',
'#D62728', '#FF9896', '#9467BD',
'#C5B0D5', '#8C564B', '#C49C94',
'#E377C2', '#F7B6D2', '#7F7F7F',
'#C7C7C7', '#BCBD22', '#DBDB8D',
'#17BECF', '#9EDAE5']
if not self.colorized:
self._colorize(palette)
self.colorized = True
if not tree_style:
from ete2 import TreeStyle
tree_style = TreeStyle()
# tstyle.show_leaf_name = False
tree_style.scale = 28
tree_style.branch_vertical_margin = 6
tree_style.show_branch_length = False
# tstyle.show_branch_support = True
tree_style.show_scale = False
self.L.convert_to_ultrametric()
self.L.show(tree_style=tree_style)
def render_annotate(newick_path, output_path):
"""Render the annotated tree, showing internal node names.
The output_path should end in .PNG, .PDF or .SVG: this will determine the format.
To aid in testing, if output_path is None, the tree is shown rather than rendered.
"""
tree = Tree(newick_path, format=1)
ts = TreeStyle()
ts.show_leaf_name = True
ts.branch_vertical_margin = 15
ns = NodeStyle()
ns["size"] = 1
edge = 0
for node in tree.traverse():
node.name = node.name.replace("'", "")
node.name = node.name.replace("+", ",")
if not node.is_leaf() and node.name != 'NoName':
f = TextFace(node.name)
f.margin_top = 5
f.margin_bottom = 5
f.margin_right = 10
f.margin_left = 10
edge += 1
node.add_face(f, column=0, position="branch-top")
if output_path is None:
tree.show(tree_style=ts)
else:
tree.render(output_path)
def setUp(self):
tree = Tree()
root = tree.get_tree_root()
root.dist = 0
root.name = "root"
node = root.add_child(name="Left")
node.add_child(name="Alpha")
node.add_child(name="Beta")
node = root.add_child(name="Right")
node.add_child(name="Gamma")
node.add_child(name="Delta")
for desc in tree.iter_descendants():
desc.dist = 0
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = False
ts.mode = "c"
ts.arc_start = 0
ts.arc_span = 360
self.circular_style = ts
self.exampleTree = tree
self.alignment = MultipleSeqAlignment([
SeqRecord(Seq("AAG", generic_dna), id="Alpha"),
SeqRecord(Seq("AGA", generic_dna), id="Beta"),
SeqRecord(Seq("AAA", generic_dna), id="Gamma"),
SeqRecord(Seq("GGA", generic_dna), id="Delta"),
])
def ETETree(seqs, ref, metric):
"""Tree showing bola alleles covered by tepitope"""
from ete2 import Tree, PhyloTree, TreeStyle, NodeStyle
aln = Genome.clustalAlignment(seqs=seqs)
t = Tree('temp.dnd')
#t.set_outgroup(t&ref)
ts = TreeStyle()
ts.show_leaf_name = True
ts.mode = "c"
ts.arc_start = -180
ts.arc_span = 180
cutoff = 0.25
def func(node):
if node.name == 'NoName' or not node.name in metric:
return False
if metric[node.name] <= cutoff:
return True
matches = filter(func, t.traverse())
print len(matches), "nodes have distance <=%s" % cutoff
nst1 = NodeStyle()
nst1["bgcolor"] = "Yellow"
for n in matches:
n.set_style(nst1)
nst2 = NodeStyle()
nst2["bgcolor"] = "LightGreen"
hlanodes = [t.get_leaves_by_name(name=r)[0] for r in refalleles]
for n in hlanodes:
n.set_style(nst2)
t.show(tree_style=ts)
return
def __init__(self):
init_balances = {}
for i in xrange(Parameters.num_peers):
init_balances["P_" + str(i)] = Parameters.start_balance
self.gen_block = Block("B_-1", 0, init_balances, {}, {}, "None")
self.nodes = [Peer("P_" + str(i), self.get_delay, self.gen_block) for i in xrange(Parameters.num_peers)]
self.node_is_slow = dict()
self.network_graph = self.generate_graph()
self.assign_neighbours()
for i in xrange(Parameters.num_peers):
pid = "P_" + str(i)
self.node_is_slow[pid] = (random.random() < Parameters.z)
# testing str of peers.
t = threading.Timer(5, self.nodes[0].write_to_file)
t.start()
#for tree generation
if _ete2_import:
self.nst = [NodeStyle() for i in xrange(Parameters.num_peers)]
self.fnst = [NodeStyle() for i in xrange(Parameters.num_peers)]
for i in xrange(Parameters.num_peers):
self.nst[i]["bgcolor"] = "#" + str(hex(random.randint(128,255)))[2:] + str(hex(random.randint(128,255)))[2:] + str(hex(random.randint(128,255)))[2:]
for i in xrange(Parameters.num_peers):
self.fnst[i]["size"] = 15
self.fnst[i]["fgcolor"] = self.nst[i]["bgcolor"]
self.ts = TreeStyle()
# self.ts.mode = "c" #circle
self.ts.show_leaf_name = False
def my_layout(node):
F = TextFace(node.name, tight_text=True)
add_face_to_node(F, node, column=0, position="branch-right")
self.ts.layout_fn = my_layout
def print_colored_host_tree(host_tree_fp, host_colors, output_fp):
tree = Tree(host_tree_fp)
for host in host_colors:
if tree.get_leaves_by_name(host) == []:
tip = "'%s'" % host
else:
tip = host
node = tree.get_leaves_by_name(tip)[0]
node.add_face(AttrFace("name", fsize=14, fgcolor=host_colors[host]), 0)
# remove stupid blue circles on nodes
style = NodeStyle()
style["size"] = 0
for l in tree.traverse():
l.set_style(style)
# get rid of default rendered leaf labels
ts = TreeStyle()
ts.show_leaf_name = False
tree.render(output_fp, tree_style=ts)
return
def generateImage(self, tree):
ts = TreeStyle()
ts.layout_fn = self.__layout__
ts.mode = "c"
ts.show_leaf_name = False
tree.render(self.treePNGFile, w=1000, tree_style=ts)
tree.render(self.treeSVGFile, w=250, tree_style=ts)
def add_taxonomy_label(cotu_tree, potu_table):
ts = TreeStyle()
for row in range(len(labels_list)):
for col in range(len(labels_list[row])):
ts.legend.add_face(TextFace(labels_list[row][col], fsize=20),
column=col)
def constructing_final_tree(distance_matrix, protein_labels):
v = str(upgma(distance_matrix, protein_labels)) + ";"
t = Tree(v)
ts = TreeStyle()
ts.show_leaf_name = True
t.convert_to_ultrametric()
ts.scale = 120
t.show(tree_style=ts)
def plotTree(self, tree, out_fn=None, rotation=270, show_leaf_name=False,
show_branch_length=False, circularTree=False, show_division_nodes=True,
distance_between_branches=4, show_border=False, width=None, height=None):
from ete2 import TreeStyle
from PyQt4 import QtSvg, QtCore, QtGui
from ete2.treeview import qt4_render, drawer, main
ts = TreeStyle()
ts.show_scale = False
ts.show_border = show_border
ts.orientation = 1 # 0, tree is drawn from left-to-right. 1, tree is drawn from right-to-left
ts.rotation = rotation
ts.show_leaf_name = show_leaf_name
ts.show_branch_length = show_branch_length
if circularTree:
ts.mode = 'c'
else:
ts.mode = 'r'
ts.branch_vertical_margin = distance_between_branches
def hideInternalNodesLayout(node):
if not node.is_leaf():
node.img_style["size"] = 0
if show_division_nodes is False:
ts.layout_fn = hideInternalNodesLayout
if out_fn is not None:
scene = qt4_render._TreeScene()
img = ts
tree_item, n2i, n2f = qt4_render.render(tree, img)
scene.init_data(tree, img, n2i, n2f)
tree_item.setParentItem(scene.master_item)
scene.master_item.setPos(0,0)
scene.addItem(scene.master_item)
main.save(scene, out_fn, w=width, h=height, dpi=600)
else:
scene, img = drawer.init_scene(tree, None, ts)
tree_item, n2i, n2f = qt4_render.render(tree, img)
scene.init_data(tree, img, n2i, n2f)
tree_item.setParentItem(scene.master_item)
scene.addItem(scene.master_item)
size = tree_item.rect()
w, h = size.width(), size.height()
svg = QtSvg.QSvgGenerator()
svg.setFileName("test.svg")
svg.setSize(QtCore.QSize(w, h))
svg.setViewBox(size)
pp = QtGui.QPainter()
pp.begin(svg)
scene.render(pp, tree_item.rect(), tree_item.rect(), QtCore.Qt.KeepAspectRatio)
def constructing_final_tree(distance_matrix, protein_labels):
v = str(neighbor_joining(distance_matrix, protein_labels)) + ";"
t = Tree(v)
t.dist = 0
ts = TreeStyle()
ts.mode = "c"
ts.show_leaf_name = True
ts.layout_fn = my_layout
t.show(tree_style=ts)
def draw_ete_tree(self,
corpus,
fontsize=5,
color_leafs=False,
save_newick=True,
mode='c',
outputfile=None,
return_svg=True,
show=False,
save=False):
root = self.to_ete(labels=corpus.titles)
def layout(node):
if node.is_leaf():
N = AttrFace("name", fsize=7)
faces.add_face_to_node(faces.AttrFace("name", "Arial", 10,
None),
node,
0,
position='branch-right')
# problems: aligment of labels to branch, left padding of labels
ts = TreeStyle()
ts.mode = mode
ts.show_leaf_name = False
ts.scale = 120
ts.show_scale = False
ts.branch_vertical_margin = 10
nstyle = NodeStyle()
nstyle["fgcolor"] = "#0f0f0f"
nstyle["size"] = 0
nstyle["vt_line_color"] = "#0f0f0f"
nstyle["hz_line_color"] = "#0f0f0f"
nstyle["vt_line_width"] = 1
nstyle["hz_line_width"] = 1
nstyle["vt_line_type"] = 0
nstyle["hz_line_type"] = 0
for n in root.traverse():
n.set_style(nstyle)
ts.layout_fn = layout
if outputfile:
outputfile = os.path.expanduser(outputfile)
if save_newick: # save tree in newick format for later manipulation in e.g. FigTree:
root.write(outfile=os.path.splitext(outputfile)[0] + '.newick')
if save:
root.render(outputfile, tree_style=ts)
if show:
root.show(tree_style=ts)
if return_svg: # return the SVG as a string
return root.render("%%return")[0]
def get_example_tree():
# Performs a tree reconciliation analysis
gene_tree_nw = '((Dme_001,Dme_002),(((Cfa_001,Mms_001),((Hsa_001,Ptr_001),Mmu_001)),(Ptr_002,(Hsa_002,Mmu_002))));'
species_tree_nw = "((((Hsa, Ptr), Mmu), (Mms, Cfa)), Dme);"
genetree = PhyloTree(gene_tree_nw)
sptree = PhyloTree(species_tree_nw)
recon_tree, events = genetree.reconcile(sptree)
recon_tree.link_to_alignment(alg)
return recon_tree, TreeStyle()
def prettifyTree(ete_tree,
leaf_font_size=32,
branch_support_size=20,
show_bootstraps=True,
title=None,
ts=None):
''' Perform standardized functions to make the ETE trees easier to read:
- Make the branch support bigger
- Make the leaf fonts bigger
- Turn off elongating branches for visualization purposes (i.e. make sure the real branch lengths are represented)
- Change both to standard font (Times)
- Standardize the tree's width (calculate based on the maximum length from the root to a tip)
- (optional) add title to tree
'''
for node in ete_tree.traverse():
if node.is_leaf():
# Make text faces with name = the existing node name but with big font.
# A side effect of this is that we also get the annotations lined up
F = faces.TextFace(node.name, ftype="Times", fsize=leaf_font_size)
node.add_face(F, 0, position="aligned")
else:
if show_bootstraps:
# Make branch support bigger
F = faces.TextFace(node._support,
ftype="Times",
fsize=branch_support_size)
node.add_face(F, 0, position="branch-top")
#correct the long root node bug (fixed in next release)
ete_tree.dist = 0
# Optionally create a new TreeStyle if we are not passing in an old one.
if ts is None:
ts = TreeStyle()
# This "fixes" the dashed line issue but makes the tree look terrible.
# There may be no way around this (and it's likely other tree viewers do the same thing
# but just don't tell you).
#ts.optimal_scale_level = "full"
# We made these bigger so lets turn off the default ones too.
ts.show_branch_support = False
ts.show_leaf_name = False
if title is not None:
ts.title.clear()
title = TextFace(title)
title.hz_align = True
title.fsize = 52
ts.title.add_face(title, 0)
return ete_tree, ts
def drawTree(nwfile, outfile):
from ete2 import Tree, TreeStyle, TextFace
ts = TreeStyle()
ts.show_leaf_name = False
ts.layout_fn = my_layout
ts.branch_vertical_margin = 12.75
ts.orientation = 1
titleFace = TextFace("Phylogenetic Tree", fsize=18, fgcolor="white")
titleFace.margin_top = 15
ts.title.add_face(titleFace, column=1)
t = Tree(nwfile)
t.render(outfile, tree_style=ts)
def render_symbiont_tree(symbiont_tree, output_fp, ts=TreeStyle()):
ts.show_leaf_name = True
# ts.scale = 300 # 120 pixels per branch length unit
# ts.mode = "c"
nstyle = NodeStyle()
nstyle["shape"] = "circle"
nstyle["size"] = 0
for n in symbiont_tree.traverse():
n.set_style(nstyle)
print 'rendering tree'
symbiont_tree.render(output_fp, tree_style=ts)
def get_tree_style(scale=None, vertical_margin=None):
"""Setups the tree-style used when rendering the tree"""
style = TreeStyle()
style.show_leaf_name = False
if scale:
style.scale = scale
style.show_border = True
if vertical_margin:
style.branch_vertical_margin = vertical_margin
return style
def ete_tree(self, labels=None):
if sys.version_info[0] == 2:
from ete2 import Tree, NodeStyle, TreeStyle
elif sys.version_info[0] == 3:
from ete3 import Tree, NodeStyle, TreeStyle
else:
raise ValueError('Your version of Python is not supported.')
from scipy.cluster.hierarchy import to_tree
T = to_tree(self.to_linkage_matrix())
root = Tree()
root.dist = 0
root.name = "root"
item2node = {T: root}
to_visit = [T]
while to_visit:
node = to_visit.pop()
cl_dist = node.dist / 2.0
for ch_node in [node.left, node.right]:
if ch_node:
ch = Tree()
ch.dist = cl_dist
ch.name = str(ch_node.id)
item2node[node].add_child(ch)
item2node[ch_node] = ch
to_visit.append(ch_node)
if labels != None:
for leaf in root.get_leaves():
leaf.name = str(labels[int(leaf.name)])
ts = TreeStyle()
ts.show_leaf_name = True
# Draws nodes as small red spheres of diameter equal to 10 pixels
nstyle = NodeStyle()
nstyle["shape"] = None
nstyle["size"] = 0
# 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 root.traverse():
n.set_style(nstyle)
return root
def __init__(self, tree, options):
self._tree = tree
self._options = options
self._formatingMethods = []
self._storageDir = None
self._filePrefix = None
self._style = TreeStyle()
self._style.show_leaf_name = True
self._style.show_branch_length = False
self._style.scale = 80
self._style.branch_vertical_margin = 15
self._style.rotation = 90
self._style.arc_start = -180
self._style.arc_span = 180
self.parseOptions(options)
def build_tree_style(tree):
# use our simple TSS cascade to prepare an ETE TreeStyle object
sheets = gather_tss_stylesheets(tree)
if len(sheets) == 0:
return None
# Some styles can be applied to the entire tree
ts = TreeStyle()
# For nodes (and other elements?), build an ordered set of TSS rules
# to apply to each element in our layout function
node_rules = []
for s in sheets:
ts, tss_cascade = apply_stylesheet(
stylesheet=s,
tree_style=ts,
node_rules=node_rules)
otu_collections = tree.nexml_project.get_otus()
# Use a layout function to test each node against TSS selectors?
def apply_tss(node):
node_style = NodeStyle()
# gather label text and styles separately; we'll need to add this
# using a TextFace after all styles have been considered
label_specs = {}
label_specs['text'] = get_proper_node_label(node, otu_collections)
for rule in node_rules:
# Test this node against each selector
if test_node_against_selector(node, rule.selector):
node_style, node = apply_node_rule(rule, node_style, node, label_specs)
node.set_style(node_style);
# assign the final label with appropriate style
if node.is_leaf():
label_face = TextFace(**label_specs)
node.add_face(label_face, 0)
return node
# apply this layout function to each node as it's rendered
ts.layout_fn = apply_tss
# suppress default node-labeling behavior (so we can style labels!)
ts.show_leaf_name = False
return ts
def main(args):
if args.ofn == None:
args.ofn = args.ifn + '.png'
ts = TreeStyle()
ts.show_leaf_name = True
nstyle = NodeStyle()
#nstyle["shape"] = "sphere"
nstyle["size"] = 5
#nstyle["fgcolor"] = "darkred"
nstyle["vt_line_width"] = 2
nstyle["hz_line_width"] = 2
#ts.mode = "c"
tree = Tree(args.ifn)
for n in tree.traverse():
n.set_style(nstyle)
tree.render(args.ofn, tree_style=ts, dpi=300, units='in') #, h=20, w=20)
def draw_significant_expansion_contraction(
self, outfile_prefix="significant_expansion_contraction_tree"):
tree = self.tree
for node in tree.traverse():
node.img_style["size"] = 0
def layout(node):
if node.up is not None:
attr = AttrFace("significant_expansion",
fsize=7,
fgcolor="green",
text_prefix="+")
faces.add_face_to_node(attr, node, 0, position="branch-top")
attr = AttrFace("significant_contraction",
fsize=7,
fgcolor="red",
text_prefix="-")
faces.add_face_to_node(attr, node, 0, position="branch-bottom")
if node.is_leaf():
attr = AttrFace("name",
fsize=10,
fgcolor="black",
text_prefix=" ",
fstyle="italic")
faces.add_face_to_node(attr, node, 0, position="aligned")
ts = TreeStyle()
ts.layout_fn = layout
ts.optimal_scale_level = "full"
ts.branch_vertical_margin = 10
ts.show_leaf_name = False
#ts.allow_face_overlap =True
tree.render("%s.png" % outfile_prefix,
w=200,
units='mm',
tree_style=ts,
dpi=1200)
tree.render("%s.svg" % outfile_prefix,
w=200,
units='mm',
tree_style=ts,
dpi=1200)
def render_tree(tree, fname):
# Generates tree snapshot
npr_nodestyle = NodeStyle()
npr_nodestyle["fgcolor"] = "red"
for n in tree.traverse():
if hasattr(n, "nodeid"):
n.set_style(npr_nodestyle)
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = True
ts.show_branch_support = True
ts.mode = "r"
iterface = faces.TextFace("iter")
ts.legend.add_face(iterface, 0)
tree.dist = 0
tree.sort_descendants()
tree.render(fname, tree_style=ts, w=700)
def draw(self, out_file_prefix, w=140, units="mm"):
def layout(node, feature):
if node.up is not None or feature == "id":
attr = AttrFace(feature, fsize=5, fgcolor="green")
faces.add_face_to_node(attr, node, 0, position="branch-top")
for feature in self.tree.features - set(["support", "name"]):
if feature[0] == "_":
continue # skip _nid feature and other technical features of tree
def layout_arg(node):
return layout(node, feature)
ts = TreeStyle()
ts.layout_fn = layout_arg
self.tree.render("%s_%s.png" % (out_file_prefix, feature),
w=w,
units=units,
tree_style=ts)
def main(argv):
inputfile = ''
outgroup = ''
outputfile = ''
ts = TreeStyle()
ts.show_leaf_name = True
ts.show_branch_length = False
ts.show_branch_support = True
ns = NodeStyle()
ns["size"] = 0
ns["vt_line_width"] = 2
ns["hz_line_width"] = 2
try:
opts, args = getopt.getopt(argv, "hi:o:p:",
["input=", "outgroup=", "-prefix-svg="])
except getopt.GetoptError:
print 'print-single-nwk.py -i <inputfile> -o <outgroup> -p <prefixsvg>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'print-single-nwk.py -i <inputfile> -o <outgroup> -p <prefixsvg>'
sys.exit()
elif opt in ("-i", "--input"):
inputfile = arg
elif opt in ("-o", "--outgroup"):
outgroup = arg
elif opt in ("-p", "--prefix-svg"):
outputfile = arg
# read tree
t = Tree(inputfile)
t.set_outgroup(outgroup)
t.ladderize(1)
for node in t.traverse():
node.set_style(ns)
# print final tree
t.render(outputfile + ".svg", tree_style=ts)
