diff options
-rw-r--r-- | src/Alpha_complex/include/gudhi/Alpha_complex.h | 6 | ||||
-rw-r--r-- | src/Alpha_complex/test/Alpha_complex_unit_test.cpp | 10 | ||||
-rw-r--r-- | src/Simplex_tree/include/gudhi/Simplex_tree.h | 16 | ||||
-rw-r--r-- | src/Simplex_tree/test/simplex_tree_unit_test.cpp | 71 |
4 files changed, 77 insertions, 26 deletions
diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h index 330b3b34..33830175 100644 --- a/src/Alpha_complex/include/gudhi/Alpha_complex.h +++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h @@ -230,8 +230,6 @@ class Alpha_complex : public Simplex_tree<> { } set_dimension(triangulation_->maximal_dimension()); - // set_filtration to +inf for prune_above_filtration to be done (if necessary) - set_filtration(std::numeric_limits<Filtration_value>::infinity()); // -------------------------------------------------------------------------------------------- // double map to retrieve simplex tree vertex handles from CGAL vertex iterator and vice versa @@ -323,7 +321,9 @@ class Alpha_complex : public Simplex_tree<> { initialize_filtration(); } // Remove all simplices that have a filtration value greater than max_alpha_square - prune_above_filtration(max_alpha_square); + if (prune_above_filtration(max_alpha_square)) { + initialize_filtration(); + } // -------------------------------------------------------------------------------------------- } diff --git a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp index 2912019d..315582d1 100644 --- a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp +++ b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp @@ -78,7 +78,8 @@ BOOST_AUTO_TEST_CASE(ALPHA_DOC_OFF_file_filtered) { std::cout << "========== OFF FILE NAME = " << off_file_name << " - alpha²=" << max_alpha_square_value << "==========" << std::endl; - Gudhi::alphacomplex::Alpha_complex<Kernel_d> alpha_complex_from_file(off_file_name, max_alpha_square_value); + // Use of the default dynamic kernel + Gudhi::alphacomplex::Alpha_complex<> alpha_complex_from_file(off_file_name, max_alpha_square_value); const int DIMENSION = 2; std::cout << "alpha_complex_from_file.dimension()=" << alpha_complex_from_file.dimension() << std::endl; @@ -200,7 +201,12 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) { BOOST_CHECK_THROW (alpha_complex_from_points.get_point(1234), std::out_of_range); // Test after prune_above_filtration - alpha_complex_from_points.prune_above_filtration(0.6); + bool modified = alpha_complex_from_points.prune_above_filtration(0.6); + if (modified) { + alpha_complex_from_points.initialize_filtration(); + } + BOOST_CHECK(modified); + // Another way to check num_simplices std::cout << "Iterator on alpha complex simplices in the filtration order, with [filtration value]:" << std::endl; num_simplices = 0; diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h index aa8f059e..af298f33 100644 --- a/src/Simplex_tree/include/gudhi/Simplex_tree.h +++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h @@ -1186,11 +1186,14 @@ class Simplex_tree { public: /** \brief Prune above filtration value given as parameter. * @param[in] filtration Maximum threshold value. - * \post The filtration must be valid. If the filtration has not been initialized yet, the method initializes it - * (i.e. order the simplices). If the complex has changed since the last time the filtration was initialized, please - * call `initialize_filtration()` to recompute it. + * @return The filtration modification information. + * \pre The filtration must be valid. If the filtration has not been initialized yet, the method initializes it + * (i.e. order the simplices). + * \post Some simplex tree functions require the filtration to be valid. `prune_above_filtration()` + * function is not launching `initialize_filtration()` but returns the filtration modification information. If the + * complex has changed , please call `initialize_filtration()` to recompute it. */ - void prune_above_filtration(Filtration_value filtration) { + bool prune_above_filtration(Filtration_value filtration) { // Initialize filtration_vect_ if required if (filtration_vect_.empty()) { initialize_filtration(); @@ -1213,13 +1216,12 @@ class Simplex_tree { remove_maximal_simplex(sh); } // Re-initialize filtration_vect_ if dta were removed, because removing is shifting data in a flat_map - if (simplex_list_to_removed.size() > 0) - initialize_filtration(); + return (simplex_list_to_removed.size() > 0); } /* // Another alternative for prune_above_filtration - // Seg fault in this state + // initialize_filtration is not called. UT are not passed. void prune_above_filtration(Filtration_value filt) { if (!Options::store_filtration || filt >= filtration()) return; rec_prune_above_filtration(root(), filt); diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp index b8c1cc35..b1bb23b1 100644 --- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp +++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp @@ -1012,20 +1012,30 @@ BOOST_AUTO_TEST_CASE(prune_above_filtration) { // o // 5 + bool simplex_is_changed = false; // Check the no action cases // greater than initial filtration value - st.prune_above_filtration(10.0); + simplex_is_changed = st.prune_above_filtration(10.0); + if (simplex_is_changed) + st.initialize_filtration(); BOOST_CHECK(st == st_complete); + BOOST_CHECK(!simplex_is_changed); // equal to initial filtration value - st.prune_above_filtration(6.0); + simplex_is_changed = st.prune_above_filtration(6.0); + if (simplex_is_changed) + st.initialize_filtration(); BOOST_CHECK(st == st_complete); + BOOST_CHECK(!simplex_is_changed); // lower than initial filtration value, but still greater than the maximum filtration value - st.prune_above_filtration(5.0); + simplex_is_changed = st.prune_above_filtration(5.0); + if (simplex_is_changed) + st.initialize_filtration(); BOOST_CHECK(st == st_complete); + BOOST_CHECK(!simplex_is_changed); // Display the Simplex_tree std::cout << "The complex contains " << st.num_simplices() << " simplices"; - std::cout << " - dimension " << st.dimension() << " - filtration " << st.filtration() << std::endl; + std::cout << " - dimension " << st.dimension() << std::endl; std::cout << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl; for (auto f_simplex : st.filtration_simplex_range()) { std::cout << " " << "[" << st.filtration(f_simplex) << "] "; @@ -1036,35 +1046,46 @@ BOOST_AUTO_TEST_CASE(prune_above_filtration) { } // Check the pruned cases - // Set the st_pruned filtration for operator== - st.prune_above_filtration(2.5); + simplex_is_changed = st.prune_above_filtration(2.5); + if (simplex_is_changed) + st.initialize_filtration(); BOOST_CHECK(st == st_pruned); + BOOST_CHECK(simplex_is_changed); // Display the Simplex_tree std::cout << "The complex pruned at 2.5 contains " << st.num_simplices() << " simplices"; - std::cout << " - dimension " << st.dimension() << " - filtration " << st.filtration() << std::endl; + std::cout << " - dimension " << st.dimension() << std::endl; - st.prune_above_filtration(2.0); + simplex_is_changed = st.prune_above_filtration(2.0); + if (simplex_is_changed) + st.initialize_filtration(); std::cout << "The complex pruned at 2.0 contains " << st.num_simplices() << " simplices"; - std::cout << " - dimension " << st.dimension() << " - filtration " << st.filtration() << std::endl; + std::cout << " - dimension " << st.dimension() << std::endl; BOOST_CHECK(st == st_pruned); + BOOST_CHECK(!simplex_is_changed); typeST st_empty; // FIXME st_empty.set_dimension(3); - st.prune_above_filtration(0.0); + simplex_is_changed = st.prune_above_filtration(0.0); + if (simplex_is_changed) + st.initialize_filtration(); // Display the Simplex_tree std::cout << "The complex pruned at 0.0 contains " << st.num_simplices() << " simplices"; - std::cout << " - dimension " << st.dimension() << " - filtration " << st.filtration() << std::endl; + std::cout << " - dimension " << st.dimension() << std::endl; BOOST_CHECK(st == st_empty); + BOOST_CHECK(simplex_is_changed); // Test case to the limit - st.prune_above_filtration(-1.0); + simplex_is_changed = st.prune_above_filtration(-1.0); + if (simplex_is_changed) + st.initialize_filtration(); BOOST_CHECK(st == st_empty); + BOOST_CHECK(!simplex_is_changed); } BOOST_AUTO_TEST_CASE(mini_prune_above_filtration) { @@ -1096,11 +1117,33 @@ BOOST_AUTO_TEST_CASE(mini_prune_above_filtration) { std::cout << "The complex contains " << st.num_simplices() << " simplices" << std::endl; BOOST_CHECK(st.num_simplices() == 27); + // Test case to the limit - With these options, there is no filtration, which means filtration is 0 + bool simplex_is_changed = st.prune_above_filtration(1.0); + if (simplex_is_changed) + st.initialize_filtration(); + // Display the Simplex_tree + std::cout << "The complex pruned at 1.0 contains " << st.num_simplices() << " simplices" << std::endl; + BOOST_CHECK(!simplex_is_changed); + BOOST_CHECK(st.num_simplices() == 27); + + simplex_is_changed = st.prune_above_filtration(0.0); + if (simplex_is_changed) + st.initialize_filtration(); + // Display the Simplex_tree + std::cout << "The complex pruned at 0.0 contains " << st.num_simplices() << " simplices" << std::endl; + BOOST_CHECK(!simplex_is_changed); + BOOST_CHECK(st.num_simplices() == 27); + // Test case to the limit - st.prune_above_filtration(-1.0); + simplex_is_changed = st.prune_above_filtration(-1.0); + if (simplex_is_changed) + st.initialize_filtration(); + // Display the Simplex_tree + std::cout << "The complex pruned at -1.0 contains " << st.num_simplices() << " simplices" << std::endl; + BOOST_CHECK(simplex_is_changed); + BOOST_CHECK(st.num_simplices() == 0); // Display the Simplex_tree std::cout << "The complex contains " << st.num_simplices() << " simplices" << std::endl; - BOOST_CHECK(st.num_simplices() == 0); }
\ No newline at end of file |