Directory re-organization for Gudhi modules

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

Former-commit-id: acfc931aee37c65ee2828e3873e9727b308e5d76

9 files changed, 231 insertions, 187 deletions

diff --git a/src/cython/Makefile b/src/cython/Makefile
index c17e9e09..a4fa1104 100644
--- a/src/cython/Makefile
+++ b/src/cython/Makefile
@@ -2,8 +2,12 @@ ext:
 	python setup.py build_ext --inplace
 
 test:
-	python Simplex_tree_UT.py
-	python Simplex_tree_example.py
+	python test/Simplex_tree_UT.py
+
+example:
+	python example/Simplex_tree_example.py
 
 clean:
 	rm -rf build/ *.o *.so *.cpp
+
+.PHONY: example test
diff --git a/src/cython/README b/src/cython/README
new file mode 100644
index 00000000..7d2c4491
--- /dev/null
+++ b/src/cython/README
@@ -0,0 +1,3 @@
+
+If you do not want to install the package, just launch the following command to help Python to find the compiled package :
+$> export PYTHONPATH=`pwd`:$PYTHONPATH
diff --git a/src/cython/cgudhi.pxd b/src/cython/cgudhi.pxd
deleted file mode 100644
index 1be7309d..00000000
--- a/src/cython/cgudhi.pxd
+++ /dev/null
@@ -1,29 +0,0 @@
-from libcpp.vector cimport vector
-from libcpp.utility cimport pair
-
-cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
-    cdef cppclass Simplex_tree_options_full_featured:
-        pass
-    cdef cppclass Simplex_tree_options_fast_persistence:
-        pass
-    cdef cppclass Simplex_tree_options_mini:
-        pass
-    cdef cppclass Simplex_tree_interface[T]:
-        Simplex_tree()
-        double filtration()
-        double simplex_filtration(vector[int] simplex)
-        void set_filtration(double filtration)
-        void initialize_filtration()
-        int num_vertices()
-        int num_simplices()
-        void set_dimension(int dimension)
-        int dimension()
-        bint find_simplex(vector[int] simplex)
-        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)
-        vector[pair[vector[int], double]] get_star_tree(vector[int] simplex)
-        vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, int dimension)
-        void graph_expansion(vector[vector[double]] points,int max_dimension,double max_edge_length)
-
-
diff --git a/src/cython/Simplex_tree_example.py b/src/cython/example/Simplex_tree_example.py
index e9459588..e9459588 100755
--- a/src/cython/Simplex_tree_example.py
+++ b/src/cython/example/Simplex_tree_example.py
diff --git a/src/cython/gudhi.pyx b/src/cython/gudhi.pyx
index c5757039..551226c5 100644
--- a/src/cython/gudhi.pyx
+++ b/src/cython/gudhi.pyx
@@ -1,155 +1 @@
-from cython cimport numeric
-from libcpp.vector cimport vector
-from libcpp.utility cimport pair
-
-cimport cgudhi
-
-
-# SimplexTree python interface
-cdef class SimplexTree:
-    cdef cgudhi.Simplex_tree_interface[cgudhi.Simplex_tree_options_full_featured] *thisptr
-    def __cinit__(self, points=None, max_dimension=3, max_edge_length=float('inf')):
-        self.thisptr = new cgudhi.Simplex_tree_interface[cgudhi.Simplex_tree_options_full_featured]()
-        # Constructor from graph expansion
-        if points is not None:
-            self.thisptr.graph_expansion(points,max_dimension,max_edge_length)
-    def __dealloc__(self):
-        if self.thisptr != NULL:
-            del self.thisptr
-    def get_filtration(self):
-        return self.thisptr.filtration()
-    def filtration(self, simplex):
-        return self.thisptr.simplex_filtration(simplex)
-    def set_filtration(self, filtration):
-        self.thisptr.set_filtration(<double>filtration)
-    def initialize_filtration(self):
-        self.thisptr.initialize_filtration()
-    def num_vertices(self):
-        return self.thisptr.num_vertices()
-    def num_simplices(self):
-        return self.thisptr.num_simplices()
-    def dimension(self):
-        return self.thisptr.dimension()
-    def set_dimension(self, dim):
-        self.thisptr.set_dimension(<int>dim)
-    def find(self, simplex):
-        cdef vector[int] complex
-        for i in simplex:
-          complex.push_back(i)
-        return self.thisptr.find_simplex(complex)
-    def insert(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()
-        ct = []
-        for filtered_complex in coface_tree:
-            v = []
-            for vertex in filtered_complex.first:
-                v.append(vertex)
-            ct.append((v,filtered_complex.second))
-        return ct
-    def get_skeleton_tree(self, dim):
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim)
-        ct = []
-        for filtered_complex in coface_tree:
-            v = []
-            for vertex in filtered_complex.first:
-                v.append(vertex)
-            ct.append((v,filtered_complex.second))
-        return ct
-    def get_star_tree(self, simplex):
-        cdef vector[int] complex
-        for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex)
-        ct = []
-        for filtered_complex in coface_tree:
-            v = []
-            for vertex in filtered_complex.first:
-                v.append(vertex)
-            ct.append((v,filtered_complex.second))
-        return ct
-    def get_coface_tree(self, simplex, dim):
-        cdef vector[int] complex
-        for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim)
-        ct = []
-        for filtered_complex in coface_tree:
-            v = []
-            for vertex in filtered_complex.first:
-                v.append(vertex)
-            ct.append((v,filtered_complex.second))
-        return ct
-
-
-cdef class MiniSimplexTree:
-    cdef cgudhi.Simplex_tree_interface[cgudhi.Simplex_tree_options_mini] *thisptr
-    def __cinit__(self):
-        self.thisptr = new cgudhi.Simplex_tree_interface[cgudhi.Simplex_tree_options_mini]()
-    def __dealloc__(self):
-        if self.thisptr != NULL:
-            del self.thisptr
-    def num_vertices(self):
-        return self.thisptr.num_vertices()
-    def num_simplices(self):
-        return self.thisptr.num_simplices()
-    def dimension(self):
-        return self.thisptr.dimension()
-    def set_dimension(self, dim):
-        self.thisptr.set_dimension(<int>dim)
-    def find(self, simplex):
-        cdef vector[int] complex
-        for i in simplex:
-          complex.push_back(i)
-        return self.thisptr.find_simplex(complex)
-    def insert(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()
-        ct = []
-        for filtered_complex in coface_tree:
-            v = []
-            for vertex in filtered_complex.first:
-                v.append(vertex)
-            ct.append((v,filtered_complex.second))
-        return ct
-    def get_skeleton_tree(self, dim):
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim)
-        ct = []
-        for filtered_complex in coface_tree:
-            v = []
-            for vertex in filtered_complex.first:
-                v.append(vertex)
-            ct.append((v,filtered_complex.second))
-        return ct
-    def get_star_tree(self, simplex):
-        cdef vector[int] complex
-        for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex)
-        ct = []
-        for filtered_complex in coface_tree:
-            v = []
-            for vertex in filtered_complex.first:
-                v.append(vertex)
-            ct.append((v,filtered_complex.second))
-        return ct
-    def get_coface_tree(self, simplex, dim):
-        cdef vector[int] complex
-        for i in simplex:
-          complex.push_back(i)
-        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim)
-        ct = []
-        for filtered_complex in coface_tree:
-            v = []
-            for vertex in filtered_complex.first:
-                v.append(vertex)
-            ct.append((v,filtered_complex.second))
-        return ct
+include "src/cython/Simplex_tree.pyx"
diff --git a/src/cython/setup.py b/src/cython/setup.py
index 5942560d..8439a071 100644
--- a/src/cython/setup.py
+++ b/src/cython/setup.py
@@ -6,10 +6,14 @@ gudhi = Extension(
     sources = ['gudhi.pyx',],
     language = 'c++',
     extra_compile_args=['-std=c++11'],
-    include_dirs = ['../include','.'],
+    include_dirs = ['../include','./src/cpp'],
 )
 
 setup(
     name = 'gudhi',
+    author='Vincent Rouvreau',
+    author_email='gudhi-contact@lists.gforge.inria.fr',
+    version='0.1.0',
+    url='http://gudhi.gforge.inria.fr/',
     ext_modules = cythonize(gudhi),
 )
