def test_join_split_trees(self):
        eq_(len(self.mesh), 18)
        join = ct.join_split_tree(self.mesh, self.height_func)
        split = ct.join_split_tree(self.mesh, self.height_func, split=True)
        eq_(join.order(), split.order())
        eq_(sorted(join.nodes()), sorted(split.nodes()))
        eq_(sorted(ct.join_split_peak_pit_nodes(join)), [7, 8, 9, 10])
        eq_(sorted(ct.join_split_peak_pit_nodes(split)), [1, 2])
        eq_(sorted(ct.join_split_pass_nodes(join)), [4, 5, 6])
        eq_(sorted(ct.join_split_pass_nodes(split)), [3])

        compare_adj(join.adj, join_adj)
        compare_adj(split.adj, split_adj)

        if 0:
            import pylab as pl
            pl.ion()
            nx_join = join.to_networkx()
            _nx.draw_shell(nx_join)
            pl.title('join')
            pl.figure()
            nx_split = split.to_networkx()
            _nx.draw_shell(nx_split)
            pl.title('split')
            raw_input("enter to continue")
    def test_contour_tree(self):
        join = ct.join_split_tree(self.mesh, self.height_func)
        split = ct.join_split_tree(self.mesh, self.height_func, split=True)
        contour_tree = ct.contour_tree(self.mesh, self.height_func)
        crit_pts = ct.critical_points(contour_tree)
        eq_(sorted(crit_pts.peaks), sorted(ct.join_split_peak_pit_nodes(join)))
        eq_(sorted(crit_pts.pits), sorted(ct.join_split_peak_pit_nodes(split)))
        eq_(sorted(crit_pts.passes), sorted([3, 4, 5, 6]))

        if 0:
            import pylab as pl
            pl.ion()
            pl.figure()
            try:
                _nx.draw(contour_tree.to_networkx())
            except AttributeError:
                _nx.draw(contour_tree)
            raw_input("enter to continue")
 def _test_contour_tree_sparse(self):
     join, join_arcs = ct.join_split_tree_sparse(self.mesh, self.height_func)
     eq_(set(join_arcs.keys()), set(self.mesh.nodes()))
     split, split_arcs = ct.join_split_tree_sparse(self.mesh, self.height_func, split=True)
     eq_(set(split_arcs.keys()), set(self.mesh.nodes()))
     ct.rectify_join_split_trees(join, join_arcs, split, split_arcs, self.height_func)
     eq_(sorted(join.nodes()), sorted(split.nodes()))
     contour_tree, regions = ct.sparse_contour_tree(self.mesh, self.height_func)
     crit_pts = ct.critical_points(contour_tree)
     eq_(sorted(crit_pts.peaks), sorted(ct.join_split_peak_pit_nodes(join)))
     eq_(sorted(crit_pts.pits), sorted(ct.join_split_peak_pit_nodes(split)))
     eq_(sorted(crit_pts.passes), sorted([3, 4, 5, 6]))
     if 0:
         import pylab as pl
         pl.ion()
         nx_join = join.to_nx()
         _nx.draw(nx_join)
         pl.title('join')
         pl.figure()
         nx_split = split.to_nx()
         _nx.draw(nx_split)
         pl.title('split')
         pl.figure()
         nx_ctree = contour_tree.to_nx()
         _nx.draw(nx_ctree)
         raw_input("enter to continue")
     eq_(regions,
             {
                 (6, 4): [4.9, 6],
                 (3, 2): [2],
                 (7, 6): [7],
                 (3, 1): [1, 2.1],
                 (5, 4): [4.6, 5],
                 (10, 5): [6.1, 7.2, 8.3, 10],
                 (4, 3): [3, 4],
                 (9, 5): [6.5, 9],
                 (8, 6): [6.9, 8],
                 })