summaryrefslogtreecommitdiff
path: root/src/cython/include
diff options
context:
space:
mode:
Diffstat (limited to 'src/cython/include')
-rw-r--r--src/cython/include/Alpha_complex_interface.h85
-rw-r--r--src/cython/include/Cubical_complex_interface.h58
-rw-r--r--src/cython/include/Persistent_cohomology_interface.h96
-rw-r--r--src/cython/include/Simplex_tree_interface.h157
-rw-r--r--src/cython/include/Subsampling_interface.h79
-rw-r--r--src/cython/include/Tangential_complex_interface.h124
-rw-r--r--src/cython/include/Witness_complex_interface.h189
7 files changed, 788 insertions, 0 deletions
diff --git a/src/cython/include/Alpha_complex_interface.h b/src/cython/include/Alpha_complex_interface.h
new file mode 100644
index 00000000..81761c77
--- /dev/null
+++ b/src/cython/include/Alpha_complex_interface.h
@@ -0,0 +1,85 @@
+/* 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) 2016 INRIA
+ *
+ * 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/>.
+ */
+
+#ifndef ALPHA_COMPLEX_INTERFACE_H
+#define ALPHA_COMPLEX_INTERFACE_H
+
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Alpha_complex.h>
+#include <CGAL/Epick_d.h>
+
+#include "Simplex_tree_interface.h"
+
+#include <vector>
+#include <utility> // std::pair
+#include <iostream>
+
+namespace Gudhi {
+
+namespace alpha_complex {
+
+class Alpha_complex_interface {
+ using Dynamic_kernel = CGAL::Epick_d< CGAL::Dynamic_dimension_tag >;
+ using Point_d = Dynamic_kernel::Point_d;
+ typedef typename Simplex_tree<>::Simplex_handle Simplex_handle;
+ typedef typename std::pair<Simplex_handle, bool> Insertion_result;
+ using Simplex = std::vector<Vertex_handle>;
+ using Filtered_complex = std::pair<Simplex, Filtration_value>;
+ using Complex_tree = std::vector<Filtered_complex>;
+
+ typedef typename Simplex_tree<>::Simplex_key Simplex_key;
+
+ public:
+ Alpha_complex_interface(std::vector<std::vector<double>>&points) {
+ alpha_complex_ = new Alpha_complex<Dynamic_kernel>(points);
+ }
+
+ Alpha_complex_interface(std::string off_file_name, bool from_file = true) {
+ alpha_complex_ = new Alpha_complex<Dynamic_kernel>(off_file_name);
+ }
+
+ std::vector<double> get_point(int vh) {
+ std::vector<double> vd;
+ try {
+ Point_d ph = alpha_complex_->get_point(vh);
+ for (auto coord = ph.cartesian_begin(); coord < ph.cartesian_end(); coord++)
+ vd.push_back(*coord);
+ } catch (std::out_of_range outofrange) {
+ // std::out_of_range is thrown in case not found. Other exceptions must be re-thrown
+ }
+ return vd;
+ }
+
+ void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square) {
+ alpha_complex_->create_complex(*simplex_tree, max_alpha_square);
+ simplex_tree->initialize_filtration();
+ }
+
+ private:
+ Alpha_complex<Dynamic_kernel>* alpha_complex_;
+};
+
+} // namespace alpha_complex
+
+} // namespace Gudhi
+
+#endif // ALPHA_COMPLEX_INTERFACE_H
diff --git a/src/cython/include/Cubical_complex_interface.h b/src/cython/include/Cubical_complex_interface.h
new file mode 100644
index 00000000..5d17ff6b
--- /dev/null
+++ b/src/cython/include/Cubical_complex_interface.h
@@ -0,0 +1,58 @@
+/* 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) 2016 INRIA
+ *
+ * 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/>.
+ */
+
+#ifndef CUBICAL_COMPLEX_INTERFACE_H
+#define CUBICAL_COMPLEX_INTERFACE_H
+
+#include <gudhi/Bitmap_cubical_complex.h>
+#include <gudhi/Bitmap_cubical_complex_base.h>
+#include <gudhi/Bitmap_cubical_complex_periodic_boundary_conditions_base.h>
+
+#include <vector>
+#include <utility> // std::pair
+#include <iostream>
+
+namespace Gudhi {
+
+namespace cubical_complex {
+
+template<typename CubicalComplexOptions = Bitmap_cubical_complex_base<double>>
+class Cubical_complex_interface : public Bitmap_cubical_complex<CubicalComplexOptions> {
+ public:
+
+ Cubical_complex_interface(const std::vector<unsigned>& dimensions,
+ const std::vector<double>& top_dimensional_cells)
+ : Bitmap_cubical_complex<CubicalComplexOptions>(dimensions, top_dimensional_cells) {
+ }
+
+ Cubical_complex_interface(const std::string& perseus_file)
+ : Bitmap_cubical_complex<CubicalComplexOptions>(perseus_file.c_str()) {
+ }
+
+};
+
+} // namespace cubical_complex
+
+} // namespace Gudhi
+
+#endif // CUBICAL_COMPLEX_INTERFACE_H
+
diff --git a/src/cython/include/Persistent_cohomology_interface.h b/src/cython/include/Persistent_cohomology_interface.h
new file mode 100644
index 00000000..1ff0e09b
--- /dev/null
+++ b/src/cython/include/Persistent_cohomology_interface.h
@@ -0,0 +1,96 @@
+/* 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) 2016 INRIA
+ *
+ * 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/>.
+ */
+
+#ifndef PERSISTENT_COHOMOLOGY_INTERFACE_H
+#define PERSISTENT_COHOMOLOGY_INTERFACE_H
+
+#include <gudhi/Persistent_cohomology.h>
+
+#include <vector>
+#include <utility> // for std::pair
+
+namespace Gudhi {
+
+template<class FilteredComplex>
+class Persistent_cohomology_interface : public
+persistent_cohomology::Persistent_cohomology<FilteredComplex, persistent_cohomology::Field_Zp> {
+ private:
+
+ /*
+ * Compare two intervals by dimension, then by length.
+ */
+ struct cmp_intervals_by_dim_then_length {
+
+ explicit cmp_intervals_by_dim_then_length(FilteredComplex * sc)
+ : sc_(sc) { }
+
+ template<typename Persistent_interval>
+ bool operator()(const Persistent_interval & p1, const Persistent_interval & p2) {
+ if (sc_->dimension(get < 0 > (p1)) == sc_->dimension(get < 0 > (p2)))
+ return (sc_->filtration(get < 1 > (p1)) - sc_->filtration(get < 0 > (p1))
+ > sc_->filtration(get < 1 > (p2)) - sc_->filtration(get < 0 > (p2)));
+ else
+ return (sc_->dimension(get < 0 > (p1)) > sc_->dimension(get < 0 > (p2)));
+ }
+ FilteredComplex* sc_;
+ };
+
+ public:
+
+ Persistent_cohomology_interface(FilteredComplex* stptr)
+ : persistent_cohomology::Persistent_cohomology<FilteredComplex, persistent_cohomology::Field_Zp>(*stptr),
+ stptr_(stptr) { }
+
+ Persistent_cohomology_interface(FilteredComplex* stptr, bool persistence_dim_max)
+ : persistent_cohomology::Persistent_cohomology<FilteredComplex, persistent_cohomology::Field_Zp>(*stptr,
+ persistence_dim_max),
+ stptr_(stptr) { }
+
+ std::vector<std::pair<int, std::pair<double, double>>> get_persistence(int homology_coeff_field, double min_persistence) {
+ persistent_cohomology::Persistent_cohomology<FilteredComplex, persistent_cohomology::Field_Zp>::init_coefficients(homology_coeff_field);
+ persistent_cohomology::Persistent_cohomology<FilteredComplex, persistent_cohomology::Field_Zp>::compute_persistent_cohomology(min_persistence);
+
+ // Custom sort and output persistence
+ cmp_intervals_by_dim_then_length cmp(stptr_);
+ auto persistent_pairs = persistent_cohomology::Persistent_cohomology<FilteredComplex, persistent_cohomology::Field_Zp>::get_persistent_pairs();
+ std::sort(std::begin(persistent_pairs), std::end(persistent_pairs), cmp);
+
+ std::vector<std::pair<int, std::pair<double, double>>> persistence;
+ for (auto pair : persistent_pairs) {
+ persistence.push_back(std::make_pair(stptr_->dimension(get<0>(pair)),
+ std::make_pair(stptr_->filtration(get<0>(pair)),
+ stptr_->filtration(get<1>(pair)))));
+ }
+ return persistence;
+
+ }
+
+ private:
+ // A copy
+ FilteredComplex* stptr_;
+
+};
+
+} // namespace Gudhi
+
+#endif // PERSISTENT_COHOMOLOGY_INTERFACE_H
+
diff --git a/src/cython/include/Simplex_tree_interface.h b/src/cython/include/Simplex_tree_interface.h
new file mode 100644
index 00000000..8e9dd966
--- /dev/null
+++ b/src/cython/include/Simplex_tree_interface.h
@@ -0,0 +1,157 @@
+/* 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) 2016 INRIA
+ *
+ * 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/>.
+ */
+
+#ifndef SIMPLEX_TREE_INTERFACE_H
+#define SIMPLEX_TREE_INTERFACE_H
+
+#include <gudhi/graph_simplicial_complex.h>
+#include <gudhi/distance_functions.h>
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Points_off_io.h>
+
+#include "Persistent_cohomology_interface.h"
+
+#include <vector>
+#include <utility> // std::pair
+#include <iostream>
+
+namespace Gudhi {
+
+template<typename SimplexTreeOptions = Simplex_tree_options_full_featured>
+class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> {
+ public:
+ typedef typename Simplex_tree<SimplexTreeOptions>::Simplex_handle Simplex_handle;
+ typedef typename std::pair<Simplex_handle, bool> Insertion_result;
+ using Simplex = std::vector<Vertex_handle>;
+ using Filtered_complex = std::pair<Simplex, Filtration_value>;
+ using Complex_tree = std::vector<Filtered_complex>;
+
+ public:
+
+ bool find_simplex(const Simplex& vh) {
+ return (Simplex_tree<SimplexTreeOptions>::find(vh) != Simplex_tree<SimplexTreeOptions>::null_simplex());
+ }
+
+ bool insert_simplex_and_subfaces(const Simplex& complex, Filtration_value filtration = 0) {
+ Insertion_result result = Simplex_tree<SimplexTreeOptions>::insert_simplex_and_subfaces(complex, filtration);
+ Simplex_tree<SimplexTreeOptions>::initialize_filtration();
+ return (result.second);
+ }
+
+ Filtration_value simplex_filtration(const Simplex& complex) {
+ return Simplex_tree<SimplexTreeOptions>::filtration(Simplex_tree<SimplexTreeOptions>::find(complex));
+ }
+
+ void remove_maximal_simplex(const Simplex& complex) {
+ Simplex_tree<SimplexTreeOptions>::remove_maximal_simplex(Simplex_tree<SimplexTreeOptions>::find(complex));
+ Simplex_tree<SimplexTreeOptions>::initialize_filtration();
+ }
+
+ Complex_tree get_filtered_tree() {
+ Complex_tree filtered_tree;
+ for (auto f_simplex : Simplex_tree<SimplexTreeOptions>::filtration_simplex_range()) {
+ Simplex simplex;
+ for (auto vertex : Simplex_tree<SimplexTreeOptions>::simplex_vertex_range(f_simplex)) {
+ simplex.insert(simplex.begin(), vertex);
+ }
+ filtered_tree.push_back(std::make_pair(simplex, Simplex_tree<SimplexTreeOptions>::filtration(f_simplex)));
+ }
+ return filtered_tree;
+
+ }
+
+ Complex_tree get_skeleton_tree(int dimension) {
+ Complex_tree skeleton_tree;
+ for (auto f_simplex : Simplex_tree<SimplexTreeOptions>::skeleton_simplex_range(dimension)) {
+ Simplex simplex;
+ for (auto vertex : Simplex_tree<SimplexTreeOptions>::simplex_vertex_range(f_simplex)) {
+ simplex.insert(simplex.begin(), vertex);
+ }
+ skeleton_tree.push_back(std::make_pair(simplex, Simplex_tree<SimplexTreeOptions>::filtration(f_simplex)));
+ }
+ return skeleton_tree;
+ }
+
+ 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))) {
+ Simplex simplex;
+ for (auto vertex : Simplex_tree<SimplexTreeOptions>::simplex_vertex_range(f_simplex)) {
+ simplex.insert(simplex.begin(), vertex);
+ }
+ star_tree.push_back(std::make_pair(simplex, Simplex_tree<SimplexTreeOptions>::filtration(f_simplex)));
+ }
+ return star_tree;
+ }
+
+ 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)) {
+ Simplex simplex;
+ for (auto vertex : Simplex_tree<SimplexTreeOptions>::simplex_vertex_range(f_simplex)) {
+ simplex.insert(simplex.begin(), vertex);
+ }
+ coface_tree.push_back(std::make_pair(simplex, Simplex_tree<SimplexTreeOptions>::filtration(f_simplex)));
+ }
+ return coface_tree;
+ }
+
+ void graph_expansion(std::vector<std::vector<double>>&points, int max_dimension, double max_edge_length) {
+ Graph_t prox_graph = compute_proximity_graph(points, max_edge_length, euclidean_distance<std::vector<double>>);
+ Simplex_tree<SimplexTreeOptions>::insert_graph(prox_graph);
+ Simplex_tree<SimplexTreeOptions>::expansion(max_dimension);
+ Simplex_tree<SimplexTreeOptions>::initialize_filtration();
+ }
+
+ void graph_expansion(std::string& off_file_name, int max_dimension, double max_edge_length, bool from_file=true) {
+ Gudhi::Points_off_reader<std::vector <double>> off_reader(off_file_name);
+ // Check the read operation was correct
+ if (!off_reader.is_valid()) {
+ std::cerr << "Unable to read file " << off_file_name << std::endl;
+ } else {
+ std::vector<std::vector <double>> points = off_reader.get_point_cloud();
+ Graph_t prox_graph = compute_proximity_graph(points, max_edge_length,
+ euclidean_distance<std::vector<double>>);
+ Simplex_tree<SimplexTreeOptions>::insert_graph(prox_graph);
+ Simplex_tree<SimplexTreeOptions>::expansion(max_dimension);
+ Simplex_tree<SimplexTreeOptions>::initialize_filtration();
+ }
+ }
+
+ void create_persistence(Gudhi::Persistent_cohomology_interface<Simplex_tree<SimplexTreeOptions>>* pcoh) {
+ pcoh = new Gudhi::Persistent_cohomology_interface<Simplex_tree<SimplexTreeOptions>>(*this);
+ }
+
+};
+
+struct Simplex_tree_options_mini : Simplex_tree_options_full_featured {
+ // Not doing persistence, so we don't need those
+ static const bool store_key = true;
+ static const bool store_filtration = false;
+ // I have few vertices
+ typedef short Vertex_handle;
+};
+
+} // namespace Gudhi
+
+#endif // SIMPLEX_TREE_INTERFACE_H
+
diff --git a/src/cython/include/Subsampling_interface.h b/src/cython/include/Subsampling_interface.h
new file mode 100644
index 00000000..12c48012
--- /dev/null
+++ b/src/cython/include/Subsampling_interface.h
@@ -0,0 +1,79 @@
+/* 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) 2016 INRIA
+ *
+ * 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/>.
+ */
+
+#ifndef SUBSAMPLING_INTERFACE_H
+#define SUBSAMPLING_INTERFACE_H
+
+#include <gudhi/choose_n_farthest_points.h>
+#include <gudhi/Points_off_io.h>
+#include <CGAL/Epick_d.h>
+
+#include <vector>
+#include <iostream>
+
+namespace Gudhi {
+
+namespace subsampling {
+
+using Subsampling_dynamic_kernel = CGAL::Epick_d< CGAL::Dynamic_dimension_tag >;
+using Subsampling_point_d = Subsampling_dynamic_kernel::Point_d;
+using Subsampling_ft = Subsampling_dynamic_kernel::FT;
+
+std::vector<std::vector<double>> subsampling_n_farthest_points(std::vector<std::vector<double>>& points, unsigned nb_points) {
+ std::vector<Subsampling_point_d> input, output;
+ for (auto point : points)
+ input.push_back(Subsampling_point_d(point.size(), point.begin(), point.end()));
+ std::vector<std::vector<double>> landmarks;
+ Subsampling_dynamic_kernel k;
+ choose_n_farthest_points(k, points, nb_points, std::back_inserter(landmarks));
+
+ return landmarks;
+}
+
+std::vector<std::vector<double>> subsampling_n_farthest_points(std::vector<std::vector<double>>& points, unsigned nb_points, unsigned starting_point) {
+ std::vector<Subsampling_point_d> input, output;
+ for (auto point : points)
+ input.push_back(Subsampling_point_d(point.size(), point.begin(), point.end()));
+ std::vector<std::vector<double>> landmarks;
+ Subsampling_dynamic_kernel k;
+ choose_n_farthest_points(k, points, nb_points, starting_point, std::back_inserter(landmarks));
+
+ return landmarks;
+}
+
+std::vector<std::vector<double>> subsampling_n_farthest_points_from_file(std::string& off_file, unsigned nb_points) {
+ Gudhi::Points_off_reader<std::vector<double>> off_reader(off_file);
+ std::vector<std::vector<double>> points = off_reader.get_point_cloud();
+ return subsampling_n_farthest_points(points, nb_points);
+}
+
+std::vector<std::vector<double>> subsampling_n_farthest_points_from_file(std::string& off_file, unsigned nb_points, unsigned starting_point) {
+ Gudhi::Points_off_reader<std::vector<double>> off_reader(off_file);
+ std::vector<std::vector<double>> points = off_reader.get_point_cloud();
+ return subsampling_n_farthest_points(points, nb_points, starting_point);
+}
+} // namespace subsampling
+
+} // namespace Gudhi
+
+#endif // SUBSAMPLING_INTERFACE_H
+
diff --git a/src/cython/include/Tangential_complex_interface.h b/src/cython/include/Tangential_complex_interface.h
new file mode 100644
index 00000000..9da32757
--- /dev/null
+++ b/src/cython/include/Tangential_complex_interface.h
@@ -0,0 +1,124 @@
+/* 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) 2016 INRIA
+ *
+ * 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/>.
+ */
+
+#ifndef TANGENTIAL_COMPLEX_INTERFACE_H
+#define TANGENTIAL_COMPLEX_INTERFACE_H
+
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Tangential_complex.h>
+#include <gudhi/Points_off_io.h>
+#include <CGAL/Epick_d.h>
+
+#include "Simplex_tree_interface.h"
+
+#include <vector>
+#include <utility> // std::pair
+#include <iostream>
+
+namespace Gudhi {
+
+namespace tangential_complex {
+
+class Tangential_complex_interface {
+ using Dynamic_kernel = CGAL::Epick_d< CGAL::Dynamic_dimension_tag >;
+ using Point_d = Dynamic_kernel::Point_d;
+ typedef typename Simplex_tree<>::Simplex_handle Simplex_handle;
+ typedef typename std::pair<Simplex_handle, bool> Insertion_result;
+ using Simplex = std::vector<Vertex_handle>;
+ using Filtered_complex = std::pair<Simplex, Filtration_value>;
+ using Complex_tree = std::vector<Filtered_complex>;
+ using TC = Tangential_complex<Dynamic_kernel, CGAL::Dynamic_dimension_tag, CGAL::Parallel_tag>;
+
+ public:
+ Tangential_complex_interface(std::vector<std::vector<double>>&points) {
+ Dynamic_kernel k;
+ unsigned intrisic_dim = 0;
+ if (points.size() > 0)
+ intrisic_dim = points[0].size() - 1;
+
+ tangential_complex_ = new TC(points, intrisic_dim, k);
+ tangential_complex_->compute_tangential_complex();
+ num_inconsistencies_ = tangential_complex_->number_of_inconsistent_simplices();
+ }
+
+ Tangential_complex_interface(std::string off_file_name, bool from_file = true) {
+ Gudhi::Points_off_reader<Point_d> off_reader(off_file_name);
+ Dynamic_kernel k;
+ unsigned intrisic_dim = 0;
+ std::vector<Point_d> points = off_reader.get_point_cloud();
+ if (points.size() > 0)
+ intrisic_dim = points[0].size() - 1;
+
+ tangential_complex_ = new TC(points, intrisic_dim, k);
+ tangential_complex_->compute_tangential_complex();
+ num_inconsistencies_ = tangential_complex_->number_of_inconsistent_simplices();
+ }
+
+ std::vector<double> get_point(unsigned vh) {
+ std::vector<double> vd;
+ if (vh < tangential_complex_->number_of_vertices()) {
+ Point_d ph = tangential_complex_->get_point(vh);
+ for (auto coord = ph.cartesian_begin(); coord < ph.cartesian_end(); coord++)
+ vd.push_back(*coord);
+ }
+ return vd;
+ }
+
+ unsigned number_of_vertices() {
+ return tangential_complex_->number_of_vertices();
+ }
+
+ unsigned number_of_simplices() {
+ return num_inconsistencies_.num_simplices;
+ }
+
+ unsigned number_of_inconsistent_simplices() {
+ return num_inconsistencies_.num_inconsistent_simplices;
+ }
+
+ unsigned number_of_inconsistent_stars() {
+ return num_inconsistencies_.num_inconsistent_stars;
+ }
+
+ void fix_inconsistencies_using_perturbation(double max_perturb, double time_limit) {
+ tangential_complex_->fix_inconsistencies_using_perturbation(max_perturb, time_limit);
+ num_inconsistencies_ = tangential_complex_->number_of_inconsistent_simplices();
+ }
+
+ void create_simplex_tree(Simplex_tree<>* simplex_tree) {
+ int max_dim = tangential_complex_->create_complex<Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_full_featured>>(*simplex_tree);
+ // FIXME
+ simplex_tree->set_dimension(max_dim);
+ simplex_tree->initialize_filtration();
+ }
+
+ private:
+ TC* tangential_complex_;
+ TC::Num_inconsistencies num_inconsistencies_;
+};
+
+} // namespace tangential_complex
+
+} // namespace Gudhi
+
+#endif // TANGENTIAL_COMPLEX_INTERFACE_H
+
diff --git a/src/cython/include/Witness_complex_interface.h b/src/cython/include/Witness_complex_interface.h
new file mode 100644
index 00000000..ab99adf5
--- /dev/null
+++ b/src/cython/include/Witness_complex_interface.h
@@ -0,0 +1,189 @@
+/* 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) 2016 INRIA
+ *
+ * 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/>.
+ */
+
+#ifndef WITNESS_COMPLEX_INTERFACE_H
+#define WITNESS_COMPLEX_INTERFACE_H
+
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Witness_complex.h>
+#include <gudhi/Construct_closest_landmark_table.h>
+#include <gudhi/pick_n_random_points.h>
+
+#include "Persistent_cohomology_interface.h"
+
+#include <vector>
+#include <utility> // std::pair
+#include <iostream>
+
+namespace Gudhi {
+
+namespace witness_complex {
+
+class Witness_complex_interface {
+ typedef typename Simplex_tree<>::Simplex_handle Simplex_handle;
+ typedef typename std::pair<Simplex_handle, bool> Insertion_result;
+ using Simplex = std::vector<Vertex_handle>;
+ using Filtered_complex = std::pair<Simplex, Filtration_value>;
+ using Complex_tree = std::vector<Filtered_complex>;
+
+ public:
+ Witness_complex_interface(std::vector<std::vector<double>>&points, int number_of_landmarks)
+ : pcoh_(nullptr) {
+ std::vector<std::vector< int > > knn;
+ std::vector<std::vector<double>> landmarks;
+ Gudhi::subsampling::pick_n_random_points(points, number_of_landmarks, std::back_inserter(landmarks));
+ Gudhi::witness_complex::construct_closest_landmark_table(points, landmarks, knn);
+
+ Gudhi::witness_complex::witness_complex(knn, number_of_landmarks, points[0].size(), simplex_tree_);
+ }
+
+ bool find_simplex(const Simplex& vh) {
+ return (simplex_tree_.find(vh) != simplex_tree_.null_simplex());
+ }
+
+ bool insert_simplex_and_subfaces(const Simplex& complex, Filtration_value filtration = 0) {
+ Insertion_result result = simplex_tree_.insert_simplex_and_subfaces(complex, filtration);
+ return (result.second);
+ }
+
+ Filtration_value simplex_filtration(const Simplex& complex) {
+ return simplex_tree_.filtration(simplex_tree_.find(complex));
+ }
+
+ void remove_maximal_simplex(const Simplex& complex) {
+ return simplex_tree_.remove_maximal_simplex(simplex_tree_.find(complex));
+ }
+
+ Complex_tree get_filtered_tree() {
+ Complex_tree filtered_tree;
+ for (auto f_simplex : simplex_tree_.filtration_simplex_range()) {
+ Simplex simplex;
+ for (auto vertex : simplex_tree_.simplex_vertex_range(f_simplex)) {
+ simplex.insert(simplex.begin(), vertex);
+ }
+ filtered_tree.push_back(std::make_pair(simplex, simplex_tree_.filtration(f_simplex)));
+ }
+ return filtered_tree;
+
+ }
+
+ Complex_tree get_skeleton_tree(int dimension) {
+ Complex_tree skeleton_tree;
+ for (auto f_simplex : simplex_tree_.skeleton_simplex_range(dimension)) {
+ Simplex simplex;
+ for (auto vertex : simplex_tree_.simplex_vertex_range(f_simplex)) {
+ simplex.insert(simplex.begin(), vertex);
+ }
+ skeleton_tree.push_back(std::make_pair(simplex, simplex_tree_.filtration(f_simplex)));
+ }
+ return skeleton_tree;
+ }
+
+ Complex_tree get_star_tree(const Simplex& complex) {
+ Complex_tree star_tree;
+ for (auto f_simplex : simplex_tree_.star_simplex_range(simplex_tree_.find(complex))) {
+ Simplex simplex;
+ for (auto vertex : simplex_tree_.simplex_vertex_range(f_simplex)) {
+ simplex.insert(simplex.begin(), vertex);
+ }
+ star_tree.push_back(std::make_pair(simplex, simplex_tree_.filtration(f_simplex)));
+ }
+ return star_tree;
+ }
+
+ Complex_tree get_coface_tree(const Simplex& complex, int dimension) {
+ Complex_tree coface_tree;
+ for (auto f_simplex : simplex_tree_.cofaces_simplex_range(simplex_tree_.find(complex), dimension)) {
+ Simplex simplex;
+ for (auto vertex : simplex_tree_.simplex_vertex_range(f_simplex)) {
+ simplex.insert(simplex.begin(), vertex);
+ }
+ coface_tree.push_back(std::make_pair(simplex, simplex_tree_.filtration(f_simplex)));
+ }
+ return coface_tree;
+ }
+
+ // Specific to Witness complex because no inheritance
+ Filtration_value filtration() const {
+ return simplex_tree_.filtration();
+ }
+
+ void set_filtration(Filtration_value fil) {
+ simplex_tree_.set_filtration(fil);
+ }
+
+ void initialize_filtration() {
+ simplex_tree_.initialize_filtration();
+ }
+
+ size_t num_vertices() const {
+ return simplex_tree_.num_vertices();
+ }
+
+ size_t num_simplices() {
+ return simplex_tree_.num_simplices();
+ }
+
+ int dimension() const {
+ return simplex_tree_.dimension();
+ }
+
+ void set_dimension(int dimension) {
+ simplex_tree_.set_dimension(dimension);
+ }
+
+ std::vector<std::pair<int, std::pair<double, double>>> get_persistence(int homology_coeff_field, double min_persistence) {
+ if (pcoh_ != nullptr) {
+ delete pcoh_;
+ }
+ pcoh_ = new Persistent_cohomology_interface<Simplex_tree<>>(&simplex_tree_);
+ return pcoh_->get_persistence(homology_coeff_field, min_persistence);
+ }
+
+ std::vector<int> get_betti_numbers() const {
+ if (pcoh_ != nullptr) {
+ return pcoh_->betti_numbers();
+ }
+ std::vector<int> betti_numbers;
+ return betti_numbers;
+ }
+
+ std::vector<int> get_persistent_betti_numbers(Filtration_value from, Filtration_value to) const {
+ if (pcoh_ != nullptr) {
+ return pcoh_->persistent_betti_numbers(from, to);
+ }
+ std::vector<int> persistent_betti_numbers;
+ return persistent_betti_numbers;
+ }
+
+ private:
+ Simplex_tree<> simplex_tree_;
+ Persistent_cohomology_interface<Simplex_tree<>>* pcoh_;
+
+};
+
+} // namespace witness_complex
+
+} // namespace Gudhi
+
+#endif // WITNESS_COMPLEX_INTERFACE_H
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-04 09:12:57 +0000