summaryrefslogtreecommitdiff
path: root/example/Simplex_tree
diff options
context:
space:
mode:
Diffstat (limited to 'example/Simplex_tree')
-rw-r--r--example/Simplex_tree/CMakeLists.txt29
-rw-r--r--example/Simplex_tree/README73
-rw-r--r--example/Simplex_tree/mini_simplex_tree.cpp69
-rw-r--r--example/Simplex_tree/simple_simplex_tree.cpp253
-rw-r--r--example/Simplex_tree/simplex_tree_from_alpha_shapes_3.cpp276
-rw-r--r--example/Simplex_tree/simplex_tree_from_cliques_of_graph.cpp114
6 files changed, 814 insertions, 0 deletions
diff --git a/example/Simplex_tree/CMakeLists.txt b/example/Simplex_tree/CMakeLists.txt
new file mode 100644
index 00000000..9314a805
--- /dev/null
+++ b/example/Simplex_tree/CMakeLists.txt
@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 2.6)
+project(Simplex_tree_examples)
+
+add_executable ( simplex_tree_from_cliques_of_graph simplex_tree_from_cliques_of_graph.cpp )
+if (TBB_FOUND)
+ target_link_libraries(simplex_tree_from_cliques_of_graph ${TBB_LIBRARIES})
+endif()
+add_test(simplex_tree_from_cliques_of_graph_2 ${CMAKE_CURRENT_BINARY_DIR}/simplex_tree_from_cliques_of_graph ${CMAKE_SOURCE_DIR}/data/points/Klein_bottle_complex.txt 2)
+add_test(simplex_tree_from_cliques_of_graph_3 ${CMAKE_CURRENT_BINARY_DIR}/simplex_tree_from_cliques_of_graph ${CMAKE_SOURCE_DIR}/data/points/Klein_bottle_complex.txt 3)
+
+add_executable ( simple_simplex_tree simple_simplex_tree.cpp )
+if (TBB_FOUND)
+ target_link_libraries(simple_simplex_tree ${TBB_LIBRARIES})
+endif()
+add_test(simple_simplex_tree ${CMAKE_CURRENT_BINARY_DIR}/simple_simplex_tree)
+
+add_executable ( mini_simplex_tree mini_simplex_tree.cpp )
+add_test(mini_simplex_tree ${CMAKE_CURRENT_BINARY_DIR}/mini_simplex_tree)
+
+
+# An example with Simplex-tree using CGAL alpha_shapes_3
+if(GMP_FOUND AND CGAL_FOUND)
+ add_executable ( simplex_tree_from_alpha_shapes_3 simplex_tree_from_alpha_shapes_3.cpp )
+ target_link_libraries(simplex_tree_from_alpha_shapes_3 ${GMP_LIBRARIES} ${CGAL_LIBRARY} ${Boost_SYSTEM_LIBRARY})
+ if (TBB_FOUND)
+ target_link_libraries(simplex_tree_from_alpha_shapes_3 ${TBB_LIBRARIES})
+ endif()
+ add_test(simplex_tree_from_alpha_shapes_3 ${CMAKE_CURRENT_BINARY_DIR}/simplex_tree_from_alpha_shapes_3 ${CMAKE_SOURCE_DIR}/data/points/bunny_5000)
+endif()
diff --git a/example/Simplex_tree/README b/example/Simplex_tree/README
new file mode 100644
index 00000000..e37af790
--- /dev/null
+++ b/example/Simplex_tree/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 weighted graph Klein bottle file:
+
+./simplex_tree_from_cliques_of_graph ../../../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_cliques_of_graph ../../../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 and displayed from a 3D alpha complex:
+ [ Requires CGAL, GMP and GMPXX to be installed]
+
+./simplex_tree_from_alpha_shapes_3 ../../../data/points/bunny_5000
diff --git a/example/Simplex_tree/mini_simplex_tree.cpp b/example/Simplex_tree/mini_simplex_tree.cpp
new file mode 100644
index 00000000..7e48aaaf
--- /dev/null
+++ b/example/Simplex_tree/mini_simplex_tree.cpp
@@ -0,0 +1,69 @@
+/* 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): Marc Glisse
+ *
+ * Copyright (C) 2015 INRIA Saclay - Ile-de-France (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 <gudhi/Simplex_tree.h>
+#include <iostream>
+#include <initializer_list>
+
+using namespace Gudhi;
+
+struct MyOptions : Simplex_tree_options_full_featured {
+ // Not doing persistence, so we don't need those
+ static const bool store_key = false;
+ static const bool store_filtration = false;
+ // I have few vertices
+ typedef short Vertex_handle;
+};
+typedef Simplex_tree<MyOptions> ST;
+
+// Dictionary should be private, but for now this is the easiest way.
+static_assert(sizeof(ST::Dictionary::value_type) < sizeof(Simplex_tree<>::Dictionary::value_type),
+ "Not storing the filtration and key should save some space");
+
+int main() {
+ ST st;
+
+ /* Complex to build. */
+ /* 1 */
+ /* o */
+ /* /X\ */
+ /* o---o---o */
+ /* 2 0 3 */
+
+ auto triangle012 = {0, 1, 2};
+ auto edge03 = {0, 3};
+ st.insert_simplex_and_subfaces(triangle012);
+ st.insert_simplex_and_subfaces(edge03);
+ // FIXME: Remove this line
+ st.set_dimension(2);
+
+ auto edge02 = {0, 2};
+ ST::Simplex_handle e = st.find(edge02);
+ // We are not using filtrations so everything has value 0
+ assert(st.filtration(e) == 0);
+ for (ST::Simplex_handle t : st.cofaces_simplex_range(e, 1)) {
+ // Only coface is 012
+ for (ST::Vertex_handle v : st.simplex_vertex_range(t)) // v in { 0, 1, 2 }
+ std::cout << v;
+ std::cout << '\n';
+ }
+}
diff --git a/example/Simplex_tree/simple_simplex_tree.cpp b/example/Simplex_tree/simple_simplex_tree.cpp
new file mode 100644
index 00000000..5146b906
--- /dev/null
+++ b/example/Simplex_tree/simple_simplex_tree.cpp
@@ -0,0 +1,253 @@
+/* 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 <gudhi/graph_simplicial_complex.h>
+#include <gudhi/Simplex_tree.h>
+
+#include <iostream>
+#include <utility> // for pair
+#include <vector>
+
+using namespace Gudhi;
+
+typedef std::vector< Vertex_handle > typeVectorVertex;
+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;
+
+ // 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 = { 0 };
+ typePairSimplexBool returnValue =
+ simplexTree.insert_simplex(firstSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+
+ if (returnValue.second == true) {
+ std::cout << " + 0 INSERTED" << std::endl;
+ } else {
+ std::cout << " - 0 NOT INSERTED" << std::endl;
+ }
+
+ // ++ SECOND
+ std::cout << " * INSERT 1" << std::endl;
+ typeVectorVertex secondSimplexVector = { 1 };
+ returnValue =
+ simplexTree.insert_simplex(secondSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+
+ if (returnValue.second == true) {
+ std::cout << " + 1 INSERTED" << std::endl;
+ } else {
+ std::cout << " - 1 NOT INSERTED" << std::endl;
+ }
+
+ // ++ THIRD
+ std::cout << " * INSERT (0,1)" << std::endl;
+ typeVectorVertex thirdSimplexVector = { 0, 1 };
+ returnValue =
+ simplexTree.insert_simplex(thirdSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+
+ if (returnValue.second == true) {
+ std::cout << " + (0,1) INSERTED" << std::endl;
+ } else {
+ std::cout << " - (0,1) NOT INSERTED" << std::endl;
+ }
+
+ // ++ FOURTH
+ std::cout << " * INSERT 2" << std::endl;
+ typeVectorVertex fourthSimplexVector = { 2 };
+ returnValue =
+ simplexTree.insert_simplex(fourthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+
+ if (returnValue.second == true) {
+ std::cout << " + 2 INSERTED" << std::endl;
+ } else {
+ std::cout << " - 2 NOT INSERTED" << std::endl;
+ }
+
+ // ++ FIFTH
+ std::cout << " * INSERT (2,0)" << std::endl;
+ typeVectorVertex fifthSimplexVector = { 2, 0 };
+ returnValue =
+ simplexTree.insert_simplex(fifthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+
+ if (returnValue.second == true) {
+ std::cout << " + (2,0) INSERTED" << std::endl;
+ } else {
+ std::cout << " - (2,0) NOT INSERTED" << std::endl;
+ }
+
+ // ++ SIXTH
+ std::cout << " * INSERT (2,1)" << std::endl;
+ typeVectorVertex sixthSimplexVector = { 2, 1 };
+ returnValue =
+ simplexTree.insert_simplex(sixthSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+
+ if (returnValue.second == true) {
+ std::cout << " + (2,1) INSERTED" << std::endl;
+ } else {
+ std::cout << " - (2,1) NOT INSERTED" << std::endl;
+ }
+
+ // ++ SEVENTH
+ std::cout << " * INSERT (2,1,0)" << std::endl;
+ typeVectorVertex seventhSimplexVector = { 2, 1, 0 };
+ returnValue =
+ simplexTree.insert_simplex(seventhSimplexVector, Filtration_value(THIRD_FILTRATION_VALUE));
+
+ if (returnValue.second == true) {
+ std::cout << " + (2,1,0) INSERTED" << std::endl;
+ } else {
+ std::cout << " - (2,1,0) NOT INSERTED" << std::endl;
+ }
+
+ // ++ EIGHTH
+ std::cout << " * INSERT 3" << std::endl;
+ typeVectorVertex eighthSimplexVector = { 3 };
+ returnValue =
+ simplexTree.insert_simplex(eighthSimplexVector, Filtration_value(FIRST_FILTRATION_VALUE));
+
+ if (returnValue.second == true) {
+ std::cout << " + 3 INSERTED" << std::endl;
+ } else {
+ std::cout << " - 3 NOT INSERTED" << std::endl;
+ }
+
+ // ++ NINETH
+ std::cout << " * INSERT (3,0)" << std::endl;
+ typeVectorVertex ninethSimplexVector = { 3, 0 };
+ returnValue =
+ simplexTree.insert_simplex(ninethSimplexVector, Filtration_value(SECOND_FILTRATION_VALUE));
+
+ if (returnValue.second == true) {
+ std::cout << " + (3,0) INSERTED" << std::endl;
+ } else {
+ std::cout << " - (3,0) NOT INSERTED" << std::endl;
+ }
+
+ // ++ TENTH
+ std::cout << " * INSERT 0 (already inserted)" << std::endl;
+ typeVectorVertex tenthSimplexVector = { 0 };
+ // With a different filtration value
+ returnValue = simplexTree.insert_simplex(tenthSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
+
+ if (returnValue.second == true) {
+ std::cout << " + 0 INSERTED" << std::endl;
+ } else {
+ std::cout << " - 0 NOT INSERTED" << std::endl;
+ }
+
+ // ++ ELEVENTH
+ std::cout << " * INSERT (2,1,0) (already inserted)" << std::endl;
+ typeVectorVertex eleventhSimplexVector = { 2, 1, 0 };
+ returnValue =
+ simplexTree.insert_simplex(eleventhSimplexVector, Filtration_value(FOURTH_FILTRATION_VALUE));
+
+ if (returnValue.second == true) {
+ std::cout << " + (2,1,0) INSERTED" << std::endl;
+ } 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 << "********************************************************************\n";
+ // Display the Simplex_tree - Can not be done in the middle of 2 inserts
+ std::cout << "* The complex contains " << simplexTree.num_simplices() << " simplices\n";
+ std::cout << " - dimension " << simplexTree.dimension() << " - filtration " << simplexTree.filtration() << "\n";
+ std::cout << "* Iterator on Simplices in the filtration, with [filtration value]:\n";
+ 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 << static_cast<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
+
+ // ------------------------------------------------------------------------------------------------------------------
+ // Find in the simplex_tree
+ // ------------------------------------------------------------------------------------------------------------------
+ Simplex_tree<>::Simplex_handle simplexFound = simplexTree.find(secondSimplexVector);
+ std::cout << "**************IS THE SIMPLEX {1} IN THE SIMPLEX TREE ?\n";
+ if (simplexFound != simplexTree.null_simplex())
+ std::cout << "***+ YES IT IS!\n";
+ else
+ std::cout << "***- NO IT ISN'T\n";
+
+ typeVectorVertex unknownSimplexVector = { 15 };
+ simplexFound = simplexTree.find(unknownSimplexVector);
+ std::cout << "**************IS THE SIMPLEX {15} IN THE SIMPLEX TREE ?\n";
+ if (simplexFound != simplexTree.null_simplex())
+ std::cout << "***+ YES IT IS!\n";
+ else
+ std::cout << "***- NO IT ISN'T\n";
+
+ simplexFound = simplexTree.find(fifthSimplexVector);
+ std::cout << "**************IS THE SIMPLEX {2,0} IN THE SIMPLEX TREE ?\n";
+ if (simplexFound != simplexTree.null_simplex())
+ std::cout << "***+ YES IT IS!\n";
+ else
+ std::cout << "***- NO IT ISN'T\n";
+
+ typeVectorVertex otherSimplexVector = { 1, 15 };
+ simplexFound = simplexTree.find(otherSimplexVector);
+ std::cout << "**************IS THE SIMPLEX {15,1} IN THE SIMPLEX TREE ?\n";
+ if (simplexFound != simplexTree.null_simplex())
+ std::cout << "***+ YES IT IS!\n";
+ else
+ std::cout << "***- NO IT ISN'T\n";
+
+ typeVectorVertex invSimplexVector = { 1, 2, 0 };
+ simplexFound = simplexTree.find(invSimplexVector);
+ std::cout << "**************IS THE SIMPLEX {1,2,0} IN THE SIMPLEX TREE ?\n";
+ if (simplexFound != simplexTree.null_simplex())
+ std::cout << "***+ YES IT IS!\n";
+ else
+ std::cout << "***- NO IT ISN'T\n";
+ return 0;
+}
diff --git a/example/Simplex_tree/simplex_tree_from_alpha_shapes_3.cpp b/example/Simplex_tree/simplex_tree_from_alpha_shapes_3.cpp
new file mode 100644
index 00000000..49d358ab
--- /dev/null
+++ b/example/Simplex_tree/simplex_tree_from_alpha_shapes_3.cpp
@@ -0,0 +1,276 @@
+/* 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 <gudhi/graph_simplicial_complex.h>
+#include <gudhi/Simplex_tree.h>
+#include <boost/variant.hpp>
+
+#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 <cmath>
+#include <string>
+#include <tuple> // for tuple<>
+#include <map>
+#include <utility> // for pair<>
+#include <list>
+#include <vector>
+
+// 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<> Simplex_tree;
+typedef 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;
+
+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. CGAL has a strange behavior in REGULARIZED mode.
+ Alpha_shape_3 as(lp.begin(), lp.end(), 0, Alpha_shape_3::GENERAL);
+#ifdef DEBUG_TRACES
+ std::cout << "Alpha shape computed in GENERAL mode" << 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;
+ 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_simplex " << vertex << "\n";
+#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_simplex(the_simplex_tree, std::sqrt(*the_alpha_value_iterator));
+ if (the_alpha_value_iterator != the_alpha_values.end())
+ ++the_alpha_value_iterator;
+ else
+ std::cerr << "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:\n";
+ 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: \n";
+ 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:\n";
+ 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]:\n";
+ 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:\n";
+ 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/example/Simplex_tree/simplex_tree_from_cliques_of_graph.cpp b/example/Simplex_tree/simplex_tree_from_cliques_of_graph.cpp
new file mode 100644
index 00000000..58085014
--- /dev/null
+++ b/example/Simplex_tree/simplex_tree_from_cliques_of_graph.cpp
@@ -0,0 +1,114 @@
+/* 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 <gudhi/reader_utils.h>
+#include <gudhi/Simplex_tree.h>
+
+#include <iostream>
+#include <ctime>
+#include <string>
+
+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);
+ // insert the graph in the simplex tree as 1-skeleton
+ st.insert_graph(g);
+ end = clock();
+ std::cout << "Insert the 1-skeleton in the simplex tree in "
+ << static_cast<double>(end - start) / CLOCKS_PER_SEC << " s. \n";
+
+ start = clock();
+ // expand the 1-skeleton until dimension max_dim
+ st.expansion(max_dim);
+ end = clock();
+ std::cout << "max_dim = " << max_dim << "\n";
+ std::cout << "Expand the simplex tree in "
+ << static_cast<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;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-21 01:22:58 +0000