From 0d25c9db02cdc20c4b7ca1f48780eb7129ee8b82 Mon Sep 17 00:00:00 2001 From: Vincent Rouvreau Date: Tue, 5 Apr 2022 10:30:57 +0200 Subject: Boundary and its opposite vertex iterator for the simplex tree --- src/Simplex_tree/include/gudhi/Simplex_tree.h | 23 +++++ .../gudhi/Simplex_tree/Simplex_tree_iterators.h | 102 ++++++++++++++++++++- .../gudhi/Simplex_tree/Simplex_tree_siblings.h | 1 + src/Simplex_tree/test/simplex_tree_unit_test.cpp | 35 +++++++ 4 files changed, 160 insertions(+), 1 deletion(-) diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h index d48f6616..63a7f190 100644 --- a/src/Simplex_tree/include/gudhi/Simplex_tree.h +++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h @@ -187,6 +187,12 @@ class Simplex_tree { typedef Simplex_tree_boundary_simplex_iterator Boundary_simplex_iterator; /** \brief Range over the simplices of the boundary of a simplex. */ typedef boost::iterator_range Boundary_simplex_range; + /** \brief Iterator over the simplices of the boundary and its opposite vertex of a simplex. + * + * 'value_type' is std::pair. */ + typedef Simplex_tree_boundary_opposite_vertex_simplex_iterator Boundary_opposite_vertex_simplex_iterator; + /** \brief Range over the simplices of the boundary and its opposite vertex of a simplex. */ + typedef boost::iterator_range Boundary_opposite_vertex_simplex_range; /** \brief Iterator over the simplices of the simplicial complex. * * 'value_type' is Simplex_handle. */ @@ -296,6 +302,23 @@ class Simplex_tree { Boundary_simplex_iterator(this)); } + /** \brief Returns a range over the simplices of the boundary and its opposite vertex of a simplex. + * + * The boundary and its opposite vertex of a simplex is the set of codimension \f$1\f$ subsimplices of the simplex. + * If the simplex is \f$[v_0, \cdots ,v_d]\f$, with canonical orientation induced by \f$ v_0 < \cdots < v_d \f$, the + * iterator enumerates the simplices of the boundary in the order: + * \f$[v_0,\cdots,\widehat{v_i},\cdots,v_d]\f$ for \f$i\f$ from \f$0\f$ to \f$d\f$, where \f$\widehat{v_i}\f$ means + * that the vertex \f$v_i\f$ is omitted from boundary, but returned as the second element of the pair, known as the + * the opposite vertex of the boundary. + * + * @param[in] sh Simplex for which the boundary and its opposite vertex is computed. + * @return Iterator on a pair of SimplexHandle (a boundary) and a VertexHandle (its opposite vertex). */ + template + Boundary_opposite_vertex_simplex_range boundary_opposite_vertex_simplex_range(SimplexHandle sh) { + return Boundary_opposite_vertex_simplex_range(Boundary_opposite_vertex_simplex_iterator(this, sh), + Boundary_opposite_vertex_simplex_iterator(this)); + } + /** @} */ // end range and iterator methods /** \name Constructor/Destructor * @{ */ diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h index e5522cc7..841b4d49 100644 --- a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h +++ b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h @@ -5,6 +5,7 @@ * Copyright (C) 2014 Inria * * Modification(s): + * - 2022/04 Vincent Rouvreau: Add Simplex_tree_boundary_opposite_vertex_simplex_iterator for alpha and cech purpose * - YYYY/MM Author: Description of the modification */ @@ -17,6 +18,7 @@ #include #include +#include // for std::pair namespace Gudhi { @@ -123,7 +125,7 @@ class Simplex_tree_boundary_simplex_iterator : public boost::iterator_facade< private: friend class boost::iterator_core_access; -// valid when iterating along the SAME boundary. + // valid when iterating along the SAME boundary. bool equal(Simplex_tree_boundary_simplex_iterator const& other) const { return sh_ == other.sh_; } @@ -178,6 +180,104 @@ class Simplex_tree_boundary_simplex_iterator : public boost::iterator_facade< Simplex_handle sh_; // current Simplex_handle in the boundary SimplexTree * st_; // simplex containing the simplicial complex }; + +/* \brief Iterator over the simplices of the boundary and opposite vertex of a simplex. + * + * Forward iterator, value_type is std::pair.*/ +template +class Simplex_tree_boundary_opposite_vertex_simplex_iterator : public boost::iterator_facade< + Simplex_tree_boundary_opposite_vertex_simplex_iterator, + std::pair const, boost::forward_traversal_tag> { + public: + using Simplex_handle = typename SimplexTree::Simplex_handle; + using Vertex_handle = typename SimplexTree::Vertex_handle; + using Siblings = typename SimplexTree::Siblings; + + // For cython purpose only. The object it initializes should be overwritten ASAP and never used before it is + // overwritten. + Simplex_tree_boundary_opposite_vertex_simplex_iterator() + : sib_(nullptr), + st_(nullptr) { + } + + // any end() iterator + explicit Simplex_tree_boundary_opposite_vertex_simplex_iterator(SimplexTree * st) + : last_(st->null_vertex()), + next_(st->null_vertex()), + sib_(nullptr), + baov_(st->null_simplex(), st->null_vertex()), + st_(st) { + } + + template + Simplex_tree_boundary_opposite_vertex_simplex_iterator(SimplexTree * st, SimplexHandle sh) + : last_(sh->first), + next_(st->null_vertex()), + sib_(nullptr), + baov_(st->null_simplex(), sh->first), + st_(st) { + // Only check once at the beginning instead of for every increment, as this is expensive. + if (SimplexTree::Options::contiguous_vertices) + GUDHI_CHECK(st_->contiguous_vertices(), "The set of vertices is not { 0, ..., n } without holes"); + Siblings * sib = st->self_siblings(sh); + next_ = sib->parent(); + sib_ = sib->oncles(); + if (sib_ != nullptr) { + if (SimplexTree::Options::contiguous_vertices && sib_->oncles() == nullptr) + // Only relevant for edges + baov_.first = sib_->members_.begin()+next_; + else + baov_.first = sib_->find(next_); + } + } + + private: + friend class boost::iterator_core_access; + + // valid when iterating along the SAME boundary. + bool equal(Simplex_tree_boundary_opposite_vertex_simplex_iterator const& other) const { + return (baov_.first == other.baov_.first); + } + + std::pair const& dereference() const { + return baov_; + } + + void increment() { + if (sib_ == nullptr) { + baov_.first = st_->null_simplex(); + return; // ------>> + } + Siblings * for_sib = sib_; + Siblings * new_sib = sib_->oncles(); + auto rit = suffix_.rbegin(); + for (; rit != suffix_.rend(); ++rit) { + baov_.first = for_sib->find(*rit); + for_sib = baov_.first->second.children(); + } + baov_.first = for_sib->find(last_); // baov_.first points to the right simplex now + suffix_.push_back(next_); + next_ = sib_->parent(); + sib_ = new_sib; + if (suffix_.empty()) + baov_.second = last_; + else + baov_.second = suffix_.back(); + } + + // Most of the storage should be moved to the range, iterators should be light. + Vertex_handle last_; // last vertex of the simplex + Vertex_handle next_; // next vertex to push in suffix_ + // 40 seems a conservative bound on the dimension of a Simplex_tree for now, + // as it would not fit on the biggest hard-drive. + boost::container::static_vector suffix_; + // static_vector still has some overhead compared to a trivial hand-made + // version using std::aligned_storage, or compared to making suffix_ static. + Siblings * sib_; // where the next search will start from + std::pair baov_; // a pair containing the current Simplex_handle in the boundary and its opposite vertex + SimplexTree * st_; // simplex containing the simplicial complex +}; + /*---------------------------------------------------------------------------*/ /* \brief Iterator over the simplices of a simplicial complex. * diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_siblings.h b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_siblings.h index b53bad29..ae25d290 100644 --- a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_siblings.h +++ b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_siblings.h @@ -36,6 +36,7 @@ class Simplex_tree_siblings { template friend class Simplex_tree_boundary_simplex_iterator; template friend class Simplex_tree_complex_simplex_iterator; template friend class Simplex_tree_skeleton_simplex_iterator; + template friend class Simplex_tree_boundary_opposite_vertex_simplex_iterator; typedef typename SimplexTree::Vertex_handle Vertex_handle; typedef typename SimplexTree::Filtration_value Filtration_value; diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp index bdd41d34..2c8a376c 100644 --- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp +++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp @@ -991,3 +991,38 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_reset_filtration, typeST, list_of_tes } +BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_boundaries_and_opposite_vertex_iterator, typeST, list_of_tested_variants) { + std::clog << "********************************************************************" << std::endl; + std::clog << "TEST OF BOUNDARIES AND OPPOSITE VERTEX ITERATORS" << std::endl; + typeST st; + + st.insert_simplex_and_subfaces({2, 1, 0}, 3.); + st.insert_simplex_and_subfaces({3, 0}, 2.); + st.insert_simplex_and_subfaces({3, 4, 5}, 3.); + st.insert_simplex_and_subfaces({0, 1, 6, 7}, 4.); + + /* Inserted simplex: */ + /* 1 6 */ + /* o---o */ + /* /X\7/ */ + /* o---o---o---o */ + /* 2 0 3\X/4 */ + /* o */ + /* 5 */ + using Simplex = std::vector; + // simplices must be kept sorted by vertex number for std::vector to use operator== - cf. last BOOST_CHECK + std::vector simplices = {{0, 1, 2}, {0, 3}, {0, 1, 6, 7}, {3,4,5}, {3,5}}; + for (auto simplex : simplices) { + for(auto boundary_and_opposite_vertex : st.boundary_opposite_vertex_simplex_range(st.find(simplex))) { + Simplex output; + for (auto vertex : st.simplex_vertex_range(boundary_and_opposite_vertex.first)) { + std::clog << vertex << " "; + output.emplace_back(vertex); + } + std::clog << " - opposite vertex = " << boundary_and_opposite_vertex.second << std::endl; + output.emplace_back(boundary_and_opposite_vertex.second); + std::sort(output.begin(), output.end()); + BOOST_CHECK(simplex == output); + } + } +} -- cgit v1.2.3 From dc5d417b3d2c2f6772389c1906455f041b796b37 Mon Sep 17 00:00:00 2001 From: Vincent Rouvreau <10407034+VincentRouvreau@users.noreply.github.com> Date: Tue, 12 Apr 2022 14:23:40 +0200 Subject: doc review Co-authored-by: Marc Glisse --- src/Simplex_tree/include/gudhi/Simplex_tree.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h index 63a7f190..82281cc4 100644 --- a/src/Simplex_tree/include/gudhi/Simplex_tree.h +++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h @@ -187,7 +187,7 @@ class Simplex_tree { typedef Simplex_tree_boundary_simplex_iterator Boundary_simplex_iterator; /** \brief Range over the simplices of the boundary of a simplex. */ typedef boost::iterator_range Boundary_simplex_range; - /** \brief Iterator over the simplices of the boundary and its opposite vertex of a simplex. + /** \brief Iterator over the simplices of the boundary of a simplex and their opposite vertices. * * 'value_type' is std::pair. */ typedef Simplex_tree_boundary_opposite_vertex_simplex_iterator Boundary_opposite_vertex_simplex_iterator; -- cgit v1.2.3 From 59d4abce6ab249ac2bed82355a9930601cd3b77f Mon Sep 17 00:00:00 2001 From: Vincent Rouvreau <10407034+VincentRouvreau@users.noreply.github.com> Date: Tue, 12 Apr 2022 14:35:06 +0200 Subject: doc review Co-authored-by: Marc Glisse --- src/Simplex_tree/include/gudhi/Simplex_tree.h | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h index 82281cc4..5219d263 100644 --- a/src/Simplex_tree/include/gudhi/Simplex_tree.h +++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h @@ -302,17 +302,16 @@ class Simplex_tree { Boundary_simplex_iterator(this)); } - /** \brief Returns a range over the simplices of the boundary and its opposite vertex of a simplex. + /** \brief Given a simplex, returns a range over the simplices of its boundary and their opposite vertices. * - * The boundary and its opposite vertex of a simplex is the set of codimension \f$1\f$ subsimplices of the simplex. + * The boundary of a simplex is the set of codimension \f$1\f$ subsimplices of the simplex. * If the simplex is \f$[v_0, \cdots ,v_d]\f$, with canonical orientation induced by \f$ v_0 < \cdots < v_d \f$, the * iterator enumerates the simplices of the boundary in the order: * \f$[v_0,\cdots,\widehat{v_i},\cdots,v_d]\f$ for \f$i\f$ from \f$0\f$ to \f$d\f$, where \f$\widehat{v_i}\f$ means - * that the vertex \f$v_i\f$ is omitted from boundary, but returned as the second element of the pair, known as the - * the opposite vertex of the boundary. + * that the vertex \f$v_i\f$, known as the opposite vertex, is omitted from boundary, but returned as the second element of a pair. * - * @param[in] sh Simplex for which the boundary and its opposite vertex is computed. - * @return Iterator on a pair of SimplexHandle (a boundary) and a VertexHandle (its opposite vertex). */ + * @param[in] sh Simplex for which the boundary is computed. + */ template Boundary_opposite_vertex_simplex_range boundary_opposite_vertex_simplex_range(SimplexHandle sh) { return Boundary_opposite_vertex_simplex_range(Boundary_opposite_vertex_simplex_iterator(this, sh), -- cgit v1.2.3 From 576925c8ebce411e6116bcfc2bbf1bcd66b8d536 Mon Sep 17 00:00:00 2001 From: Vincent Rouvreau Date: Tue, 12 Apr 2022 14:37:34 +0200 Subject: doc review: i is from d to 0 --- src/Simplex_tree/include/gudhi/Simplex_tree.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h index 5219d263..0bd76baa 100644 --- a/src/Simplex_tree/include/gudhi/Simplex_tree.h +++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h @@ -307,8 +307,9 @@ class Simplex_tree { * The boundary of a simplex is the set of codimension \f$1\f$ subsimplices of the simplex. * If the simplex is \f$[v_0, \cdots ,v_d]\f$, with canonical orientation induced by \f$ v_0 < \cdots < v_d \f$, the * iterator enumerates the simplices of the boundary in the order: - * \f$[v_0,\cdots,\widehat{v_i},\cdots,v_d]\f$ for \f$i\f$ from \f$0\f$ to \f$d\f$, where \f$\widehat{v_i}\f$ means - * that the vertex \f$v_i\f$, known as the opposite vertex, is omitted from boundary, but returned as the second element of a pair. + * \f$[v_0,\cdots,\widehat{v_i},\cdots,v_d]\f$ for \f$i\f$ from \f$d\f$ to \f$0\f$, where \f$\widehat{v_i}\f$ means + * that the vertex \f$v_i\f$, known as the opposite vertex, is omitted from boundary, but returned as the second + * element of a pair. * * @param[in] sh Simplex for which the boundary is computed. */ -- cgit v1.2.3 From 28ba351cab3b53adf76af043022cc7b0d9da79e6 Mon Sep 17 00:00:00 2001 From: Vincent Rouvreau Date: Tue, 12 Apr 2022 14:43:04 +0200 Subject: identation --- src/Simplex_tree/test/simplex_tree_unit_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp index 2c8a376c..75a8c539 100644 --- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp +++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp @@ -1011,7 +1011,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_boundaries_and_opposite_vertex_iterat /* 5 */ using Simplex = std::vector; // simplices must be kept sorted by vertex number for std::vector to use operator== - cf. last BOOST_CHECK - std::vector simplices = {{0, 1, 2}, {0, 3}, {0, 1, 6, 7}, {3,4,5}, {3,5}}; + std::vector simplices = {{0, 1, 2}, {0, 3}, {0, 1, 6, 7}, {3, 4, 5}, {3, 5}}; for (auto simplex : simplices) { for(auto boundary_and_opposite_vertex : st.boundary_opposite_vertex_simplex_range(st.find(simplex))) { Simplex output; -- cgit v1.2.3 From bcb69fe23195a4073c3b05f6df58d3ceeef0b7f0 Mon Sep 17 00:00:00 2001 From: Vincent Rouvreau Date: Tue, 12 Apr 2022 14:44:12 +0200 Subject: code review: remove unnecessary test of empty suffix_ --- src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h index 841b4d49..e4b54c7e 100644 --- a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h +++ b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h @@ -259,10 +259,7 @@ class Simplex_tree_boundary_opposite_vertex_simplex_iterator : public boost::ite suffix_.push_back(next_); next_ = sib_->parent(); sib_ = new_sib; - if (suffix_.empty()) - baov_.second = last_; - else - baov_.second = suffix_.back(); + baov_.second = suffix_.back(); } // Most of the storage should be moved to the range, iterators should be light. -- cgit v1.2.3 From a6393ee6200010f69514875b953936b38e9eaa7f Mon Sep 17 00:00:00 2001 From: Vincent Rouvreau Date: Tue, 12 Apr 2022 17:03:58 +0200 Subject: code review: Add short cut for contiguous vertices increment --- .../include/gudhi/Simplex_tree/Simplex_tree_iterators.h | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h index e4b54c7e..3fd2e07c 100644 --- a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h +++ b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h @@ -251,6 +251,21 @@ class Simplex_tree_boundary_opposite_vertex_simplex_iterator : public boost::ite Siblings * for_sib = sib_; Siblings * new_sib = sib_->oncles(); auto rit = suffix_.rbegin(); + if (SimplexTree::Options::contiguous_vertices && new_sib == nullptr) { + // We reached the root, use a short-cut to find a vertex. + if (rit == suffix_.rend()) { + baov_.second = baov_.first->first; + // Segment, this vertex is the last boundary simplex + baov_.first = for_sib->members_.begin()+last_; + sib_ = nullptr; + return; + } else { + // Dim >= 2, initial step of the descent + baov_.first = for_sib->members_.begin()+*rit; + for_sib = baov_.first->second.children(); + ++rit; + } + } for (; rit != suffix_.rend(); ++rit) { baov_.first = for_sib->find(*rit); for_sib = baov_.first->second.children(); -- cgit v1.2.3 From bfd89c0959adb2fafe15fc7d930d4aa3589a0e83 Mon Sep 17 00:00:00 2001 From: Vincent Rouvreau Date: Tue, 12 Apr 2022 17:18:27 +0200 Subject: doc review: accordingly to the review, replace the other places where it was also not well explained --- src/Simplex_tree/include/gudhi/Simplex_tree.h | 2 +- src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h index 0bd76baa..34bc5ace 100644 --- a/src/Simplex_tree/include/gudhi/Simplex_tree.h +++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h @@ -191,7 +191,7 @@ class Simplex_tree { * * 'value_type' is std::pair. */ typedef Simplex_tree_boundary_opposite_vertex_simplex_iterator Boundary_opposite_vertex_simplex_iterator; - /** \brief Range over the simplices of the boundary and its opposite vertex of a simplex. */ + /** \brief Range over the simplices of the boundary of a simplex and their opposite vertices. */ typedef boost::iterator_range Boundary_opposite_vertex_simplex_range; /** \brief Iterator over the simplices of the simplicial complex. * diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h index 3fd2e07c..394c6ee1 100644 --- a/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h +++ b/src/Simplex_tree/include/gudhi/Simplex_tree/Simplex_tree_iterators.h @@ -181,7 +181,7 @@ class Simplex_tree_boundary_simplex_iterator : public boost::iterator_facade< SimplexTree * st_; // simplex containing the simplicial complex }; -/* \brief Iterator over the simplices of the boundary and opposite vertex of a simplex. +/* \brief Iterator over the simplices of the boundary of a simplex and their opposite vertices. * * Forward iterator, value_type is std::pair.*/ template -- cgit v1.2.3 From ff11b137365f0cef11062f9413907f0f39414b3e Mon Sep 17 00:00:00 2001 From: Vincent Rouvreau Date: Tue, 17 May 2022 10:15:24 +0200 Subject: code review: test also range size --- src/Simplex_tree/test/simplex_tree_unit_test.cpp | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp index 75a8c539..2b2be89d 100644 --- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp +++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp @@ -17,6 +17,8 @@ #include #include // greater #include // std::tie +#include // for std::distance +#include // for std::size_t #define BOOST_TEST_DYN_LINK #define BOOST_TEST_MODULE "simplex_tree" @@ -1011,8 +1013,16 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_boundaries_and_opposite_vertex_iterat /* 5 */ using Simplex = std::vector; // simplices must be kept sorted by vertex number for std::vector to use operator== - cf. last BOOST_CHECK - std::vector simplices = {{0, 1, 2}, {0, 3}, {0, 1, 6, 7}, {3, 4, 5}, {3, 5}}; + std::vector simplices = {{0, 1, 2}, {0, 3}, {0, 1, 6, 7}, {3, 4, 5}, {3, 5}, {2}}; for (auto simplex : simplices) { + std::size_t range_size = std::distance(st.boundary_opposite_vertex_simplex_range(st.find(simplex)).begin(), + st.boundary_opposite_vertex_simplex_range(st.find(simplex)).end()); + std::cout << "Range size = " << range_size << " - " << simplex.size() << std::endl; + if (simplex.size() > 1) { + BOOST_CHECK(range_size == simplex.size()); + } else { + BOOST_CHECK(range_size == 0); + } for(auto boundary_and_opposite_vertex : st.boundary_opposite_vertex_simplex_range(st.find(simplex))) { Simplex output; for (auto vertex : st.simplex_vertex_range(boundary_and_opposite_vertex.first)) { -- cgit v1.2.3 From 7d1e88a2995e23d882cc3bfe69ec09357d6c2618 Mon Sep 17 00:00:00 2001 From: Vincent Rouvreau Date: Tue, 17 May 2022 10:33:51 +0200 Subject: code review: test also the list of all oppposite vertices is the simplex given as an input --- src/Simplex_tree/test/simplex_tree_unit_test.cpp | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp index 2b2be89d..b18e2ec4 100644 --- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp +++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp @@ -1015,14 +1015,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_boundaries_and_opposite_vertex_iterat // simplices must be kept sorted by vertex number for std::vector to use operator== - cf. last BOOST_CHECK std::vector simplices = {{0, 1, 2}, {0, 3}, {0, 1, 6, 7}, {3, 4, 5}, {3, 5}, {2}}; for (auto simplex : simplices) { - std::size_t range_size = std::distance(st.boundary_opposite_vertex_simplex_range(st.find(simplex)).begin(), - st.boundary_opposite_vertex_simplex_range(st.find(simplex)).end()); - std::cout << "Range size = " << range_size << " - " << simplex.size() << std::endl; - if (simplex.size() > 1) { - BOOST_CHECK(range_size == simplex.size()); - } else { - BOOST_CHECK(range_size == 0); - } + Simplex opposite_vertices; for(auto boundary_and_opposite_vertex : st.boundary_opposite_vertex_simplex_range(st.find(simplex))) { Simplex output; for (auto vertex : st.simplex_vertex_range(boundary_and_opposite_vertex.first)) { @@ -1030,9 +1023,18 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_boundaries_and_opposite_vertex_iterat output.emplace_back(vertex); } std::clog << " - opposite vertex = " << boundary_and_opposite_vertex.second << std::endl; + // Check that boundary simplex + opposite vertex = simplex given as input output.emplace_back(boundary_and_opposite_vertex.second); std::sort(output.begin(), output.end()); BOOST_CHECK(simplex == output); + opposite_vertices.emplace_back(boundary_and_opposite_vertex.second); } + // Check that the list of all opposite vertices = simplex given as input + // no opposite vertices if simplex given as input is of dimension 1 + std::sort(opposite_vertices.begin(), opposite_vertices.end()); + if (simplex.size() > 1) + BOOST_CHECK(simplex == opposite_vertices); + else + BOOST_CHECK(opposite_vertices.size() == 0); } } -- cgit v1.2.3