def test_prunning(self):
pruned1 = hier.pruned(self.cluster, level=2)
depths = hier.cluster_depths(pruned1)
self.assertTrue(all(d <= 2 for d in depths.values()))
pruned2 = hier.pruned(self.cluster, height=10)
self.assertTrue(c.height >= 10 for c in hier.preorder(pruned2))
pruned3 = hier.pruned(self.cluster, condition=lambda cl: len(cl) <= 3)
self.assertTrue(len(c) > 3 for c in hier.preorder(pruned3))
def test_prunning(self):
pruned1 = hier.pruned(self.cluster, level=2)
depths = hier.cluster_depths(pruned1)
self.assertTrue(all(d <= 2 for d in depths.values()))
pruned2 = hier.pruned(self.cluster, height=10)
self.assertTrue(c.height >= 10 for c in hier.preorder(pruned2))
pruned3 = hier.pruned(self.cluster, condition=lambda cl: len(cl) <= 3)
self.assertTrue(len(c) > 3 for c in hier.preorder(pruned3))
def clusters_at_height(root_cluster, height):
""" Return a list of clusters by cutting the clustering at height.
"""
lower = set()
cluster_list = []
for cl in hierarchical.preorder(root_cluster):
if cl in lower:
continue
if cl.height < height:
cluster_list.append(cl)
lower.update(hierarchical.preorder(cl))
return cluster_list
def clusters_at_height(root, height):
"""Return a list of clusters by cutting the clustering at `height`.
"""
lower = set()
cluster_list = []
for cl in preorder(root):
if cl in lower:
continue
if cl.value.height < height:
cluster_list.append(cl)
lower.update(preorder(cl))
return cluster_list
def clusters_at_height(root, height):
"""Return a list of clusters by cutting the clustering at `height`.
"""
lower = set()
cluster_list = []
for cl in preorder(root):
if cl in lower:
continue
if cl.value.height < height:
cluster_list.append(cl)
lower.update(preorder(cl))
return cluster_list
def clusters_at_height(root_cluster, height):
""" Return a list of clusters by cutting the clustering at height.
"""
lower = set()
cluster_list = []
for cl in hierarchical.preorder(root_cluster):
if cl in lower:
continue
if cl.height < height:
cluster_list.append(cl)
lower.update(hierarchical.preorder(cl))
return cluster_list
def _selection_poly(self, item):
# type: (Tree) -> QPolygonF
"""
Return an selection geometry covering item and all its children.
"""
def left(item):
return [self._items[ch] for ch in item.node.branches[:1]]
def right(item):
return [self._items[ch] for ch in item.node.branches[-1:]]
itemsleft = list(preorder(item, left))[::-1]
itemsright = list(preorder(item, right))
# itemsleft + itemsright walks from the leftmost leaf up to the root
# and down to the rightmost leaf
assert itemsleft[0].node.is_leaf
assert itemsright[-1].node.is_leaf
if item.node.is_leaf:
# a single anchor point
vert = [itemsleft[0].element.anchor]
else:
vert = []
for it in itemsleft[1:]:
vert.extend([
it.element.path[0], it.element.path[1], it.element.anchor
])
for it in itemsright[:-1]:
vert.extend([
it.element.anchor, it.element.path[-2], it.element.path[-1]
])
# close the polygon
vert.append(vert[0])
def isclose(a, b, rel_tol=1e-6):
return abs(a - b) < rel_tol * max(abs(a), abs(b))
def isclose_p(p1, p2, rel_tol=1e-6):
return isclose(p1.x, p2.x, rel_tol) and \
isclose(p1.y, p2.y, rel_tol)
# merge consecutive vertices that are (too) close
acc = [vert[0]]
for v in vert[1:]:
if not isclose_p(v, acc[-1]):
acc.append(v)
vert = acc
return QPolygonF([QPointF(*p) for p in vert])
def test_prunning(self):
pruned = hierarchical.prune(self.cluster, level=2)
depths = hierarchical.cluster_depths(pruned)
self.assertTrue(all(d <= 2 for d in depths.values()))
pruned = hierarchical.prune(self.cluster, height=10)
self.assertTrue(c.height >= 10 for c in hierarchical.preorder(pruned))
def test_pre_post_order(self):
tree = hierarchical.Tree
root = tree("A", (tree("B"), tree("C")))
self.assertEqual([n.value for n in hierarchical.postorder(root)],
["B", "C", "A"])
self.assertEqual([n.value for n in hierarchical.preorder(root)],
["A", "B", "C"])
def test_prunning(self):
pruned = hierarchical.prune(self.cluster, level=2)
depths = hierarchical.cluster_depths(pruned)
self.assertTrue(all(d <= 2 for d in depths.values()))
pruned = hierarchical.prune(self.cluster, height=10)
self.assertTrue(c.height >= 10 for c in hierarchical.preorder(pruned))
def test_pre_post_order(self):
tree = hierarchical.Tree
root = tree("A", (tree("B"), tree("C")))
self.assertEqual([n.value for n in hierarchical.postorder(root)],
["B", "C", "A"])
self.assertEqual([n.value for n in hierarchical.preorder(root)],
["A", "B", "C"])
def _selected_super_item(self, item):
""" Return the selected super item if it exists
"""
for selected_item in self.selected_items:
if item in hierarchical.preorder(selected_item):
return selected_item
return None
def _selected_super_item(self, item):
""" Return the selected super item if it exists
"""
for selected_item in self.selected_items:
if item in hierarchical.preorder(selected_item):
return selected_item
return None
def _selected_sub_items(self, item):
""" Return all selected subclusters under item.
"""
res = []
for item in hierarchical.preorder(item)[1:]:
if item in self.selected_items:
res.append(item)
return res
def set_highlight(self, state):
""" Set highlight state for this item. Highlighted items are drawn
with a wider pen.
"""
for cl in hierarchical.preorder(self):
cl._highlight = state
cl.update()
def _selected_sub_items(self, item):
""" Return all selected subclusters under item.
"""
res = []
for item in hierarchical.preorder(item)[1:]:
if item in self.selected_items:
res.append(item)
return res
def set_highlight(self, state):
""" Set highlight state for this item. Highlighted items are drawn
with a wider pen.
"""
for cl in hierarchical.preorder(self):
cl._highlight = state
cl.update()
def _selected_super_item(self, item):
"""Return the selected super item if it exists."""
def branches(item):
return [self._items[ch] for ch in item.node.branches]
for selected_item in self._selection:
if item in set(preorder(selected_item, branches)):
return selected_item
return None
def _selected_super_item(self, item):
"""Return the selected super item if it exists."""
def branches(item):
return [self._items[ch] for ch in item.node.branches]
for selected_item in self._selection:
if item in set(preorder(selected_item, branches)):
return selected_item
return None
def _selected_sub_items(self, item):
"""Return all selected subclusters under item."""
def branches(item):
return [self._items[ch] for ch in item.node.branches]
res = []
for item in list(preorder(item, branches))[1:]:
if item in self._selection:
res.append(item)
return res
def _selected_sub_items(self, item):
"""Return all selected subclusters under item."""
def branches(item):
return [self._items[ch] for ch in item.node.branches]
res = []
for item in list(preorder(item, branches))[1:]:
if item in self._selection:
res.append(item)
return res
def on_depth_change(self):
if self.root_cluster and self.dendrogram.widget:
selected = self.dendrogram.widget.selected_clusters()
selected = set([(c.first, c.last) for c in selected])
root = self.root_cluster
if self.PrintDepthCheck:
root = hierarchical.pruned(root, level=self.PrintDepth)
self.display_tree1(root)
selected = [c for c in hierarchical.preorder(root) if (c.first, c.last) in selected]
self.dendrogram.widget.set_selected_clusters(selected)
def on_depth_change(self):
if self.root_cluster and self.dendrogram.widget:
selected = self.dendrogram.widget.selected_clusters()
selected = set([(c.first, c.last) for c in selected])
root = self.root_cluster
if self.PrintDepthCheck:
root = hierarchical.pruned(root, level=self.PrintDepth)
self.display_tree1(root)
selected = [c for c in hierarchical.preorder(root)
if (c.first, c.last) in selected]
self.dendrogram.widget.set_selected_clusters(selected)
def _selection_poly(self, item):
"""Return an selection item covering the selection rooted at item.
"""
def branches(item):
return [self._items[ch] for ch in item.node.branches]
def left(item):
return [self._items[ch] for ch in item.node.branches[:1]]
def right(item):
return [self._items[ch] for ch in item.node.branches[-1:]]
allitems = list(preorder(item, left)) + list(preorder(item, right))[1:]
if len(allitems) == 1:
assert (allitems[0].node.is_leaf)
else:
allitems = [item for item in allitems if not item.node.is_leaf]
brects = [QPolygonF(item.boundingRect()) for item in allitems]
return reduce(QPolygonF.united, brects, QPolygonF())
def _selection_poly(self, item):
"""Return an selection item covering the selection rooted at item.
"""
def branches(item):
return [self._items[ch] for ch in item.node.branches]
def left(item):
return [self._items[ch] for ch in item.node.branches[:1]]
def right(item):
return [self._items[ch] for ch in item.node.branches[-1:]]
allitems = list(preorder(item, left)) + list(preorder(item, right))[1:]
if len(allitems) == 1:
assert(allitems[0].node.is_leaf)
else:
allitems = [item for item in allitems if not item.node.is_leaf]
brects = [QPolygonF(item.boundingRect()) for item in allitems]
return reduce(QPolygonF.united, brects, QPolygonF())
def test_order(self):
post = list(hierarchical.postorder(self.cluster))
seen = set()
for n in post:
self.assertTrue(all(ch in seen for ch in n.branches))
seen.add(n)
pre = list(hierarchical.preorder(self.cluster))
seen = set()
for n in pre:
self.assertTrue(all(ch not in seen for ch in n.branches))
seen.add(n)
def test_order(self):
post = list(hierarchical.postorder(self.cluster))
seen = set()
for n in post:
self.assertTrue(all(ch in seen for ch in n.branches))
seen.add(n)
pre = list(hierarchical.preorder(self.cluster))
seen = set()
for n in pre:
self.assertTrue(all(ch not in seen for ch in n.branches))
seen.add(n)
def _invalidate_pruning(self):
if self.root:
selection = self.dendrogram.selected_nodes()
ranges = [node.value.range for node in selection]
if self.pruning:
self._set_displayed_root(prune(self.root, level=self.max_depth))
else:
self._set_displayed_root(self.root)
selected = [node for node in preorder(self._displayed_root) if node.value.range in ranges]
self.dendrogram.set_selected_clusters(selected)
self._apply_selection()
def _invalidate_pruning(self):
if self.root:
selection = self.dendrogram.selected_nodes()
ranges = [node.value.range for node in selection]
if self.pruning:
self._set_displayed_root(
prune(self.root, level=self.max_depth))
else:
self._set_displayed_root(self.root)
selected = [node for node in preorder(self._displayed_root)
if node.value.range in ranges]
self.dendrogram.set_selected_clusters(selected)
self._apply_selection()
def test_prunning(self):
pruned = hierarchical.prune(self.cluster, level=2)
depths = hierarchical.cluster_depths(pruned)
self.assertTrue(all(d <= 2 for d in depths.values()))
pruned = hierarchical.prune(self.cluster, height=10)
self.assertTrue(c.height >= 10 for c in hierarchical.preorder(pruned))
top = hierarchical.top_clusters(self.cluster, 3)
self.assertEqual(len(top), 3)
top = hierarchical.top_clusters(self.cluster, len(self.matrix))
self.assertEqual(len(top), len(self.matrix))
self.assertTrue(all(n.is_leaf for n in top))
top1 = hierarchical.top_clusters(self.cluster, len(self.matrix) + 1)
self.assertEqual(top1, top)
def test_prunning(self):
pruned = hierarchical.prune(self.cluster, level=2)
depths = hierarchical.cluster_depths(pruned)
self.assertTrue(all(d <= 2 for d in depths.values()))
pruned = hierarchical.prune(self.cluster, height=10)
self.assertTrue(c.height >= 10 for c in hierarchical.preorder(pruned))
top = hierarchical.top_clusters(self.cluster, 3)
self.assertEqual(len(top), 3)
top = hierarchical.top_clusters(self.cluster, len(self.matrix))
self.assertEqual(len(top), len(self.matrix))
self.assertTrue(all(n.is_leaf for n in top))
top1 = hierarchical.top_clusters(self.cluster, len(self.matrix) + 1)
self.assertEqual(top1, top)
def test_order(self):
post = hier.postorder(self.cluster)
pre = hier.preorder(self.cluster)
def test_order(self):
post = hier.postorder(self.cluster)
pre = hier.preorder(self.cluster)
