Moved into trunk

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

5 files changed, 785 insertions, 0 deletions

diff --git a/src/Simplex_tree/example/CMakeLists.txt b/src/Simplex_tree/example/CMakeLists.txt
new file mode 100644
index 00000000..6a392d3b
--- /dev/null
+++ b/src/Simplex_tree/example/CMakeLists.txt
@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 2.6)
+project(GUDHISimplexTreeFromFile)
+
+# NEED TO FIND BOOST NEEDED COMPONENTS TO LINK WITH
+find_package(Boost 1.45.0 COMPONENTS system thread)
+message("Boost_lib = ${Boost_LIBRARIES}")
+
+add_executable ( simplex_tree_from_file simplex_tree_from_file.cpp )
+target_link_libraries(simplex_tree_from_file ${Boost_LIBRARIES})
+   
+add_executable ( simple_simplex_tree simple_simplex_tree.cpp )
+target_link_libraries(simple_simplex_tree ${Boost_LIBRARIES})
+   
+# An example with Simplex-tree using CGAL alpha_shapes_3
+if(GMPXX_FOUND AND GMP_FOUND AND CGAL_FOUND)
+   message("CGAL_lib = ${CGAL_LIBRARIES_DIR}")
+   message("GMPXX_LIBRARIES = ${GMPXX_LIBRARIES}")
+   message("GMP_LIBRARIES = ${GMP_LIBRARIES}")
+
+   add_executable ( simplex_tree_from_alpha_shapes_3 simplex_tree_from_alpha_shapes_3.cpp )
+   target_link_libraries(simplex_tree_from_alpha_shapes_3 ${Boost_LIBRARIES} ${GMPXX_LIBRARIES} ${GMP_LIBRARIES} ${CGAL_LIBRARY})
+endif()  
diff --git a/src/Simplex_tree/example/README b/src/Simplex_tree/example/README
new file mode 100644
index 00000000..210c922b
--- /dev/null
+++ b/src/Simplex_tree/example/README
@@ -0,0 +1,73 @@
+To build the example, run in a Terminal:
+
+cd /path-to-gudhi/
+cmake .
+cd /path-to-example/
+make
+
+
+Example of use :
+
+*** Simple simplex tree construction
+
+./simple_simplex_tree
+
+********************************************************************
+EXAMPLE OF SIMPLE INSERTION
+   * INSERT 0
+   + 0 INSERTED
+   * INSERT 1
+   + 1 INSERTED
+   * INSERT (0,1)
+   + (0,1) INSERTED
+   * INSERT 2
+   + 2 INSERTED
+   * INSERT (2,0)
+   + (2,0) INSERTED
+   * INSERT (2,1)
+   + (2,1) INSERTED
+   * INSERT (2,1,0)
+   + (2,1,0) INSERTED
+   * INSERT 3
+   + 3 INSERTED
+   * INSERT (3,0)
+   + (3,0) INSERTED
+   * INSERT 0 (already inserted)
+   - 0 NOT INSERTED
+   * INSERT (2,1,0) (already inserted)
+   - (2,1,0) NOT INSERTED
+********************************************************************
+* The complex contains 9 simplices
+   - dimension 2   - filtration 0.4
+* Iterator on Simplices in the filtration, with [filtration value]:
+   [0.1] 0 
+   [0.1] 1 
+   [0.1] 2 
+   [0.1] 3 
+   [0.2] 1 0 
+   [0.2] 2 0 
+   [0.2] 2 1 
+   [0.2] 3 0 
+   [0.3] 2 1 0 
+
+*** Simplex tree construction with Z/2Z coefficients on points sampling a Klein bottle:
+
+./simplex_tree_from_file ../../../data/points/Klein_bottle_complex.txt 2
+Insert the 1-skeleton in the simplex tree in 0 s. 
+Expand the simplex tree in 0 s. 
+Information of the Simplex Tree: 
+  Number of vertices = 10   Number of simplices = 82
+
+with Z/3Z coefficients:
+
+./simplex_tree_from_file ../../../data/points/Klein_bottle_complex.txt 3
+
+Insert the 1-skeleton in the simplex tree in 0 s.
+Expand the simplex tree in 0 s.
+Information of the Simplex Tree:
+  Number of vertices = 10   Number of simplices = 106
+
+*** Simplex_tree computed from a Alpha-shapes 3:
+    [ Requires CGAL, GMP and GMPXX to be installed]
+
+./simplex_tree_from_alpha_shapes_3 ../../../data/points/bunny_5000
diff --git a/src/Simplex_tree/example/simple_simplex_tree.cpp b/src/Simplex_tree/example/simple_simplex_tree.cpp
new file mode 100644
index 00000000..0ed2039f
--- /dev/null
+++ b/src/Simplex_tree/example/simple_simplex_tree.cpp
@@ -0,0 +1,302 @@
+/*    This file is part of the Gudhi Library. The Gudhi library
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++
+ *    library for computational topology.
+ *
+ *    Author(s):       Vincent Rouvreau
+ *
+ *    Copyright (C) 2014  INRIA Sophia Antipolis-Méditerranée (France)
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <iostream>
+#include <ctime>
+#include "gudhi/graph_simplicial_complex.h"
+#include "gudhi/Simplex_tree.h"
+
+using namespace Gudhi;
+
+typedef std::vector< Vertex_handle > typeVectorVertex;
+typedef std::pair<typeVectorVertex, Filtration_value> typeSimplex;
+typedef std::pair< Simplex_tree<>::Simplex_handle, bool > typePairSimplexBool;
+
+int main (int argc, char * const argv[])
+{
+	const Filtration_value FIRST_FILTRATION_VALUE = 0.1;
+	const Filtration_value SECOND_FILTRATION_VALUE = 0.2;
+	const Filtration_value THIRD_FILTRATION_VALUE = 0.3;
+	const Filtration_value FOURTH_FILTRATION_VALUE = 0.4;
+	Vertex_handle FIRST_VERTEX_HANDLE =  (Vertex_handle)0;
+	Vertex_handle SECOND_VERTEX_HANDLE = (Vertex_handle)1;
+	Vertex_handle THIRD_VERTEX_HANDLE = (Vertex_handle)2;
+	Vertex_handle FOURTH_VERTEX_HANDLE = (Vertex_handle)3;
+
+	// TEST OF INSERTION
+	std::cout << "********************************************************************" << std::endl;
+	std::cout << "EXAMPLE OF SIMPLE INSERTION" << std::endl;
+	//Construct the Simplex Tree
+	Simplex_tree<> simplexTree;
+
+	// Simplex to be inserted:
+	//    1
+	//    o
+	//   /X\
+	//  o---o---o
+	//  2   0   3
+
+	// ++ FIRST
+	std::cout << "   * INSERT 0" << std::endl;
+	typeVectorVertex firstSimplexVector;
+	firstSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+	typeSimplex firstSimplex = std::make_pair(firstSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+	typePairSimplexBool returnValue =
+			simplexTree.insert ( firstSimplex.first, firstSimplex.second );
+
+	if (returnValue.second == true)
+	{
+		std::cout << "   + 0 INSERTED" << std::endl;
+		int nb_simplices = simplexTree.num_simplices() + 1;
+		simplexTree.set_num_simplices(nb_simplices);
+	}
+	else
+	{
+		std::cout << "   - 0 NOT INSERTED" << std::endl;
+	}
+
+	// ++ SECOND
+	std::cout << "   * INSERT 1" << std::endl;
+	typeVectorVertex secondSimplexVector;
+	secondSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+	typeSimplex secondSimplex = std::make_pair(secondSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+	returnValue =
+			simplexTree.insert ( secondSimplex.first, secondSimplex.second );
+
+	if (returnValue.second == true)
+	{
+		std::cout << "   + 1 INSERTED" << std::endl;
+		int nb_simplices = simplexTree.num_simplices() + 1;
+		simplexTree.set_num_simplices(nb_simplices);
+	}
+	else
+	{
+		std::cout << "   - 1 NOT INSERTED" << std::endl;
+	}
+
+	// ++ THIRD
+	std::cout << "   * INSERT (0,1)" << std::endl;
+	typeVectorVertex thirdSimplexVector;
+	thirdSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+	thirdSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+	typeSimplex thirdSimplex = std::make_pair(thirdSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+	returnValue =
+			simplexTree.insert ( thirdSimplex.first, thirdSimplex.second );
+
+	if (returnValue.second == true)
+	{
+		std::cout << "   + (0,1) INSERTED" << std::endl;
+		int nb_simplices = simplexTree.num_simplices() + 1;
+		simplexTree.set_num_simplices(nb_simplices);
+	}
+	else
+	{
+		std::cout << "   - (0,1) NOT INSERTED" << std::endl;
+	}
+
+	// ++ FOURTH
+	std::cout << "   * INSERT 2" << std::endl;
+	typeVectorVertex fourthSimplexVector;
+	fourthSimplexVector.push_back(THIRD_VERTEX_HANDLE);
+	typeSimplex fourthSimplex = std::make_pair(fourthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+	returnValue =
+			simplexTree.insert ( fourthSimplex.first, fourthSimplex.second );
+
+	if (returnValue.second == true)
+	{
+		std::cout << "   + 2 INSERTED" << std::endl;
+		int nb_simplices = simplexTree.num_simplices() + 1;
+		simplexTree.set_num_simplices(nb_simplices);
+	}
+	else
+	{
+		std::cout << "   - 2 NOT INSERTED" << std::endl;
+	}
+
+	// ++ FIFTH
+	std::cout << "   * INSERT (2,0)" << std::endl;
+	typeVectorVertex fifthSimplexVector;
+	fifthSimplexVector.push_back(THIRD_VERTEX_HANDLE);
+	fifthSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+	typeSimplex fifthSimplex = std::make_pair(fifthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+	returnValue =
+			simplexTree.insert ( fifthSimplex.first, fifthSimplex.second );
+
+	if (returnValue.second == true)
+	{
+		std::cout << "   + (2,0) INSERTED" << std::endl;
+		int nb_simplices = simplexTree.num_simplices() + 1;
+		simplexTree.set_num_simplices(nb_simplices);
+	}
+	else
+	{
+		std::cout << "   - (2,0) NOT INSERTED" << std::endl;
+	}
+
+	// ++ SIXTH
+	std::cout << "   * INSERT (2,1)" << std::endl;
+	typeVectorVertex sixthSimplexVector;
+	sixthSimplexVector.push_back(THIRD_VERTEX_HANDLE);
+	sixthSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+	typeSimplex sixthSimplex = std::make_pair(sixthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+	returnValue =
+			simplexTree.insert ( sixthSimplex.first, sixthSimplex.second );
+
+	if (returnValue.second == true)
+	{
+		std::cout << "   + (2,1) INSERTED" << std::endl;
+		int nb_simplices = simplexTree.num_simplices() + 1;
+		simplexTree.set_num_simplices(nb_simplices);
+	}
+	else
+	{
+		std::cout << "   - (2,1) NOT INSERTED" << std::endl;
+	}
+
+	// ++ SEVENTH
+	std::cout << "   * INSERT (2,1,0)" << std::endl;
+	typeVectorVertex seventhSimplexVector;
+	seventhSimplexVector.push_back(THIRD_VERTEX_HANDLE);
+	seventhSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+	seventhSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+	typeSimplex seventhSimplex = std::make_pair(seventhSimplexVector, Filtration_value(THIRD_FILTRATION_VALUE));
+	returnValue =
+			simplexTree.insert ( seventhSimplex.first, seventhSimplex.second );
+
+	if (returnValue.second == true)
+	{
+		std::cout << "   + (2,1,0) INSERTED" << std::endl;
+		int nb_simplices = simplexTree.num_simplices() + 1;
+		simplexTree.set_num_simplices(nb_simplices);
+	}
+	else
+	{
+		std::cout << "   - (2,1,0) NOT INSERTED" << std::endl;
+	}
+
+	// ++ EIGHTH
+	std::cout << "   * INSERT 3" << std::endl;
+	typeVectorVertex eighthSimplexVector;
+	eighthSimplexVector.push_back(FOURTH_VERTEX_HANDLE);
+	typeSimplex eighthSimplex = std::make_pair(eighthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+	returnValue =
+			simplexTree.insert ( eighthSimplex.first, eighthSimplex.second );
+
+	if (returnValue.second == true)
+	{
+		std::cout << "   + 3 INSERTED" << std::endl;
+		int nb_simplices = simplexTree.num_simplices() + 1;
+		simplexTree.set_num_simplices(nb_simplices);
+	}
+	else
+	{
+		std::cout << "   - 3 NOT INSERTED" << std::endl;
+	}
+
+	// ++ NINETH
+	std::cout << "   * INSERT (3,0)" << std::endl;
+	typeVectorVertex ninethSimplexVector;
+	ninethSimplexVector.push_back(FOURTH_VERTEX_HANDLE);
+	ninethSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+	typeSimplex ninethSimplex = std::make_pair(ninethSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+	returnValue =
+			simplexTree.insert ( ninethSimplex.first, ninethSimplex.second );
+
+	if (returnValue.second == true)
+	{
+		std::cout << "   + (3,0) INSERTED" << std::endl;
+		int nb_simplices = simplexTree.num_simplices() + 1;
+		simplexTree.set_num_simplices(nb_simplices);
+	}
+	else
+	{
+		std::cout << "   - (3,0) NOT INSERTED" << std::endl;
+	}
+
+	// ++ TENTH
+	std::cout << "   * INSERT 0 (already inserted)" << std::endl;
+	typeVectorVertex tenthSimplexVector;
+	tenthSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+	typeSimplex tenthSimplex = std::make_pair(tenthSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE)); // With a different filtration value
+	returnValue =
+			simplexTree.insert ( tenthSimplex.first, tenthSimplex.second );
+
+	if (returnValue.second == true)
+	{
+		std::cout << "   + 0 INSERTED" << std::endl;
+		int nb_simplices = simplexTree.num_simplices() + 1;
+		simplexTree.set_num_simplices(nb_simplices);
+	}
+	else
+	{
+		std::cout << "   - 0 NOT INSERTED" << std::endl;
+	}
+
+	// ++ ELEVENTH
+	std::cout << "   * INSERT (2,1,0) (already inserted)" << std::endl;
+	typeVectorVertex eleventhSimplexVector;
+	eleventhSimplexVector.push_back(THIRD_VERTEX_HANDLE);
+	eleventhSimplexVector.push_back(SECOND_VERTEX_HANDLE);
+	eleventhSimplexVector.push_back(FIRST_VERTEX_HANDLE);
+	typeSimplex eleventhSimplex = std::make_pair(eleventhSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
+	returnValue =
+			simplexTree.insert ( eleventhSimplex.first, eleventhSimplex.second );
+
+	if (returnValue.second == true)
+	{
+		std::cout << "   + (2,1,0) INSERTED" << std::endl;
+		int nb_simplices = simplexTree.num_simplices() + 1;
+		simplexTree.set_num_simplices(nb_simplices);
+	}
+	else
+	{
+		std::cout << "   - (2,1,0) NOT INSERTED" << std::endl;
+	}
+
+	// ++ GENERAL VARIABLE SET
+	simplexTree.set_filtration(FOURTH_FILTRATION_VALUE); // Max filtration value
+	simplexTree.set_dimension(2); // Max dimension = 2 -> (2,1,0)
+
+	std::cout << "********************************************************************" << std::endl;
+	// Display the Simplex_tree - Can not be done in the middle of 2 inserts
+	std::cout << "* The complex contains " << simplexTree.num_simplices() << " simplices" << std::endl;
+	std::cout << "   - dimension " << simplexTree.dimension() << "   - filtration " << simplexTree.filtration() << std::endl;
+	std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+	for( auto f_simplex : simplexTree.filtration_simplex_range() )
+	{
+		std::cout << "   " << "[" << simplexTree.filtration(f_simplex) << "] ";
+		for( auto vertex : simplexTree.simplex_vertex_range(f_simplex) )
+		{
+			std::cout << (int)vertex << " ";
+		}
+		std::cout << std::endl;
+	}
+	//   [0.1] 0
+	//   [0.1] 1
+	//   [0.1] 2
+	//   [0.1] 3
+	//   [0.2] 1 0
+	//   [0.2] 2 0
+	//   [0.2] 2 1
+	//   [0.2] 3 0
+	//   [0.3] 2 1 0
+}
diff --git a/src/Simplex_tree/example/simplex_tree_from_alpha_shapes_3.cpp b/src/Simplex_tree/example/simplex_tree_from_alpha_shapes_3.cpp
new file mode 100644
index 00000000..dd76dfcf
--- /dev/null
+++ b/src/Simplex_tree/example/simplex_tree_from_alpha_shapes_3.cpp
@@ -0,0 +1,284 @@
+ /*    This file is part of the Gudhi Library. The Gudhi library
+  *    (Geometric Understanding in Higher Dimensions) is a generic C++
+  *    library for computational topology.
+  *
+  *    Author(s):       Vincent Rouvreau
+  *
+  *    Copyright (C) 2014  INRIA Saclay (France)
+  *
+  *    This program is free software: you can redistribute it and/or modify
+  *    it under the terms of the GNU General Public License as published by
+  *    the Free Software Foundation, either version 3 of the License, or
+  *    (at your option) any later version.
+  *
+  *    This program is distributed in the hope that it will be useful,
+  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  *    GNU General Public License for more details.
+  *
+  *    You should have received a copy of the GNU General Public License
+  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  */
+
+#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
+#include <CGAL/Delaunay_triangulation_3.h>
+#include <CGAL/Alpha_shape_3.h>
+#include <CGAL/iterator.h>
+
+#include <fstream>
+
+#include "gudhi/graph_simplicial_complex.h"
+#include "gudhi/Simplex_tree.h"
+#include <boost/variant.hpp>
+
+// Alpha_shape_3 templates type definitions
+typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
+typedef CGAL::Alpha_shape_vertex_base_3<Kernel>             Vb;
+typedef CGAL::Alpha_shape_cell_base_3<Kernel>               Fb;
+typedef CGAL::Triangulation_data_structure_3<Vb,Fb>         Tds;
+typedef CGAL::Delaunay_triangulation_3<Kernel,Tds>          Triangulation_3;
+typedef CGAL::Alpha_shape_3<Triangulation_3>                Alpha_shape_3;
+
+// From file type definition
+typedef Kernel::Point_3                                     Point;
+
+// filtration with alpha values needed type definition
+typedef Alpha_shape_3::FT Alpha_value_type;
+typedef CGAL::Object      Object;
+typedef CGAL::Dispatch_output_iterator<
+  CGAL::cpp11::tuple<Object, Alpha_value_type>,
+  CGAL::cpp11::tuple<std::back_insert_iterator< std::vector<Object> >, std::back_insert_iterator< std::vector<Alpha_value_type> >
+                     > > Dispatch;
+typedef Alpha_shape_3::Cell_handle   Cell_handle;
+typedef Alpha_shape_3::Facet         Facet;
+typedef Alpha_shape_3::Edge          Edge;
+typedef std::list<Alpha_shape_3::Vertex_handle> Vertex_list;
+
+// gudhi type definition
+typedef Gudhi::Simplex_tree<>::Vertex_handle Simplex_tree_vertex;
+typedef std::map<Alpha_shape_3::Vertex_handle, Simplex_tree_vertex > Alpha_shape_simplex_tree_map;
+typedef std::pair<Alpha_shape_3::Vertex_handle, Simplex_tree_vertex> Alpha_shape_simplex_tree_pair;
+typedef std::vector< Simplex_tree_vertex > Simplex_tree_vector_vertex;
+
+//#define DEBUG_TRACES
+
+Vertex_list from (const Cell_handle& ch)
+{
+	Vertex_list the_list;
+	for (auto i = 0; i < 4; i++)
+	{
+#ifdef DEBUG_TRACES
+		std::cout << "from cell[" << i << "]=" << ch->vertex(i)->point() << std::endl;
+#endif // DEBUG_TRACES
+		the_list.push_back(ch->vertex(i));
+	}
+	return the_list;
+}
+Vertex_list from (const Facet& fct)
+{
+	Vertex_list the_list;
+	for (auto i = 0; i < 4; i++)
+	{
+		if (fct.second != i)
+		{
+#ifdef DEBUG_TRACES
+			std::cout << "from facet=[" << i << "]" << fct.first->vertex(i)->point() << std::endl;
+#endif // DEBUG_TRACES
+			the_list.push_back(fct.first->vertex(i));
+		}
+	}
+	return the_list;
+}
+Vertex_list from (const Edge& edg)
+{
+	Vertex_list the_list;
+	for (auto i = 0; i < 4; i++)
+	{
+		if ((edg.second == i) ||(edg.third == i))
+		{
+#ifdef DEBUG_TRACES
+			std::cout << "from edge[" << i << "]=" << edg.first->vertex(i)->point() << std::endl;
+#endif // DEBUG_TRACES
+			the_list.push_back(edg.first->vertex(i));
+		}
+	}
+	return the_list;
+}
+Vertex_list from (const Alpha_shape_3::Vertex_handle& vh)
+{
+	Vertex_list the_list;
+#ifdef DEBUG_TRACES
+	std::cout << "from vertex=" << vh->point() << std::endl;
+#endif // DEBUG_TRACES
+	the_list.push_back(vh);
+	return the_list;
+}
+
+
+int main (int argc, char * const argv[])
+{
+	// program args management
+	if (argc != 2) {
+		std::cerr << "Usage: " << argv[0]
+		                               << " path_to_file_graph \n";
+		return 0; // ----- >>
+	}
+
+	// Read points from file
+	std::string filegraph   = argv[1];
+	std::list<Point> lp;
+	std::ifstream is(filegraph.c_str());
+	int n;
+	is >> n;
+#ifdef DEBUG_TRACES
+	std::cout << "Reading " << n << " points " << std::endl;
+#endif // DEBUG_TRACES
+	Point p;
+	for( ; n>0 ; n--)    {
+		is >> p;
+		lp.push_back(p);
+	}
+
+	// alpha shape construction from points
+	Alpha_shape_3 as(lp.begin(),lp.end());
+#ifdef DEBUG_TRACES
+	std::cout << "Alpha shape computed in REGULARIZED mode by default" << std::endl;
+#endif // DEBUG_TRACES
+
+	// filtration with alpha values from alpha shape
+	std::vector<Object> the_objects;
+	std::vector<Alpha_value_type> the_alpha_values;
+
+	Dispatch disp = CGAL::dispatch_output<Object, Alpha_value_type>( std::back_inserter(the_objects), std::back_inserter(the_alpha_values));
+
+	as.filtration_with_alpha_values(disp);
+#ifdef DEBUG_TRACES
+	std::cout << "filtration_with_alpha_values returns : " << the_objects.size() << " objects" << std::endl;
+#endif // DEBUG_TRACES
+
+	Alpha_shape_3::size_type count_vertices = 0;
+	Alpha_shape_3::size_type count_edges    = 0;
+	Alpha_shape_3::size_type count_facets   = 0;
+	Alpha_shape_3::size_type count_cells    = 0;
+
+	// Loop on objects vector
+	Vertex_list vertex_list;
+	Gudhi::Simplex_tree<> simplex_tree;
+	Alpha_shape_simplex_tree_map map_cgal_simplex_tree;
+	std::vector<Alpha_value_type>::iterator the_alpha_value_iterator = the_alpha_values.begin();
+	for(auto object_iterator: the_objects)
+	{
+		// Retrieve Alpha shape vertex list from object
+		if (const Cell_handle* cell = CGAL::object_cast<Cell_handle>(&object_iterator))
+		{
+			vertex_list = from(*cell);
+			count_cells++;
+		}
+		else if (const Facet* facet = CGAL::object_cast<Facet>(&object_iterator))
+		{
+			vertex_list = from(*facet);
+			count_facets++;
+		}
+		else if (const Edge* edge = CGAL::object_cast<Edge>(&object_iterator))
+		{
+			vertex_list = from(*edge);
+			count_edges++;
+		}
+		else if (const Alpha_shape_3::Vertex_handle* vertex = CGAL::object_cast<Alpha_shape_3::Vertex_handle>(&object_iterator))
+		{
+			count_vertices++;
+			vertex_list = from(*vertex);
+		}
+		// Construction of the vector of simplex_tree vertex from list of alpha_shapes vertex
+		Simplex_tree_vector_vertex the_simplex_tree;
+		for (auto the_alpha_shape_vertex:vertex_list)
+		{
+			Alpha_shape_simplex_tree_map::iterator the_map_iterator = map_cgal_simplex_tree.find(the_alpha_shape_vertex);
+			if (the_map_iterator == map_cgal_simplex_tree.end())
+			{
+				// alpha shape not found
+				Simplex_tree_vertex vertex = map_cgal_simplex_tree.size();
+#ifdef DEBUG_TRACES
+				std::cout << "vertex [" << the_alpha_shape_vertex->point() << "] not found - insert " << vertex << std::endl;
+#endif // DEBUG_TRACES
+				the_simplex_tree.push_back(vertex);
+				map_cgal_simplex_tree.insert(Alpha_shape_simplex_tree_pair(the_alpha_shape_vertex,vertex));
+			} else
+			{
+				// alpha shape found
+				Simplex_tree_vertex vertex = the_map_iterator->second;
+#ifdef DEBUG_TRACES
+				std::cout << "vertex [" << the_alpha_shape_vertex->point() << "] found in " << vertex << std::endl;
+#endif // DEBUG_TRACES
+				the_simplex_tree.push_back(vertex);
+			}
+		}
+		// Construction of the simplex_tree
+#ifdef DEBUG_TRACES
+		std::cout << "filtration = " << *the_alpha_value_iterator << std::endl;
+#endif // DEBUG_TRACES
+		simplex_tree.insert(the_simplex_tree, *the_alpha_value_iterator);
+		if (the_alpha_value_iterator != the_alpha_values.end())
+			++the_alpha_value_iterator;
+		else
+			std::cout << "This shall not happen" << std::endl;
+	}
+#ifdef DEBUG_TRACES
+	std::cout << "vertices \t\t" << count_vertices << std::endl;
+	std::cout << "edges \t\t"    << count_edges << std::endl;
+	std::cout << "facets \t\t"   << count_facets << std::endl;
+	std::cout << "cells \t\t"    << count_cells << std::endl;
+
+
+	std::cout << "Information of the Simplex Tree: " << std::endl;
+	std::cout << "  Number of vertices = " << simplex_tree.num_vertices() << " ";
+	std::cout << "  Number of simplices = " << simplex_tree.num_simplices() << std::endl << std::endl;
+#endif // DEBUG_TRACES
+
+#ifdef DEBUG_TRACES
+	std::cout << "Iterator on vertices: " << std::endl;
+	for( auto vertex : simplex_tree.complex_vertex_range() )
+	{ std::cout << vertex << " "; }
+#endif // DEBUG_TRACES
+
+	std::cout << simplex_tree << std::endl;
+
+#ifdef DEBUG_TRACES
+	std::cout << std::endl << std::endl << "Iterator on simplices: " << std::endl;
+	for( auto simplex : simplex_tree.complex_simplex_range() )
+	{
+		std::cout << "   ";
+		for( auto vertex : simplex_tree.simplex_vertex_range(simplex) ) { std::cout << vertex << " "; }
+		std::cout << std::endl;
+	}
+#endif // DEBUG_TRACES
+#ifdef DEBUG_TRACES
+	std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, with [filtration value]:" << std::endl;
+	for( auto f_simplex : simplex_tree.filtration_simplex_range() )
+	{ std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+	for( auto vertex : simplex_tree.simplex_vertex_range(f_simplex) )
+	{ std::cout << vertex << " "; }
+	std::cout << std::endl;
+	}
+#endif // DEBUG_TRACES
+#ifdef DEBUG_TRACES
+	std::cout << std::endl << std::endl << "Iterator on Simplices in the filtration, and their boundary simplices:" << std::endl;
+	for( auto f_simplex : simplex_tree.filtration_simplex_range() )
+	{
+		std::cout << "   " << "[" << simplex_tree.filtration(f_simplex) << "] ";
+		for( auto vertex : simplex_tree.simplex_vertex_range(f_simplex) )
+		{ std::cout << vertex << " "; }
+		std::cout << std::endl;
+
+		for( auto b_simplex : simplex_tree.boundary_simplex_range(f_simplex) )
+		{
+			std::cout << "      " << "[" << simplex_tree.filtration(b_simplex) << "] ";
+			for( auto vertex : simplex_tree.simplex_vertex_range(b_simplex) )
+			{ std::cout << vertex << " "; }
+			std::cout << std::endl;
+		}
+	}
+#endif // DEBUG_TRACES
+
+	return 0;
+}
diff --git a/src/Simplex_tree/example/simplex_tree_from_file.cpp b/src/Simplex_tree/example/simplex_tree_from_file.cpp
new file mode 100644
index 00000000..20e8f067
--- /dev/null
+++ b/src/Simplex_tree/example/simplex_tree_from_file.cpp
@@ -0,0 +1,104 @@
+ /*    This file is part of the Gudhi Library. The Gudhi library
+  *    (Geometric Understanding in Higher Dimensions) is a generic C++
+  *    library for computational topology.
+  *
+  *    Author(s):       Clément Maria
+  *
+  *    Copyright (C) 2014  INRIA Sophia Antipolis-Méditerranée (France)
+  *
+  *    This program is free software: you can redistribute it and/or modify
+  *    it under the terms of the GNU General Public License as published by
+  *    the Free Software Foundation, either version 3 of the License, or
+  *    (at your option) any later version.
+  *
+  *    This program is distributed in the hope that it will be useful,
+  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  *    GNU General Public License for more details.
+  *
+  *    You should have received a copy of the GNU General Public License
+  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  */
+
+#include <iostream>
+#include <ctime>
+#include "gudhi/reader_utils.h"
+#include "gudhi/Simplex_tree.h"
+
+using namespace Gudhi;
+
+int main (int argc, char * const argv[])
+{
+  if (argc != 3) {
+    std::cerr << "Usage: " << argv[0]
+      << " path_to_file_graph max_dim \n";
+    return 0;
+  }
+  std::string filegraph   = argv[1];
+  int max_dim       = atoi(argv[2]);
+
+  clock_t start, end;
+  //Construct the Simplex Tree
+  Simplex_tree<> st;
+
+  start = clock();
+  auto g = read_graph(filegraph);
+  st.insert_graph (g); //insert the graph in the simplex tree as 1-skeleton
+  end = clock();
+  std::cout << "Insert the 1-skeleton in the simplex tree in "
+       << (double)(end-start)/CLOCKS_PER_SEC << " s. \n";
+
+  start = clock();
+  st.expansion ( max_dim ); //expand the 1-skeleton until dimension max_dim
+  end = clock();
+  std::cout << "max_dim = " << max_dim << "\n";
+  std::cout << "Expand the simplex tree in "
+       << (double)(end-start)/CLOCKS_PER_SEC << " s. \n";
+
+  std::cout << "Information of the Simplex Tree: " << std::endl;
+  std::cout << "  Number of vertices = " << st.num_vertices() << " ";
+  std::cout << "  Number of simplices = " << st.num_simplices() << std::endl;
+  std::cout << std::endl << std::endl;
+
+  std::cout << "Iterator on vertices: ";
+    for( auto vertex : st.complex_vertex_range() ) { std::cout << vertex << " "; }
+
+  std::cout << std::endl;
+
+  std::cout << std::endl << std::endl;
+
+  std::cout << "Iterator on simplices: " << std::endl;
+  for( auto simplex : st.complex_simplex_range() )
+  {
+    std::cout << "   ";
+    for( auto vertex : st.simplex_vertex_range(simplex) ) { std::cout << vertex << " "; }
+    std::cout << std::endl;
+  }
+
+  std::cout << std::endl << 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) << "] ";
+    for( auto vertex : st.simplex_vertex_range(f_simplex) )
+      { std::cout << vertex << " "; } std::cout << std::endl;
+  }
+
+  std::cout << std::endl << std::endl;
+
+  std::cout << "Iterator on Simplices in the filtration, and their boundary simplices:" << std::endl;
+  for( auto f_simplex : st.filtration_simplex_range() )
+  {
+    std::cout << "   " << "[" << st.filtration(f_simplex) << "] ";
+    for( auto vertex : st.simplex_vertex_range(f_simplex) )
+      { std::cout << vertex << " "; } std::cout << std::endl;
+
+    for( auto b_simplex : st.boundary_simplex_range(f_simplex) )
+    {
+      std::cout << "      " << "[" << st.filtration(b_simplex) << "] ";
+    for( auto vertex : st.simplex_vertex_range(b_simplex) )
+      { std::cout << vertex << " "; } std::cout << std::endl;
+    }
+  }
+  return 0;
+}