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 _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 _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_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 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 _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_order(self): post = hier.postorder(self.cluster) pre = hier.preorder(self.cluster)