A proposal for simplex_tree reset_filtration (python & C++)

5 files changed, 110 insertions, 0 deletions

diff --git a/src/Simplex_tree/include/gudhi/Simplex_tree.h b/src/Simplex_tree/include/gudhi/Simplex_tree.h
index 889dbd00..adc8e801 100644
--- a/src/Simplex_tree/include/gudhi/Simplex_tree.h
+++ b/src/Simplex_tree/include/gudhi/Simplex_tree.h
@@ -1667,6 +1667,36 @@ class Simplex_tree {
     return sh; // None of its faces has the same filtration.
   }
 
+ public:
+  /** \brief This function resets filtration value until a given dimension.
+   * @param[in] filt_value The new filtration value.
+   * @param[in] max_dim The maximal dimension.
+   */
+  void reset_filtration(Filtration_value filt_value, int max_dim) {
+    for (auto& simplex : root_.members()) {
+      simplex.second.assign_filtration(filt_value);
+      if (has_children(&simplex) && max_dim > 0) {
+        rec_reset_filtration(simplex.second.children(), filt_value, (max_dim - 1));
+      }
+    }
+    clear_filtration(); // Drop the cache.
+  }
+
+ private:
+  /** \brief Recursively resets filtration value until a given dimension.
+   * @param[in] sib Siblings to be parsed.
+   * @param[in] filt_value The new filtration value.
+   * @param[in] max_dim The maximal dimension.
+   */
+  void rec_reset_filtration(Siblings * sib, Filtration_value filt_value, int max_dim) {
+    for (auto& simplex : sib->members()) {
+      simplex.second.assign_filtration(filt_value);
+      if (has_children(&simplex) && max_dim > 0) {
+        rec_reset_filtration(simplex.second.children(), filt_value, (max_dim - 1));
+      }
+    }
+  }
+
  private:
   Vertex_handle null_vertex_;
   /** \brief Total number of simplices in the complex, without the empty simplex.*/
diff --git a/src/Simplex_tree/test/simplex_tree_unit_test.cpp b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
index 9b5fa8fe..9780f5b0 100644
--- a/src/Simplex_tree/test/simplex_tree_unit_test.cpp
+++ b/src/Simplex_tree/test/simplex_tree_unit_test.cpp
@@ -940,3 +940,50 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(generators, typeST, list_of_tested_variants) {
     BOOST_CHECK(st.edge_with_same_filtration(st.find({1,5}))==st.find({1,5}));
   }
 }
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(simplex_tree_reset_filtration, typeST, list_of_tested_variants) {
+  std::clog << "********************************************************************" << std::endl;
+  std::clog << "TEST RESET FILTRATION" << 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             */
+
+  for (auto f_simplex : st.skeleton_simplex_range(3)) {
+    std::clog << "vertex = (";
+    for (auto vertex : st.simplex_vertex_range(f_simplex)) {
+      std::clog << vertex << ",";
+    }
+    std::clog << ") - filtration =" << st.filtration(f_simplex) << std::endl;
+    BOOST_CHECK(st.filtration(f_simplex) >= 2.);
+  }
+
+  // dimension until 5 even if simplex tree is of dimension 3 to test the limits
+  for(int dimension = 0; dimension < 6; dimension ++) {
+    st.reset_filtration(0., dimension);
+    for (auto f_simplex : st.skeleton_simplex_range(3)) {
+      std::clog << "vertex = (";
+      for (auto vertex : st.simplex_vertex_range(f_simplex)) {
+        std::clog << vertex << ",";
+      }
+      std::clog << ") - filtration =" << st.filtration(f_simplex) << std::endl;
+      if (st.dimension(f_simplex) > dimension)
+        BOOST_CHECK(st.filtration(f_simplex) >= 1.);
+      else
+        BOOST_CHECK(st.filtration(f_simplex) == 0.);
+    }
+  }
+
+}
+
diff --git a/src/python/gudhi/simplex_tree.pxd b/src/python/gudhi/simplex_tree.pxd
index e748ac40..12c2065e 100644
--- a/src/python/gudhi/simplex_tree.pxd
+++ b/src/python/gudhi/simplex_tree.pxd
@@ -57,6 +57,7 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
         bool make_filtration_non_decreasing() nogil
         void compute_extended_filtration() nogil
         vector[vector[pair[int, pair[double, double]]]] compute_extended_persistence_subdiagrams(vector[pair[int, pair[double, double]]] dgm, double min_persistence) nogil
+        void reset_filtration(double filtration, int dimension) nogil
         # Iterators over Simplex tree
         pair[vector[int], double] get_simplex_and_filtration(Simplex_tree_simplex_handle f_simplex) nogil
         Simplex_tree_simplices_iterator get_simplices_iterator_begin() nogil
diff --git a/src/python/gudhi/simplex_tree.pyx b/src/python/gudhi/simplex_tree.pyx
index 20e66d9f..41b06116 100644
--- a/src/python/gudhi/simplex_tree.pyx
+++ b/src/python/gudhi/simplex_tree.pyx
@@ -358,6 +358,16 @@ cdef class SimplexTree:
         """
         return self.get_ptr().make_filtration_non_decreasing()
 
+    def reset_filtration(self, filtration, max_dim):
+        """This function resets filtration value until a given dimension.
+
+        :param filtration: New threshold value.
+        :type filtration: float.
+        :param max_dim: The maximal dimension.
+        :type max_dim: int.
+        """
+        self.get_ptr().reset_filtration(filtration, max_dim)
+
     def extend_filtration(self):
         """ Extend filtration for computing extended persistence. This function only uses the 
         filtration values at the 0-dimensional simplices, and computes the extended persistence 
diff --git a/src/python/test/test_simplex_tree.py b/src/python/test/test_simplex_tree.py
index 2137d822..1ca84c10 100755
--- a/src/python/test/test_simplex_tree.py
+++ b/src/python/test/test_simplex_tree.py
@@ -340,3 +340,25 @@ def test_simplices_iterator():
         assert st.find(simplex[0]) == True
         print("filtration is: ", simplex[1])
         assert st.filtration(simplex[0]) == simplex[1]
+
+def test_reset_filtration():
+    st = SimplexTree()
+    
+    assert st.insert([0, 1, 2], 3.) == True
+    assert st.insert([0, 3], 2.) == True
+    assert st.insert([3, 4, 5], 3.) == True
+    assert st.insert([0, 1, 6, 7], 4.) == True
+
+    for simplex in st.get_simplices():
+        assert st.filtration(simplex[0]) >= 0.
+    
+    # dimension until 5 even if simplex tree is of dimension 3 to test the limits
+    for dimension in range(0, 6):
+        st.reset_filtration(0., dimension)
+        for simplex in st.get_skeleton(3):
+            print(simplex)
+            if len(simplex[0]) > (dimension + 1):
+                assert st.filtration(simplex[0]) >= 1.
+            else:
+                assert st.filtration(simplex[0]) == 0.
+