prune_above_filtration returns filtration vector modification information instead of calling initialize_filtration()

git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/alphashapes@1071 636b058d-ea47-450e-bf9e-a15bfbe3eedb

Former-commit-id: 6fdc1797ac6e7b452abe150643f0ec9578c3bbab

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