def read_tree(self, line, label_line):
# FIXED: tree.idx, also tree dict() use base 1 as it was in dataset
# parents is list base 0, keep idx-1
# labels is list base 0, keep idx-1
parents = list(map(int,
line.split())) # split each number and turn to int
trees = dict() # this is dict
root = None
labels = list(map(self.parse_dlabel_token, label_line.split()))
for i in range(1, len(parents) + 1):
#if not trees[i-1] and parents[i-1]!=-1:
if i not in trees.keys() and parents[i - 1] != -1:
idx = i
prev = None
while True:
parent = parents[idx - 1]
if parent == -1:
break
tree = Tree()
if prev is not None:
tree.add_child(prev)
trees[idx] = tree
tree.idx = idx # -1 remove -1 here to prevent embs[tree.idx -1] = -1 while tree.idx = 0
tree.gold_label = labels[idx - 1] # add node label
#if trees[parent-1] is not None:
if parent in trees.keys():
trees[parent].add_child(tree)
break
elif parent == 0:
root = tree
break
else:
prev = tree
idx = parent
return root
def read_tree(self, line):
parents = map(int, line.split())
trees = dict()
root = None
for i in xrange(1, len(parents) + 1):
#if not trees[i-1] and parents[i-1]!=-1:
if i - 1 not in trees.keys() and parents[i - 1] != -1:
idx = i
prev = None
while True:
parent = parents[idx - 1]
if parent == -1:
break
tree = Tree()
if prev is not None:
tree.add_child(prev)
trees[idx - 1] = tree
tree.idx = idx - 1
#if trees[parent-1] is not None:
if parent - 1 in trees.keys():
trees[parent - 1].add_child(tree)
break
elif parent == 0:
root = tree
break
else:
prev = tree
idx = parent
return root
def test_traverse_returns_none_when_operation_always_returns_false():
t = Tree("a")
t.add_child("b")
node = t.traverse(lambda n: False)
assert_that(node, is_(None))
def read_tree(self, line):
parents = list(map(int,line.split()))
trees = dict()
root = None
for i in range(1,len(parents)+1):
if i-1 not in trees.keys() and parents[i-1] != -1:
idx = i
prev = None
while True:
parent = parents[idx-1]
if parent == -1:
break
tree = Tree()
if prev is not None:
tree.add_child(prev)
trees[idx-1] = tree
tree.idx = idx-1
#if trees[parent-1] is not None:
if parent-1 in trees.keys():
trees[parent-1].add_child(tree)
break
elif parent==0:
root = tree
break
else:
prev = tree
idx = parent
#root = self.compact_tree(root, level=3)
#print('root depth after compacting: ', root.depth())
return root
class FileSystem:
def __init__(self, root):
self.file_system = Tree(root)
self.level = []
def add_root_dirs(self):
for _dir in sorted(os.listdir('.')):
self.file_system.add_child(self.file_system.root.value,
os.path.abspath(_dir))
self.level = self.file_system.root.children
def add_next_level(self):
while self.level != []:
for child in self.level:
if os.path.isdir(child.value):
os.chdir(child.value)
for c in os.listdir(child.value):
self.file_system.add_child(child.value,
os.path.realpath(c))
os.chdir('..')
self.level = [c for c in child.children for child in self.level]
def flatten_file_system1(self):
return self.flatten()
def flatten(self):
return [
val for subxs in self.file_system.tree_levels() for val in subxs
]
def flatten_file_system2(self):
return self.file_system.DFS(self.file_system.root)
def read_tree(self, parents):
# 传入进来的parents是tensor,转化为list
parents = parents.numpy().tolist()
# parents = list(map(int,line.split()))
trees = dict()
root = None
for i in range(1, len(parents) + 1):
if i - 1 not in trees.keys() and parents[i - 1] != -1:
idx = i
prev = None
while True:
parent = parents[idx - 1]
if parent == -1:
break
tree = Tree()
if prev is not None:
tree.add_child(prev)
trees[idx - 1] = tree
tree.idx = idx - 1
if parent - 1 in trees.keys():
trees[parent - 1].add_child(tree)
break
elif parent == 0:
root = tree
break
else:
prev = tree
idx = parent
return root
def build_prereq_tree(self, goal_conditions):
"""
Builds a tree of courses and their prerequisites to pre-calculate the depths of paths in the search tree.
:param goal_conditions: @see course_scheduler(course_descriptions, goal_conditions, initial_state)
:return: Root of the tree
"""
for course in goal_conditions:
prereqs = self.get_prereqs(course)
root = Tree(course)
prereqSet = flatten(prereqs)
if prereqSet == set():
root.max_depth = 0
self.heuristic_dictionary[course] = root.max_depth
return root
else:
depths = []
for prereq in prereqSet:
toAdd = self.build_prereq_tree([prereq])
root.add_child(toAdd)
self.heuristic_dictionary[prereq] = toAdd.max_depth
depths.append(toAdd.max_depth + 1)
root.max_depth = max(depths)
return root
def read_tree(self, line, label_line):
# TODO: read gold label
parents = map(int, line.split()) # split each number and turn to int
trees = dict()
root = None
labels = map(self.parse_dlabel_token, label_line.split())
for i in xrange(1, len(parents) + 1):
#if not trees[i-1] and parents[i-1]!=-1:
if i - 1 not in trees.keys() and parents[i - 1] != -1:
idx = i
prev = None
while True:
parent = parents[idx - 1]
if parent == -1:
break
tree = Tree()
if prev is not None:
tree.add_child(prev)
trees[idx - 1] = tree
tree.idx = idx - 1
tree.gold_label = labels[idx - 1] # add node label
#if trees[parent-1] is not None:
if parent - 1 in trees.keys():
trees[parent - 1].add_child(tree)
break
elif parent == 0:
root = tree
break
else:
prev = tree
idx = parent
return root
def predictTree(image_caption_model, img):
device = torch.device("cuda:0")
root = Tree("root")
root = word_embedding(root)
root.value = torch.tensor(root.value).to(device).float()
while (1):
sub_tree = Tree(image_caption_model(img, root).flatten())
max = 0
max_index = 0
for i in range(14):
if sub_tree.value[i] > max:
max = sub_tree.value[i]
max_index = i
for i in range(14):
if i != max_index:
sub_tree.value[i] = 0
else:
sub_tree.value[i] = 1
root.add_child(sub_tree)
if sub_tree.value[2] == 1:
break
for child in root.children:
if child.value[3] == 1 or child.value[7] == 1 or child.value[
8] == 1 or child.value[9] == 1 or child.value[12] == 1:
predictSubTree(image_caption_model, img, child, root, 1)
return root
def read_tree(self, line, rels):
parents = list(map(int, line.split()))
relations = list(map(str, rels.split()))
trees = dict()
root = None
for i in range(1, len(parents) + 1):
if i - 1 not in trees.keys() and parents[i - 1] != -1:
idx = i
prev = None
while True:
parent = parents[idx - 1]
if parent == -1:
break
tree = Tree()
if prev is not None:
tree.add_child(prev)
trees[idx - 1] = tree
tree.idx = idx - 1
tree.rel = relations[tree.idx]
#tree.rel = self.rel_vocab.getIndex(relations[tree.idx]) ##ADDED Relation
#tree.hidden = None
if parent - 1 in trees.keys():
trees[parent - 1].add_child(tree)
break
elif parent == 0:
root = tree
break
else:
prev = tree
idx = parent
return root
def build_sunet():
# SUNET
sunet = Tree("66a45.sunet.se")
def build_kth():
kth = Tree("kth2.sunet.se")
kth_intranet = Tree("a5ef-6c.kth.se")
for namn in ["red-12", "orange-5", "sport-3", "spel-15"]:
kth_intranet.add_child(Tree(namn))
kth_services = Tree("645ea5.kth.se")
for namn in ["webmail.kth.se", "smtp.kth.se", "www.kth.se"]:
kth_services.add_child(Tree(namn))
kth.add_child(kth_intranet)
kth.add_child(kth_services)
return kth
def build_su():
su = Tree("sthlm-universitet.sunet.se")
services = Tree("65efa64-65edb.su.se")
for namn in ["www.su.se", "smtp.su.se", "webmail.su.se"]:
services.add_child(Tree(namn))
inst = Tree("56afd.f6425-cd8.su.se")
for namn in ["biblioteket.su.se", "math.su.se", "fysik.su.se"]:
inst.add_child(Tree(namn))
su.add_child(services)
su.add_child(inst)
return su
sunet.add_child(build_su())
sunet.add_child(build_kth())
return sunet
def make_bfs_tree_from(self, vertex):
if not(self.member(vertex)):
raise ValueError("The vertex for bfs tree is not a member.")
bfs_tree = Tree(vertex)
visited = [vertex]
splicer = None
queue_ = Queue()
queue_.push_back(vertex)
queue_.push_back(splicer)
while not(queue_.is_empty()):
v = queue_.pop()
if v is splicer:
if queue_.is_empty():
return bfs_tree
queue_.push_back(splicer)
else:
for neighboor in self.graph[v]:
if neighboor not in visited:
bfs_tree.add_child(v, neighboor)
queue_.push_back(neighboor)
visited.append(neighboor)
return bfs_tree
def read_tree(self, line):
parents = map(int,line.split())
trees = dict()
root = None
for i in xrange(1,len(parents)+1):
#if not trees[i-1] and parents[i-1]!=-1:
if i-1 not in trees.keys() and parents[i-1]!=-1:
idx = i
prev = None
while True:
parent = parents[idx-1]
if parent == -1:
break
tree = Tree()
if prev is not None:
tree.add_child(prev)
trees[idx-1] = tree
tree.idx = idx-1
#if trees[parent-1] is not None:
if parent-1 in trees.keys():
trees[parent-1].add_child(tree)
break
elif parent==0:
root = tree
break
else:
prev = tree
idx = parent
return root
def test_add_child_appends_node_to_the_child_list():
t = Tree("a")
t.add_child("b")
t.add_child("c")
assert_that(t.children[0].value, is_("b"))
assert_that(t.children[1].value, is_("c"))
def test_find_returns_node_with_the_specified_value_when_such_exists():
t = Tree("a")
t.add_child("b")
t.add_child("c").add_child("d").add_child("e")
node = t.find("d")
assert_that(node.children[0].value, is_("e"))
def get_root_node(str_parse_tree):
str_json = convert_str_json(str_parse_tree)[0]
print(str_json)
root = Tree()
for key, value in str_json.items():
temp_dic = {}
temp_dic[key] = value
root.add_child(convert_json_tree(temp_dic))
return root
def convert_json_tree(json):
for key, val in json.items():
node = Tree(pos_tag=key)
if(type(val) == type("")):
node.value = val
node.children = None
elif(type(val) == type([])):
for child in val:
node.add_child(convert_json_tree(child))
else:
continue
return node
def test_traverse_uses_depth_first_strategy():
t = Tree("a")
child = t.add_child("b")
child.add_child("d")
child.add_child("e")
t.add_child("c")
visited = []
def visit_all(node):
visited.append(node.value)
return False
t.traverse(visit_all)
assert_that(visited, is_(["a", "b", "d", "e", "c"]))
def build_verisign():
verisign = Tree("5e7a-f.verisign.net")
verisign.add_child(build_banana())
rick_chain = ["Never.gonna.give.you.up.xbfzf.net",
"Never.gonna.let.you.down.xbfzf.net",
"Never.gonna.run.around.and.desert.you.xbfzf.net",
"Never.gonna.make.you.cry.xbfzf.net"]
rick_top = Tree(rick_chain[0])
prev = rick_top
for curr in rick_chain[1:]:
curr = Tree(curr)
prev.add_child(curr)
prev = curr
verisign.add_child(rick_top)
return verisign
def build_su():
su = Tree("sthlm-universitet.sunet.se")
services = Tree("65efa64-65edb.su.se")
for namn in ["www.su.se", "smtp.su.se", "webmail.su.se"]:
services.add_child(Tree(namn))
inst = Tree("56afd.f6425-cd8.su.se")
for namn in ["biblioteket.su.se", "math.su.se", "fysik.su.se"]:
inst.add_child(Tree(namn))
su.add_child(services)
su.add_child(inst)
return su
def test_insert(self):
a = Tree('a')
b = a.add_child('b')
c = a.add_child('c')
d = b.add_child('d')
e = b.add_child('e')
f = c.add_child('f')
g = c.add_child('g')
self.assertIn(b, a.children)
self.assertIn(c, a.children)
def build_tree(event):
'''
input: a batch of events [prev, arg0, arg1, arg2], a list of vertex id
shape: (batchsize x 4 x arg.max_word_length)
'''
# prev, arg0, arg1, arg2 = event
tree = Tree()
tree.idx = 0
ev_len = event.shape[1]
id_ls = list(range(ev_len))
tree.parent = 0
for arg in id_ls[1:]:
argtree = Tree()
argtree.idx = arg
tree.add_child(argtree)
return tree
def build_tree(math_exp_string):
"""
This method is used to build a tree from given input mathematical expression.
Following consideration has been taken
1. higher order operations are given with complete parenthesis ex. 1 - (2*3)
2. add left and right parenthesis if not given ex. (1 - (2 * 3))
3. print error message for any exception
"""
if not validate_math_exp(math_exp_string):
raise InvalidInput('Validation Error, one or more parenthesis are not closed properly')
exp_list = filter_exp_list(math_exp_string)
stack = Stack()
current_node = Tree()
for token in exp_list:
if token == '(':
current_node.add_child()
stack.push(current_node)
current_node = current_node.get_newborn_child()
elif token == ')':
if stack.size():
current_node = stack.pop()
elif token in operator_map.keys():
if current_node.get_val():
if current_node.get_val() == token:
current_node.add_child()
stack.push(current_node)
current_node = current_node.get_newborn_child()
else:
parent = Tree(token)
parent.update_child(current_node)
parent.add_child()
stack.push(parent)
current_node = parent.get_newborn_child()
else:
current_node.set_val(token)
current_node.add_child()
stack.push(current_node)
current_node = current_node.get_newborn_child()
else:
try:
current_node.set_val(float(token))
except ValueError, e:
logging.info(e.message)
current_node.set_val(token)
current_node = stack.pop()
def example_tree():
ft = Tree("/")
for directory in ["bin", "boot", "dev", "etc", "home", "proc"]:
t = Tree(directory)
ft.add_child(t)
if directory == "home":
for user in ["pelle", "stina", "tjorven"]:
u = Tree(user)
t.add_child(u)
if user == "tjorven":
d = Tree("sudata")
u.add_child(d)
for labb in range(3,8):
d.add_child(Tree("labb{}".format(labb)))
return ft
class treeTest(unittest.TestCase):
def setUp(self):
n = Node(5, parent=None)
self.tree = Tree(n)
self.tree.add_child(parent=5, child=4)
self.tree.add_child(parent=5, child=3)
self.tree.add_child(parent=4, child=2)
def test_get_element(self):
self.assertEqual(
self.tree.get_element(5, start=self.tree.root).data, 5)
# def test_find(self):
# self.assertTrue(self.tree.find(3))
def test_count_nodes(self):
self.assertEqual(self.tree.count_nodes(), 4)
def test_height(self):
self.assertEqual(self.tree.height(self.tree.root), 3)
def test_walk(self):
self.assertEqual(self.tree.walk(self.tree.root), [])
def test_traversal(mock_dfs):
mock_dfs.side_effect = dfs
root = Tree(1)
first_child = Tree(2)
root.add_child(first_child)
first_child.add_child(Tree(4))
root.add_child(Tree(3))
# Traversal order verified with print statements, since the function is
# only called once (no recursion).
assert mock_dfs(root, 4)
assert_equals(mock_dfs.call_count, 3)
def build_kth():
kth = Tree("kth2.sunet.se")
kth_intranet = Tree("a5ef-6c.kth.se")
for namn in ["red-12", "orange-5", "sport-3", "spel-15"]:
kth_intranet.add_child(Tree(namn))
kth_services = Tree("645ea5.kth.se")
for namn in ["webmail.kth.se", "smtp.kth.se", "www.kth.se"]:
kth_services.add_child(Tree(namn))
kth.add_child(kth_intranet)
kth.add_child(kth_services)
return kth
def build_internet():
global INTERNET
INTERNET = Tree("internet")
INTERNET.add_child(build_netnod())
INTERNET.add_child(build_verisign())
sw_chain = [
"Episode.IV.A.NEW.HOPE.75eyjm.net",
"It.is.a.period.of.civil.war.75eyjm.net",
"Rebel.spaceships.striking.from.75eyjm.net",
"a.hidden.base.have.won.their.first.75eyjm.net",
"victory.against.the.evil.Galactic.Empire.75eyjm.net"
]
sw_top = Tree(sw_chain[0])
prev = sw_top
for curr in sw_chain[1:]:
curr = Tree(curr)
prev.add_child(curr)
prev = curr
INTERNET.add_child(sw_top)
def maketree(lt):
stack = []
tree = Tree('html')
for token in lt:
if "<" in token and ("</" not in token or "/>" in token):
tag = token.split(" ", 1)[0].replace("<", "")
tag = tag.replace(">", "")
new_node = Tree(token)
tree.add_child(new_node)
if tag not in SINGLE_TAGS:
tree = new_node
stack.append(tag)
elif "</" in token:
tag = token.split(" ", 1)[0].replace("<", "")
tag = tag.replace(">", "").replace("/", "")
results = [i for i, x in enumerate(stack) if x == tag]
if len(results) != 0:
pos = results[-1]
del stack[pos]
tree = tree.parent
elif "/>" in token:
new_node = Tree(token)
tree.add_child(new_node)
else:
stack.append(token)
new_node = Tree(token)
tree.add_child(new_node)
while tree.parent is not None:
tree = tree.parent
return tree
def inverse_kinematics(x,y,z,alpha,beta,gamma,**frame_file):
angles = {}
frames = []
pos = [x,y,z]
filename = frame_file.pop('input', 'serial_manipulator_6.json')
with open(filename) as input:
data = json.load(input)
dof = data.pop('dof',6) #6 dof by default
frames_prototype = data['frames']
if not frames_prototype:
raise Exception('No frames in file')
convention = data.pop('convention','xyz')
for prototype in frames_prototype:
frames.append(Frame(prototype['displacement'],prototype['previous_relation']))
T = Axis.invert_zyz(alpha,beta,gamma)
T[0].append(x)
T[1].append(y)
T[2].append(z)
T.append([0,0,0,1])
result = Tree(0)
#compute teta1
result.add_child('teta1_a',atan2( -pos[0],pos[1] ))
result.add_child('teta1_b',atan2( pos[0],-pos[1] ))
#compute teta2,teta3
#rotate plane around z to zy for each teta1
for branch, teta1 in result.childs.items():
ang = teta1.value
p = [pos]
#rotate plane to zy
np = Utils.multiply_matrix(p,[[cos(ang),-sin(ang),0],
[sin(ang), cos(ang), 0],
[0, 0, 1]])
new_p = [np[0][0],np[0][1],np[0][2] - 99]
#we got a plane
p_mag = Utils.magnitude(new_p)
#intersect circunference with radius c centered in new_p
#with one centered in [0,99] (due to the displacement from frame 1 to frame 2 )
#and with radius of 120
c = 155
p2 = Utils.intersect_circunference(new_p[1],new_p[2],c,0,0,120)
teta2_a = atan2(-p2[0][0],p2[0][1])
teta2_b = atan2(-p2[1][0],p2[1][1])
teta1.add_child('teta2_a',teta2_a)
teta1.add_child('teta2_b',teta2_b)
i = 0
for branch2, teta2 in teta1.childs.items():
p2_mag = Utils.magnitude(p2[i])
cosalpha = -(p_mag**2 - c**2 - p2_mag**2) / (2*c*p2_mag)
alpha = acos(cosalpha)
if i == 0:
teta3 = alpha - pi/2
else:
teta3 = alpha + pi/2 -2 *pi
t3_branch = teta2.add_child('teta3',teta3)
i+=1
frames[0].rotate_joint_z(teta1.value)
frames[1].rotate_joint_z(teta2.value)
frames[2].rotate_joint_z(teta3)
T03 = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]
for frame in frames[0:3]:
T03 = Utils.multiply_matrix(T03,frame.position_m)
T30 = Utils.inv_4x4_matrix(T03)
T36 = Utils.multiply_matrix(T30,T)
costeta5 = T36[1][2]
#two possible teta5 values
teta5 = [0,0]
teta5[0] = acos(costeta5)
teta5[1]= -teta5[0]
enum = ['a','b']
j = 0
for t5 in teta5:
if round(sin(t5),4) == 0:
t3_branch.add_child('error','Configuration singularity sin(teta5) = 0')
continue
else:
sinTeta6 = round(- T36[1][1] / sin(t5),4)
cosTeta6 = round(T36[1][0] / sin(t5),4)
cosTeta4 = round(- T36[0][2] / sin(t5),4)
sinTeta4 = round(- T36[2][2] / sin(t5),4)
teta4 = acos(cosTeta4)
if sinTeta4 < 0:
teta4 = - teta4
teta6 = acos(cosTeta6)
if sinTeta6 < 0 :
teta6 = - teta6
t4_branch = t3_branch.add_child('teta4' + enum[j],teta4)
t5_branch = t4_branch.add_child('teta5',t5)
t5_branch.add_child('teta6',teta6)
j+=1
return result
def fib(n):
# replace the pass statement with your code
pass
def find_root_sqrt2(epsilon, a, b):
# replace the pass statement with your code
pass
t0 = Tree("node0", 27)
t1 = Tree("node0", 1)
t1.add_child(Tree("node1", 2, children=[Tree("node2", 3)]))
t1.add_child(Tree("node3", 4))
t1.add_child(Tree("node4", 5))
def count_leaves(t):
'''
Count the number of leaves in the tree rooted at t
Inputs: (Tree) a tree
Returns: (integer) number of leaves in t
'''
assert t is not None
if t.num_children() == 0:
def create_tree(self,
current_x,
current_y,
current_feature_list,
impurity_measure,
parent_node=None):
"""
A recursive method for generating decision-tree, using the ID3 algorithm.
:param current_x: list, available dataset
:param current_y: list, aavailable dataset labels
:param current_feature_list: list, available features
:param impurity_measure: string, impurity measure to generate tree
:param parent_node: Tree, parent tree for this iteration.
:return: Tree, A decision tree
"""
if np.unique(current_y).size == 1: # If pure subset, add leaf
return Tree(label=np.unique(current_y)[0], parent=parent_node)
if current_feature_list.size == 0 or len(
np.unique(current_x)
) == 1: # If impure subset and not able to split any further, or all x_elem equal
label_list, label_count = np.unique(current_y, return_counts=True)
max_label = label_list[np.argmax(label_count)]
return Tree(label=max_label, parent=parent_node)
if impurity_measure == "entropy":
calc_function = self.entropy
elif impurity_measure == "gini":
calc_function = self.gini_index
else:
raise Exception("Unknown impurity measure")
feature_gains = [
self.information_gain(current_x, current_y, feature, calc_function)
for feature in current_feature_list
]
max_index = feature_gains.index(max(feature_gains))
best_feature = current_feature_list[max_index]
if current_feature_list.size == 1:
current_feature_list = np.array([])
else:
current_feature_list = np.delete(current_feature_list, max_index)
parent = Tree(feature_split=best_feature, parent=parent_node)
child_labels = []
for branch_option in np.unique(current_x[:, best_feature]):
child_x = [
entry for entry in current_x
if entry[best_feature] == branch_option
]
child_y = [
current_y[ind] for ind, entry in enumerate(current_x)
if entry[best_feature] == branch_option
]
child_x = np.array(child_x)
child_y = np.array(child_y)
if child_y.size > 0:
child = self.create_tree(child_x, child_y,
current_feature_list,
impurity_measure, parent)
child.choice = branch_option
parent.add_child(child)
child_labels.append(child.label)
labels, counts = np.unique(child_labels, return_counts=True)
most_common_label = labels[np.argmax(counts)]
parent.label = most_common_label
return parent
class FCMdata(object):
"""
Object representing flow cytometry data
FCMdata.pnts : a numpy array of data points
FCMdata.channels : a list of which markers/scatters are on which column of
the array.
FCMdata.scatters : a list of which indexes in fcmdata.channels are scatters
"""
def __init__(self, name, pnts, channels, scatters=None, notes=None):
"""
fcmdata(name, pnts, channels, scatters=None)
name: name of corresponding FCS file minus extension
pnts: array of data points
channels: a list of which markers/scatters are on which column of
the array.
scatters: a list of which indexes in channels are scatters
"""
self.name = name
self.tree = Tree(pnts, channels)
#TODO add some default intelligence for determining scatters if None
self.scatters = scatters
self.markers = []
if self.scatters is not None:
for chan in range(len(channels)):
if chan in self.scatters:
pass
elif self.tree.root.channels[chan] in self.scatters:
pass
else:
self.markers.append(chan)
if notes == None:
notes = Annotation()
self.notes = notes
def __unicode__(self):
return self.name
def __repr__(self):
return self.name
def _lookup_item(self, item):
if isinstance(item, tuple):
item = list(item) # convert to be mutable.
if isinstance(item[1], basestring):
item[1] = self.name_to_index(item[1])
elif isinstance(item[1], tuple) or isinstance(item[1], list):
item[1] = list(item[1]) # convert to be mutable.
for i, j in enumerate(item[1]):
if isinstance(j, basestring):
item[1][i] = self.name_to_index(j)
item = tuple(item)
return item
def __getitem__(self, item):
"""return FCMdata points"""
item = self._lookup_item(item)
return self.tree.view()[item]
def __setitem__(self, key, value):
item = self._lookup_item(key)
self.tree.view()[item] = value
@property
def channels(self):
return [i for i in self.current_node.channels]
def __len__(self):
return self.current_node.view().__len__()
def __getattr__(self, name):
if name in dir(self.current_node.view()):
#return Node.__getattribute__(self.current_node,'view')().__getattribute__(name)
return self.current_node.view().__getattribute__(name)
else:
raise AttributeError("'%s' has no attribue '%s'" %
(str(self.__class__), name))
def __getstate__(self):
return self.__dict__
def __setstate__(self, dict):
for i in dict.keys():
self.__dict__[i] = dict[i]
def name_to_index(self, channels):
"""Return the channel indexes for the named channels"""
if isinstance(channels, basestring):
try:
if channels in self.channels:
return self.channels.index(channels)
else:
raise ValueError('%s is not in list' % channels)
except ValueError:
for j in range(1, int(self.notes.text['par']) + 1):
if channels == self.notes.text['p%dn' % j]:
return self.channels.index(self.notes.text['p%ds' % j])
raise ValueError('%s is not in list' % channels)
idx = []
for i in channels:
if i in self.channels:
idx.append(self.channels.index(i))
else:
raise ValueError('%s is not in list' % channels)
if idx:
return idx
else:
raise ValueError('field named a not found: %s' % str(channels))
def get_channel_by_name(self, channels):
"""Return the data associated with specific channel names"""
return self.tree.view()[:, self.name_to_index(channels)]
def get_markers(self):
"""return the data associated with all the markers"""
return self.view()[:, self.markers]
def get_spill(self):
"""return the spillover matrix from the original fcs used in compisating"""
try:
return self.notes.text['spill']
except KeyError:
return None
def view(self):
"""return the current view of the data"""
return self.tree.view()
def visit(self, name):
"""Switch current view of the data"""
self.tree.visit(name)
@property
def current_node(self):
"""return the current node"""
return self.tree.current
def copy(self):
"""return a copy of fcm data object"""
tname = self.name
tpnts = self.tree.root.data
tnotes = self.notes.copy()
tchannels = self.channels[:]
tscchannels = self.scatters[:]
tmp = FCMdata(tname, tpnts, tchannels, tscchannels, tnotes)
from copy import deepcopy
tmp.tree = deepcopy(self.tree)
return tmp
def logicle(self,
channels=None,
T=262144,
m=4.5,
r=None,
w=0.5,
a=0,
scale_max=1e5,
scale_min=0,
rquant=None):
"""return logicle transformed channels"""
if channels is None:
channels = self.markers
return _logicle(self, channels, T, m, r, scale_max, scale_min, w, a,
rquant)
def hyperlog(self, channels, b, d, r, order=2, intervals=1000.0):
"""return hyperlog transformed channels"""
return _hyperlog(self, channels, b, d, r, order, intervals)
def log(self, channels=None):
"""return log base 10 transformed channels"""
if channels is None:
channels = self.markers
return _log(self, channels)
def gate(self, g, chan=None):
"""return gated region of fcm data"""
return g.gate(self, chan)
def subsample(self, s, model='random', *args, **kwargs):
"""return subsampled/sliced fcm data"""
if isinstance(s, Subsample):
return s.subsample(self)
elif isinstance(s, slice):
r = Subsample(s)
return r.subsample(self)
else:
if model == 'random':
r = RandomSubsample(s)
elif model == 'anomaly':
r = AnomalySubsample(s, *args, **kwargs)
elif model == 'bias':
r = BiasSubsample(s, *args, **kwargs)
return r.subsample(self, *args, **kwargs)
def compensate(self, sidx=None, spill=None):
"""Compensate the fcm data"""
compensate(self, S=spill, markers=sidx)
return self
def get_cur_node(self):
""" get current node """
return self.current_node
def add_view(self, node):
"""add a new node to the view tree"""
self.tree.add_child(node.name, node)
return self
def summary(self):
"""returns summary of current view"""
pnts = self.view()
means = pnts.mean(0)
stds = pnts.std(0)
mins = pnts.min(0)
maxs = pnts.max(0)
medians = median(pnts, 0)
dim = pnts.shape[1]
summary = ''
for i in range(dim):
summary = summary + self.channels[i] + ":\n"
summary = summary + " max: " + str(maxs[i]) + "\n"
summary = summary + " mean: " + str(means[i]) + "\n"
summary = summary + " median: " + str(medians[i]) + "\n"
summary = summary + " min: " + str(mins[i]) + "\n"
summary = summary + " std: " + str(stds[i]) + "\n"
return summary
def boundary_events(self):
"""returns dictionary of fraction of events in first and last
channel for each channel"""
boundary_dict = {}
for k, chan in enumerate(self.channels):
col = self.view()[:, k]
boundary_dict[chan] = \
sum((col == min(col)) | (col == max(col))) / len(col)
return boundary_dict
def export(self, file_name):
"""
export out current view to a fcs file
"""
from fcm.io import export_fcs
export_fcs(file_name, self.view(), self.current_node.channels,
self.notes.text)
def extract_channels(self, channels, keep=False):
"""
create a view without the specified channels or with if keep==True
"""
if isinstance(channels, basestring) or isinstance(channels, int):
channels = [channels]
for i, j in enumerate(channels):
if isinstance(j, str):
channels[i] = self.name_to_index(j)
if keep:
channels = [
i for i in range(len(self.channels)) if i not in channels
]
d = DropChannel(channels)
d.drop(self)
return self
def add_channel(self, name, channel=None):
if channel is None:
channel = zeros((self.shape[0], 1))
print channel.shape
node = AddChannel(channel, name)
node.add(self)
return self
class FCMdata(object):
"""
Object representing flow cytometry data
FCMdata.pnts : a numpy array of data points
FCMdata.channels : a list of which markers/scatters are on which column of
the array.
FCMdata.scatters : a list of which indexes in fcmdata.channels are scatters
"""
def __init__(self, name, pnts, channels, scatters=None, notes=None):
"""
fcmdata(name, pnts, channels, scatters=None)
name: name of corresponding FCS file minus extension
pnts: array of data points
channels: a list of which markers/scatters are on which column of
the array.
scatters: a list of which indexes in channels are scatters
"""
self.name = name
self.tree = Tree(pnts, channels)
#TODO add some default intelligence for determining scatters if None
self.scatters = scatters
self.markers = []
if self.scatters is not None:
for chan in range(len(channels)):
if chan in self.scatters:
pass
elif self.tree.root.channels[chan] in self.scatters:
pass
else:
self.markers.append(chan)
if notes == None:
notes = Annotation()
self.notes = notes
def __unicode__(self):
return self.name
def __repr__(self):
return self.name
def _lookup_item(self,item):
if isinstance(item, tuple):
item = list(item) # convert to be mutable.
if isinstance(item[1], basestring):
item[1] = self.name_to_index(item[1])
elif isinstance(item[1], tuple) or isinstance(item[1], list):
item[1] = list(item[1])# convert to be mutable.
for i, j in enumerate(item[1]):
if isinstance(j, basestring):
item[1][i] = self.name_to_index(j)
item = tuple(item)
return item
def __getitem__(self, item):
"""return FCMdata points"""
item = self._lookup_item(item)
return self.tree.view()[item]
def __setitem__(self,key,value):
item = self._lookup_item(key)
self.tree.view()[item] = value
@property
def channels(self):
return [i for i in self.current_node.channels]
def __len__(self):
return self.current_node.view().__len__()
def __getattr__(self, name):
if name in dir(self.current_node.view()):
#return Node.__getattribute__(self.current_node,'view')().__getattribute__(name)
return self.current_node.view().__getattribute__(name)
else:
raise AttributeError("'%s' has no attribue '%s'" % (str(self.__class__), name))
def __getstate__(self):
return self.__dict__
def __setstate__(self, dict):
for i in dict.keys():
self.__dict__[i] = dict[i]
def name_to_index(self, channels):
"""Return the channel indexes for the named channels"""
if isinstance(channels, basestring):
try:
if channels in self.channels:
return self.channels.index(channels)
else:
raise ValueError('%s is not in list' % channels)
except ValueError:
for j in range(1, int(self.notes.text['par']) + 1):
if channels == self.notes.text['p%dn' % j]:
return self.channels.index(self.notes.text['p%ds' % j])
raise ValueError('%s is not in list' % channels)
idx = []
for i in channels:
if i in self.channels:
idx.append(self.channels.index(i))
else:
raise ValueError('%s is not in list' % channels)
if idx:
return idx
else:
raise ValueError('field named a not found: %s' % str(channels))
def get_channel_by_name(self, channels):
"""Return the data associated with specific channel names"""
return self.tree.view()[:, self.name_to_index(channels)]
def get_markers(self):
"""return the data associated with all the markers"""
return self.view()[:, self.markers]
def get_spill(self):
"""return the spillover matrix from the original fcs used in compisating"""
try:
return self.notes.text['spill']
except KeyError:
return None
def view(self):
"""return the current view of the data"""
return self.tree.view()
def visit(self, name):
"""Switch current view of the data"""
self.tree.visit(name)
@property
def current_node(self):
"""return the current node"""
return self.tree.current
def copy(self):
"""return a copy of fcm data object"""
tname = self.name
tpnts = self.tree.root.data
tnotes = self.notes.copy()
tchannels = self.channels[:]
tscchannels = self.scatters[:]
tmp = FCMdata(tname, tpnts, tchannels, tscchannels, tnotes)
from copy import deepcopy
tmp.tree = deepcopy(self.tree)
return tmp
def logicle(self, channels=None, T=262144, m=4.5, r=None, w=0.5, a=0, scale_max=1e5, scale_min=0, rquant=None):
"""return logicle transformed channels"""
if channels is None:
channels = self.markers
return _logicle(self, channels, T, m, r, scale_max, scale_min, w, a, rquant)
def hyperlog(self, channels, b, d, r, order=2, intervals=1000.0):
"""return hyperlog transformed channels"""
return _hyperlog(self, channels, b, d, r, order, intervals)
def log(self, channels=None):
"""return log base 10 transformed channels"""
if channels is None:
channels = self.markers
return _log(self, channels)
def gate(self, g, chan=None):
"""return gated region of fcm data"""
return g.gate(self, chan)
def subsample(self, s, model='random', *args, **kwargs):
"""return subsampled/sliced fcm data"""
if isinstance(s, Subsample):
return s.subsample(self)
elif isinstance(s, slice):
r = Subsample(s)
return r.subsample(self)
else:
if model == 'random':
r = RandomSubsample(s)
elif model == 'anomaly':
r = AnomalySubsample(s, *args, **kwargs)
elif model == 'bias':
r = BiasSubsample(s, *args, **kwargs)
return r.subsample(self, *args, **kwargs)
def compensate(self, sidx=None, spill=None):
"""Compensate the fcm data"""
compensate(self, S=spill, markers=sidx)
return self
def get_cur_node(self):
""" get current node """
return self.current_node
def add_view(self, node):
"""add a new node to the view tree"""
self.tree.add_child(node.name, node)
return self
def summary(self):
"""returns summary of current view"""
pnts = self.view()
means = pnts.mean(0)
stds = pnts.std(0)
mins = pnts.min(0)
maxs = pnts.max(0)
medians = median(pnts, 0)
dim = pnts.shape[1]
summary = ''
for i in range(dim):
summary = summary + self.channels[i] + ":\n"
summary = summary + " max: " + str(maxs[i]) + "\n"
summary = summary + " mean: " + str(means[i]) + "\n"
summary = summary + " median: " + str(medians[i]) + "\n"
summary = summary + " min: " + str(mins[i]) + "\n"
summary = summary + " std: " + str(stds[i]) + "\n"
return summary
def boundary_events(self):
"""returns dictionary of fraction of events in first and last
channel for each channel"""
boundary_dict = {}
for k, chan in enumerate(self.channels):
col = self.view()[:, k]
boundary_dict[chan] = \
sum((col == min(col)) | (col == max(col))) / len(col)
return boundary_dict
def export(self, file_name):
"""
export out current view to a fcs file
"""
from fcm.io import export_fcs
export_fcs(file_name, self.view(), self.current_node.channels, self.notes.text)
def extract_channels(self, channels, keep=False):
"""
create a view without the specified channels or with if keep==True
"""
if isinstance(channels, basestring) or isinstance(channels, int):
channels = [channels]
for i, j in enumerate(channels):
if isinstance(j, str):
channels[i] = self.name_to_index(j)
if keep:
channels = [ i for i in range(len(self.channels)) if i not in channels]
d = DropChannel(channels)
d.drop(self)
return self
def add_channel(self, name, channel=None):
if channel is None:
channel = zeros((self.shape[0],1))
print channel.shape
node = AddChannel(channel, name)
node.add(self)
return self
def test_non_first_child():
root = Tree(6)
root.add_child(Tree(2))
root.add_child(Tree(1))
assert dfs(root, 1)
def build_netnod():
netnod = Tree("62ef-425.netnod.com")
netnod.add_child(build_pyttemjuk())
netnod.add_child(build_sunet())
netnod.add_child(build_telenor())
return netnod
def build_telenor():
telenor = Tree("a8f.9.telenor.se")
# smallbandsbolaget
sbbolaget = Tree("cce76-top.smalbandsbolaget.se")
sb_sthlm = Tree("ns.645-52-stockholm.smalbandsbolaget.se")
sbbolaget.add_child(sb_sthlm)
for n in [ "Lisas router", "Familjen Larsson"]:
sb_sthlm.add_child(Tree(n))
telenor.add_child(sbbolaget)
# Judiths nät
judith = Tree("58.5-ce6.judith-och-judith.se")
judith_sth = Tree("a-8ed.sth-63.judith-och-judith.se")
judith.add_child(judith_sth)
for n in ["dlink-653C", "Kalle hem"]:
judith_sth.add_child(Tree(n))
telenor.add_child(judith)
return telenor
def test_add_child_returns_appended_node_instance():
t = Tree("a")
new_node = t.add_child("b")
assert_that(new_node, equal_to(t.children[0]))
def test2():
tree1 = Tree([1, 2, 3])
tree1.add_child([4, 5, 6], tree1.root)
tree2 = deepcopy(tree1)
tree2.root.data[1] = 20000
return tree1, tree2
def test_single_child():
root = Tree(6)
root.add_child(Tree(2))
assert dfs(root, 2)
def test_not_in_tree():
root = Tree(6)
root.add_child(Tree(2))
assert not dfs(root, 1)
class FCMdata(object):
"""
Object representing flow cytometry data
FCMdata.pnts : a numpy array of data points
FCMdata.channels : a list of which markers/scatters are on which column of
the array.
FCMdata.scatters : a list of which indexes in fcmdata.channels are scatters
"""
def __init__(self, name, pnts, channels, scatters=None, notes=None):
"""
fcmdata(name, pnts, channels, scatters=None)
name: name of corresponding FCS file minus extension
pnts: array of data points
channels: a list of which markers/scatters are on which column of
the array.
scatters: a list of which indexes in channels are scatters
"""
self.name = name
# if type(pnts) != type(array([])):
# raise BadFCMPointDataTypeError(pnts, "pnts isn't a numpy.array")
self.tree = Tree(pnts, channels)
#self.pnts = pnts
#self.channels = channels
#TODO add some default intelegence for determining scatters if None
self.scatters = scatters
self.markers = []
if self.scatters is not None:
for chan in range(len(channels)):
if chan in self.scatters:
pass
elif self.tree.root.channels[chan] in self.scatters:
pass
else:
self.markers.append(chan)
if notes == None:
notes = Annotation()
self.notes = notes
def __unicode__(self):
return self.name
def __repr__(self):
return self.name
def __getitem__(self, item):
"""return FCMdata points"""
if isinstance(item, tuple):
item = list(item) # convert to be mutable.
if isinstance(item[1], str):
item[1] = self.name_to_index(item[1])
elif isinstance(item[1], tuple) or isinstance(item[1], list):
item[1] = list(item[1]) # convert to be mutable.
for i, j in enumerate(item[1]):
if isinstance(j, str):
print i, 'is string', j
item[1][i] = self.name_to_index(j)
item = tuple(item)
return self.tree.view()[item]
@property
def channels(self):
return self.current_node.channels
def __getattr__(self, name):
if name in dir(self.current_node.view()):
#return Node.__getattribute__(self.current_node,'view')().__getattribute__(name)
return self.current_node.view().__getattribute__(name)
else:
raise AttributeError("'%s' has no attribue '%s'" %
(str(self.__class__), name))
def __getstate__(self):
# tmp = {}
# tmp['name'] = self.name
# tmp['tree'] = self.tree
# tmp['markers'] = self.markers
# tmp['scatters'] = self.scatters
# tmp['notes'] = self.notes
# return tmp
return self.__dict__
def __setstate__(self, dict):
for i in dict.keys():
self.__dict__[i] = dict[i]
def name_to_index(self, channels):
"""Return the channel indexes for the named channels"""
if isinstance(channels, str):
return self.channels.index(channels)
idx = []
for i in channels:
try:
idx.append(self.channels.index(i))
except ValueError:
try:
for j in range(1, int(self.notes.text['par']) + 1):
if i == self.notes.text['p%dn' % j]:
idx.append(
self.channels.index(self.notes.text['p%ds' %
j]))
except ValueError:
raise ValueError('%s is not in list' % i)
if idx:
return idx
else:
raise ValueError('field named a not found: %s' % str(channels))
def get_channel_by_name(self, channels):
"""Return the data associated with specific channel names"""
return self.tree.view()[:, self.name_to_index(channels)]
def get_markers(self):
"""return the data associated with all the markers"""
return self.view()[:, self.markers]
def get_spill(self):
"""return the spillover matrix from the original fcs used in compisating"""
try:
return self.notes.text['spill']
except KeyError:
return None
def view(self):
"""return the current view of the data"""
return self.tree.view()
def visit(self, name):
"""Switch current view of the data"""
self.tree.visit(name)
@property
def current_node(self):
"""return the current node"""
return self.tree.current
def copy(self):
"""return a copy of fcm data object"""
tname = self.name
tpnts = self.tree.root.data
tnotes = self.notes.copy()
tchannels = self.channels[:]
tscchannels = self.scatters[:]
tmp = FCMdata(tname, tpnts, tchannels, tscchannels, tnotes)
from copy import deepcopy
tmp.tree = deepcopy(self.tree)
return tmp
def logicle(self,
channels=None,
T=262144,
m=4.5,
r=None,
scale_max=1e5,
scale_min=0):
"""return logicle transformed channels"""
if channels is None:
channels = self.markers
return _logicle(self, channels, T, m, r, scale_max, scale_min)
def hyperlog(self, channels, b, d, r, order=2, intervals=1000.0):
"""return hyperlog transformed channels"""
return _hyperlog(self, channels, b, d, r, order, intervals)
def log(self, channels=None):
"""return log base 10 transformed channels"""
if channels is None:
channels = self.markers
return _log(self, channels)
def gate(self, g, chan=None):
"""return gated region of fcm data"""
return g.gate(self, chan)
def subsample(self, s):
"""return subsampled/sliced fcm data"""
return s.subsample(self)
def compensate(self, sidx=None, spill=None):
'''Compensate the fcm data'''
compensate(self, S=spill, markers=sidx)
return self
def get_cur_node(self):
""" get current node """
return self.current_node
def add_view(self, node):
"""add a new node to the view tree"""
self.tree.add_child(node.name, node)
return self
def summary(self):
"""returns summary of current view"""
pnts = self.view()
means = pnts.mean(0)
stds = pnts.std(0)
mins = pnts.min(0)
maxs = pnts.max(0)
medians = median(pnts, 0)
dim = pnts.shape[1]
summary = ''
for i in range(dim):
summary = summary + self.channels[i] + ":\n"
summary = summary + " max: " + str(maxs[i]) + "\n"
summary = summary + " mean: " + str(means[i]) + "\n"
summary = summary + " median: " + str(medians[i]) + "\n"
summary = summary + " min: " + str(mins[i]) + "\n"
summary = summary + " std: " + str(stds[i]) + "\n"
return summary
def boundary_events(self):
"""returns dictionary of fraction of events in first and last
channel for each channel"""
boundary_dict = {}
for k, chan in enumerate(self.channels):
col = self.view()[:, k]
boundary_dict[chan] = \
sum((col == min(col)) | (col == max(col))) / len(col)
return boundary_dict
def export(self, file_name):
'''
export out current view to a fcs file
'''
from fcm.io import export_fcs
export_fcs(file_name, self.view(), self.channels, self.notes.text)
