Rename Complex in Simplex

Rename st_from_graph_expansion in st_from_rips
Hide insert_simplex and use only insert_simplex_with_subfaces (insert function)


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

Former-commit-id: 510f37a47361b635a45f7fd3a4c11a37a95b6e80

4 files changed, 20 insertions, 36 deletions

diff --git a/src/cython/Simplex_tree_interface.h b/src/cython/Simplex_tree_interface.h
index df35b335..dc29bed5 100644
--- a/src/cython/Simplex_tree_interface.h
+++ b/src/cython/Simplex_tree_interface.h
@@ -37,34 +37,29 @@ template<typename SimplexTreeOptions = Simplex_tree_options_full_featured>
 class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
   typedef typename Simplex_tree<SimplexTreeOptions>::Simplex_handle Simplex_handle;
   typedef typename std::pair<Simplex_handle, bool> Insertion_result;
-  typedef std::vector<Vertex_handle> Complex;
-  typedef std::pair<Complex, Filtration_value> Filtered_complex;
+  typedef std::vector<Vertex_handle> Simplex;
+  typedef std::pair<Simplex, Filtration_value> Filtered_complex;
   typedef std::vector<Filtered_complex> Complex_tree;
 
  public:
 
-  bool find_simplex(const Complex& vh) {
+  bool find_simplex(const Simplex& vh) {
     return (Simplex_tree<SimplexTreeOptions>::find(vh) != Simplex_tree<SimplexTreeOptions>::null_simplex());
   }
 
-  bool insert_simplex(const Complex& vh, Filtration_value filtration = 0) {
-    Insertion_result result = Simplex_tree<SimplexTreeOptions>::insert_simplex(vh, filtration);
-    return (result.second);
-  }
-
-  bool insert_simplex_and_subfaces(const Complex& complex, Filtration_value filtration = 0) {
+  bool insert_simplex_and_subfaces(const Simplex& complex, Filtration_value filtration = 0) {
     Insertion_result result = Simplex_tree<SimplexTreeOptions>::insert_simplex_and_subfaces(complex, filtration);
     return (result.second);
   }
 
-  Filtration_value simplex_filtration(const Complex& complex) {
+  Filtration_value simplex_filtration(const Simplex& complex) {
     return Simplex_tree<SimplexTreeOptions>::filtration(Simplex_tree<SimplexTreeOptions>::find(complex));
   }
 
   Complex_tree get_filtered_tree() {
     Complex_tree filtered_tree;
     for (auto f_simplex : Simplex_tree<SimplexTreeOptions>::filtration_simplex_range()) {
-      Complex simplex;
+      Simplex simplex;
       for (auto vertex : Simplex_tree<SimplexTreeOptions>::simplex_vertex_range(f_simplex)) {
         simplex.insert(simplex.begin(), vertex);
       }
@@ -77,7 +72,7 @@ class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
   Complex_tree get_skeleton_tree(int dimension) {
     Complex_tree skeleton_tree;
     for (auto f_simplex : Simplex_tree<SimplexTreeOptions>::skeleton_simplex_range(dimension)) {
-      Complex simplex;
+      Simplex simplex;
       for (auto vertex : Simplex_tree<SimplexTreeOptions>::simplex_vertex_range(f_simplex)) {
         simplex.insert(simplex.begin(), vertex);
       }
@@ -86,10 +81,10 @@ class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
     return skeleton_tree;
   }
 
-  Complex_tree get_star_tree(const Complex& complex) {
+  Complex_tree get_star_tree(const Simplex& complex) {
     Complex_tree star_tree;
     for (auto f_simplex : Simplex_tree<SimplexTreeOptions>::star_simplex_range(Simplex_tree<SimplexTreeOptions>::find(complex))) {
-      Complex simplex;
+      Simplex simplex;
       for (auto vertex : Simplex_tree<SimplexTreeOptions>::simplex_vertex_range(f_simplex)) {
         simplex.insert(simplex.begin(), vertex);
       }
@@ -98,10 +93,10 @@ class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
     return star_tree;
   }
 
-  Complex_tree get_coface_tree(const Complex& complex, int dimension) {
+  Complex_tree get_coface_tree(const Simplex& complex, int dimension) {
     Complex_tree coface_tree;
     for (auto f_simplex : Simplex_tree<SimplexTreeOptions>::cofaces_simplex_range(Simplex_tree<SimplexTreeOptions>::find(complex), dimension)) {
-      Complex simplex;
+      Simplex simplex;
       for (auto vertex : Simplex_tree<SimplexTreeOptions>::simplex_vertex_range(f_simplex)) {
         simplex.insert(simplex.begin(), vertex);
       }
diff --git a/src/cython/cgudhi.pxd b/src/cython/cgudhi.pxd
index 9d055c44..1be7309d 100644
--- a/src/cython/cgudhi.pxd
+++ b/src/cython/cgudhi.pxd
@@ -19,7 +19,6 @@ cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
         void set_dimension(int dimension)
         int dimension()
         bint find_simplex(vector[int] simplex)
-        bint insert_simplex(vector[int] simplex, double filtration)
         bint insert_simplex_and_subfaces(vector[int] simplex, double filtration)
         vector[pair[vector[int], double]] get_filtered_tree()
         vector[pair[vector[int], double]] get_skeleton_tree(int dimension)
diff --git a/src/cython/gudhi.pyx b/src/cython/gudhi.pyx
index dd87f4bb..c5757039 100644
--- a/src/cython/gudhi.pyx
+++ b/src/cython/gudhi.pyx
@@ -41,11 +41,6 @@ cdef class SimplexTree:
         cdef vector[int] complex
         for i in simplex:
           complex.push_back(i)
-        return self.thisptr.insert_simplex(complex, <double>filtration)
-    def insert_with_subfaces(self, simplex, filtration = 0.0):
-        cdef vector[int] complex
-        for i in simplex:
-          complex.push_back(i)
         return self.thisptr.insert_simplex_and_subfaces(complex, <double>filtration)
     def get_filtered_tree(self):
         cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_filtered_tree()
@@ -111,12 +106,7 @@ cdef class MiniSimplexTree:
         for i in simplex:
           complex.push_back(i)
         return self.thisptr.find_simplex(complex)
-    def insert(self, simplex):
-        cdef vector[int] complex
-        for i in simplex:
-          complex.push_back(i)
-        return self.thisptr.insert_simplex(complex, 0.0)
-    def insert_with_subfaces(self, simplex, filtration = 0.0):
+    def insert(self, simplex, filtration = 0.0):
         cdef vector[int] complex
         for i in simplex:
           complex.push_back(i)
diff --git a/src/cython/main.py b/src/cython/main.py
index c5f1d03b..e9459588 100755
--- a/src/cython/main.py
+++ b/src/cython/main.py
@@ -16,7 +16,7 @@ if st.find([0,1]):
 else:
   print("Not found...")
 
-if st.insert_with_subfaces([0,1,2], filtration=4.0):
+if st.insert([0,1,2], filtration=4.0):
   print("Inserted !!")
 else:
   print("Not inserted...")
@@ -39,12 +39,12 @@ print("skeleton_tree[1]=", st.get_skeleton_tree(1))
 print("skeleton_tree[0]=", st.get_skeleton_tree(0))
 
 print("#######################################################################")
-print("SimplexTree creation from graph expansion")
-st_from_graph_expansion = gudhi.SimplexTree(points=[[0,0],[1,0],[0,1],[1,1]],max_dimension=1,max_edge_length=42)
+print("SimplexTree creation from Rips")
+st_from_rips = gudhi.SimplexTree(points=[[0,0],[1,0],[0,1],[1,1]],max_dimension=1,max_edge_length=42)
 
-print("filtered_tree=", st_from_graph_expansion.get_filtered_tree())
-print("star([0])=", st_from_graph_expansion.get_star_tree([0]))
-print("coface([0],1)=", st_from_graph_expansion.get_coface_tree([0], 1))
+print("filtered_tree=", st_from_rips.get_filtered_tree())
+print("star([0])=", st_from_rips.get_star_tree([0]))
+print("coface([0],1)=", st_from_rips.get_coface_tree([0], 1))
 
 
 print("#######################################################################")
@@ -52,8 +52,8 @@ print("MiniSimplexTree creation from insertion")
 triangle012 = [0, 1, 2]
 edge03 = [0, 3]
 mini_st = gudhi.MiniSimplexTree()
-mini_st.insert_with_subfaces(triangle012)
-mini_st.insert_with_subfaces(edge03)
+mini_st.insert(triangle012)
+mini_st.insert(edge03)
 # FIXME: Remove this line
 mini_st.set_dimension(2);