def test_to_standard_form_completion(self):
# read trees from *.xtg files in xtg folder
src_trees = read_all_trees(
pattern="test/test_input/test_standard_form_compl_*.xtg",
is_test_nodes=True)
# create a copy of trees to modify
trees = [copy.deepcopy(src_tree) for src_tree in src_trees]
self.assertEqual("ZDG X NAN".replace(" ", ""), trees[0].to_string(3))
self.assertEqual("NAN X GDZ".replace(" ", ""), trees[1].to_string(3))
trees[0].to_standard_form(3)
trees[1].to_standard_form(3)
self.assertEqual("ZDG X NAN".replace(" ", ""), trees[0].to_string(3))
self.assertEqual(
trees[1].root.to_array(3),
trees[0].root.to_array(3)) # equal after standartization
self.assertNotEqual(src_trees[1].root.to_array(3),
trees[1].root.to_array(3)) # changed
self.assertEqual(
src_trees[0].root.to_array(3),
trees[0].root.to_array(3)) # not changed during standartization
def test_calculate_number_on_level_2_trees_common_trees(self):
is_reducing = False
use_flipping = False
use_min_common_depth = False
trees = read_all_trees(
pattern="test/test_input/development_tree_utils/*.xtg")
# prepare to calculate distances
for tree in trees:
if is_reducing:
tree.reduce()
tree.prepare(use_min_common_depth, use_flipping)
node1 = trees[0].root
node2 = trees[1].root
start_numbers = [1] * 3
calculate_number_on_level_2_trees(node1, node2, start_numbers)
self.assertEqual(1, node1.number_on_level)
self.assertEqual(1, node2.number_on_level)
self.assertEqual(1, node1.left.number_on_level)
self.assertEqual(1, node2.left.number_on_level)
self.assertEqual(2, node1.right.number_on_level)
self.assertEqual(2, node2.right.number_on_level)
self.assertEqual(1, node1.left.left.number_on_level)
self.assertEqual(1, node2.left.left.number_on_level)
self.assertTrue(node1.left.right.is_none())
self.assertEqual(2, node2.left.right.number_on_level)
self.assertEqual(3, node1.right.left.number_on_level)
self.assertEqual(3, node2.right.left.number_on_level)
self.assertTrue(node1.right.right.is_none())
self.assertTrue(node2.right.right.is_none())
def __init__(self, experiment_pattern, max_level=10, is_reducing=True, use_min_common_depth=False,
use_flipping=False):
vertices = read_all_trees(pattern=experiment_pattern)
self.vertices = sorted(list(vertices), key=lambda x: x.name)
self.names = [v.name for v in self.vertices]
prepare_trees(self.vertices, max_level, is_reducing, use_min_common_depth, use_flipping)
def get_distances_by_files(pattern, global_params, is_reducing, use_flipping=False, use_min_common_depth=False, is_test_nodes=False):
# read trees from *.xtg files in xtg folder
src_trees = read_all_trees(pattern=pattern, is_test_nodes=is_test_nodes)
# create a copy of trees to modify
trees = [copy.deepcopy(src_tree) for src_tree in src_trees]
# prepare to calculate distances
for tree in trees:
if is_reducing:
tree.reduce(global_params.is_test_nodes)
tree.prepare(use_min_common_depth, use_flipping)
# calculate distances matrix
distance_matrix = [[full_distance(global_params, v1.root, v2.root, v2.flipped_root) for v2 in trees] for v1 in trees]
return [src_trees, distance_matrix]
def specie_fertility_distance(max_level=10,
is_reducing=True,
use_min_common_depth=False,
use_flipping=False):
trees = read_all_trees(pattern="../../input/xtg/*.xtg")
prepare_trees(trees, max_level, is_reducing, use_min_common_depth,
use_flipping)
global_params = GlobalParams(max_level=max_level,
param_a=0.5,
g_weight=0.0,
chain_length_weight=0.0)
level2count = {
0: 0,
1: 0,
2: 0,
3: 0,
4: 0,
5: 0,
6: 0,
7: 0,
8: 0,
9: 0,
10: 0,
11: 0
}
sp_fert_dist = []
for i in range(len(trees)):
for j in range(i + 1, len(trees)): # skip repeating pairs
# get array of tuples (node1, node2, distance, ...)
superimposed_node = SuperimposedNode(trees[i].root, trees[j].root)
distances = superimposed_node.high_fertility_distance()
for [addr, dist, reduced_level, node1, node2] in distances:
# ignore cases when at the last level history is completely equal
if dist == 0:
continue
level2count[reduced_level + 1] += 1
# ignore zygote and the next level
if reduced_level < 0:
continue
leaves1 = node1.leaves_number
leaves2 = node2.leaves_number
tree1 = trees[i]
tree2 = trees[j]
# switch order
if leaves1 < leaves2:
tree1 = trees[j]
tree2 = trees[i]
tmp_node = node1
node1 = node2
node2 = tmp_node
tmp_leaves = leaves1
leaves1 = leaves2
leaves2 = tmp_leaves
left_right_number = number_by_address(tree1.root,
tree2.root,
addr,
is_reducing=is_reducing)
is_left_0_descendants = (node1.left.is_none()) and (
node1.right.is_none())
is_right_0_descendants = (node2.left.is_none()) and (
node2.right.is_none())
l_or_r = "-"
if is_left_0_descendants:
l_or_r = trees[i].name
elif is_right_0_descendants:
l_or_r = trees[j].name
res = [
tree1.name, tree2.name, dist, reduced_level + 1,
left_right_number, is_left_0_descendants
or is_right_0_descendants, l_or_r, addr, node1.address,
node2.address, leaves1, leaves2
]
sp_fert_dist.append(res)
return sp_fert_dist
draw_settings = TreeDrawSettings(color_left=0xFF285EDD,
color_right=0xFFFC7074,
color_eq=0xFFE8E4DE,
color_ineq=0xFFE8E4DE,
get_node_caption_1=double_node_caption_1,
get_node_caption_2=node_dist_caption_2,
font=load_font(FONT_PATH, 10),
legend_font=load_font(FONT_PATH, 20),
width=2000,
height=720)
tree_drawer = TreeDrawer(draw_settings, global_params)
# read and prepare trees: reduce if necessary, precalculate some parameters
# notice: file names must be "Genus_specie_type.xtg", and it will be shown as "Genus specie"
trees = read_all_trees(pattern="test/test_input/sofa/test_reduce*.xtg",
is_test_nodes=True,
max_level=max_level)
#trees = read_all_trees(pattern="test/test_input/paper_m/M2_*.xtg", is_test_nodes=True)
#trees = read_all_trees(pattern="test/test_input/test_reduce*.xtg", is_test_nodes=True)
trees = sorted(list(trees), key=lambda x: x.name)
prepare_trees(trees,
max_level,
is_reducing=is_reducing,
use_min_common_depth=False,
use_flipping=False)
# get N*(N-1) tree pairs, superimpose and draw
for i in range(0, len(trees)):
for j in range(i + 1, len(trees)):
im = tree_drawer.draw_tree(trees[i], trees[j], "")
plt.imshow(im)