diff --git a/src/cython/Simplex_tree_interface.h b/src/cython/src/cpp/Simplex_tree_interface.h
index dc29bed5..2850d7b6 100644
--- a/src/cython/Simplex_tree_interface.h
+++ b/src/cython/src/cpp/Simplex_tree_interface.h
@@ -56,6 +56,10 @@ class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
     return Simplex_tree<SimplexTreeOptions>::filtration(Simplex_tree<SimplexTreeOptions>::find(complex));
   }
 
+  void remove_maximal_simplex(const Simplex& complex) {
+    return Simplex_tree<SimplexTreeOptions>::remove_maximal_simplex(Simplex_tree<SimplexTreeOptions>::find(complex));
+  }
+
   Complex_tree get_filtered_tree() {
     Complex_tree filtered_tree;
     for (auto f_simplex : Simplex_tree<SimplexTreeOptions>::filtration_simplex_range()) {
diff --git a/src/cython/src/cython/Simplex_tree.pyx b/src/cython/src/cython/Simplex_tree.pyx
new file mode 100644
index 00000000..91ee9dbe
--- /dev/null
+++ b/src/cython/src/cython/Simplex_tree.pyx
@@ -0,0 +1,212 @@
+from cython cimport numeric
+from libcpp.vector cimport vector
+from libcpp.utility cimport pair
+
+cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
+    cdef cppclass Simplex_tree_options_full_featured:
+        pass
+    cdef cppclass Simplex_tree_interface_full_featured "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_full_featured>":
+        Simplex_tree()
+        double filtration()
+        double simplex_filtration(vector[int] simplex)
+        void set_filtration(double filtration)
+        void initialize_filtration()
+        int num_vertices()
+        int num_simplices()
+        void set_dimension(int dimension)
+        int dimension()
+        bint find_simplex(vector[int] simplex)
+        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)
+        vector[pair[vector[int], double]] get_star_tree(vector[int] simplex)
+        vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, int dimension)
+        void graph_expansion(vector[vector[double]] points,int max_dimension,double max_edge_length)
+        void remove_maximal_simplex(vector[int] simplex)
+
+# SimplexTree python interface
+cdef class SimplexTree:
+    cdef Simplex_tree_interface_full_featured *thisptr
+    def __cinit__(self, points=None, max_dimension=3, max_edge_length=float('inf')):
+        self.thisptr = new Simplex_tree_interface_full_featured()
+        # Constructor from graph expansion
+        if points is not None:
+            self.thisptr.graph_expansion(points,max_dimension,max_edge_length)
+    def __dealloc__(self):
+        if self.thisptr != NULL:
+            del self.thisptr
+    def get_filtration(self):
+        return self.thisptr.filtration()
+    def filtration(self, simplex):
+        return self.thisptr.simplex_filtration(simplex)
+    def set_filtration(self, filtration):
+        self.thisptr.set_filtration(<double>filtration)
+    def initialize_filtration(self):
+        self.thisptr.initialize_filtration()
+    def num_vertices(self):
+        return self.thisptr.num_vertices()
+    def num_simplices(self):
+        return self.thisptr.num_simplices()
+    def dimension(self):
+        return self.thisptr.dimension()
+    def set_dimension(self, dim):
+        self.thisptr.set_dimension(<int>dim)
+    def find(self, simplex):
+        cdef vector[int] complex
+        for i in simplex:
+          complex.push_back(i)
+        return self.thisptr.find_simplex(complex)
+    def insert(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()
+        ct = []
+        for filtered_complex in coface_tree:
+            v = []
+            for vertex in filtered_complex.first:
+                v.append(vertex)
+            ct.append((v,filtered_complex.second))
+        return ct
+    def get_skeleton_tree(self, dim):
+        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim)
+        ct = []
+        for filtered_complex in coface_tree:
+            v = []
+            for vertex in filtered_complex.first:
+                v.append(vertex)
+            ct.append((v,filtered_complex.second))
+        return ct
+    def get_star_tree(self, simplex):
+        cdef vector[int] complex
+        for i in simplex:
+          complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex)
+        ct = []
+        for filtered_complex in coface_tree:
+            v = []
+            for vertex in filtered_complex.first:
+                v.append(vertex)
+            ct.append((v,filtered_complex.second))
+        return ct
+    def get_coface_tree(self, simplex, dim):
+        cdef vector[int] complex
+        for i in simplex:
+          complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim)
+        ct = []
+        for filtered_complex in coface_tree:
+            v = []
+            for vertex in filtered_complex.first:
+                v.append(vertex)
+            ct.append((v,filtered_complex.second))
+        return ct
+    def remove_maximal_simplex(self, simplex):
+        self.thisptr.remove_maximal_simplex(simplex)
+
+
+cdef extern from "Simplex_tree_interface.h" namespace "Gudhi":
+    cdef cppclass Simplex_tree_options_mini:
+        pass
+    cdef cppclass Simplex_tree_interface_mini "Gudhi::Simplex_tree_interface<Gudhi::Simplex_tree_options_mini>":
+        Simplex_tree()
+        double filtration()
+        double simplex_filtration(vector[int] simplex)
+        void set_filtration(double filtration)
+        void initialize_filtration()
+        int num_vertices()
+        int num_simplices()
+        void set_dimension(int dimension)
+        int dimension()
+        bint find_simplex(vector[int] simplex)
+        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)
+        vector[pair[vector[int], double]] get_star_tree(vector[int] simplex)
+        vector[pair[vector[int], double]] get_coface_tree(vector[int] simplex, int dimension)
+        void graph_expansion(vector[vector[double]] points,int max_dimension,double max_edge_length)
+        void remove_maximal_simplex(vector[int] simplex)
+
+# SimplexTree python interface
+cdef class MiniSimplexTree:
+    cdef Simplex_tree_interface_mini *thisptr
+    def __cinit__(self, points=None, max_dimension=3, max_edge_length=float('inf')):
+        self.thisptr = new Simplex_tree_interface_mini()
+        # Constructor from graph expansion
+        if points is not None:
+            self.thisptr.graph_expansion(points,max_dimension,max_edge_length)
+    def __dealloc__(self):
+        if self.thisptr != NULL:
+            del self.thisptr
+    def get_filtration(self):
+        return self.thisptr.filtration()
+    def filtration(self, simplex):
+        return self.thisptr.simplex_filtration(simplex)
+    def set_filtration(self, filtration):
+        self.thisptr.set_filtration(<double>filtration)
+    def initialize_filtration(self):
+        self.thisptr.initialize_filtration()
+    def num_vertices(self):
+        return self.thisptr.num_vertices()
+    def num_simplices(self):
+        return self.thisptr.num_simplices()
+    def dimension(self):
+        return self.thisptr.dimension()
+    def set_dimension(self, dim):
+        self.thisptr.set_dimension(<int>dim)
+    def find(self, simplex):
+        cdef vector[int] complex
+        for i in simplex:
+          complex.push_back(i)
+        return self.thisptr.find_simplex(complex)
+    def insert(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()
+        ct = []
+        for filtered_complex in coface_tree:
+            v = []
+            for vertex in filtered_complex.first:
+                v.append(vertex)
+            ct.append((v,filtered_complex.second))
+        return ct
+    def get_skeleton_tree(self, dim):
+        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_skeleton_tree(<int>dim)
+        ct = []
+        for filtered_complex in coface_tree:
+            v = []
+            for vertex in filtered_complex.first:
+                v.append(vertex)
+            ct.append((v,filtered_complex.second))
+        return ct
+    def get_star_tree(self, simplex):
+        cdef vector[int] complex
+        for i in simplex:
+          complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_star_tree(complex)
+        ct = []
+        for filtered_complex in coface_tree:
+            v = []
+            for vertex in filtered_complex.first:
+                v.append(vertex)
+            ct.append((v,filtered_complex.second))
+        return ct
+    def get_coface_tree(self, simplex, dim):
+        cdef vector[int] complex
+        for i in simplex:
+          complex.push_back(i)
+        cdef vector[pair[vector[int], double]] coface_tree = self.thisptr.get_coface_tree(complex, <int>dim)
+        ct = []
+        for filtered_complex in coface_tree:
+            v = []
+            for vertex in filtered_complex.first:
+                v.append(vertex)
+            ct.append((v,filtered_complex.second))
+        return ct
+    def remove_maximal_simplex(self, simplex):
+        self.thisptr.remove_maximal_simplex(simplex)
diff --git a/src/cython/Simplex_tree_UT.py b/src/cython/test/Simplex_tree_UT.py
index 56113370..56113370 100755
--- a/src/cython/Simplex_tree_UT.py
+++ b/src/cython/test/Simplex_tree_UT.py