diff options
Diffstat (limited to 'cython/include')
| -rw-r--r-- | cython/include/Alpha_complex_interface.h | 82 | ||||
| -rw-r--r-- | cython/include/Bottleneck_distance_interface.h | 53 | ||||
| -rw-r--r-- | cython/include/Cubical_complex_interface.h | 62 | ||||
| -rw-r--r-- | cython/include/Euclidean_strong_witness_complex_interface.h | 93 | ||||
| -rw-r--r-- | cython/include/Euclidean_witness_complex_interface.h | 92 | ||||
| -rw-r--r-- | cython/include/Nerve_gic_interface.h | 61 | ||||
| -rw-r--r-- | cython/include/Off_reader_interface.h | 42 | ||||
| -rw-r--r-- | cython/include/Persistent_cohomology_interface.h | 121 | ||||
| -rw-r--r-- | cython/include/Reader_utils_interface.h | 56 | ||||
| -rw-r--r-- | cython/include/Rips_complex_interface.h | 74 | ||||
| -rw-r--r-- | cython/include/Simplex_tree_interface.h | 158 | ||||
| -rw-r--r-- | cython/include/Strong_witness_complex_interface.h | 73 | ||||
| -rw-r--r-- | cython/include/Subsampling_interface.h | 119 | ||||
| -rw-r--r-- | cython/include/Tangential_complex_interface.h | 116 | ||||
| -rw-r--r-- | cython/include/Witness_complex_interface.h | 74 |
15 files changed, 0 insertions, 1276 deletions
diff --git a/cython/include/Alpha_complex_interface.h b/cython/include/Alpha_complex_interface.h deleted file mode 100644 index 8cf527fc..00000000 --- a/cython/include/Alpha_complex_interface.h +++ /dev/null @@ -1,82 +0,0 @@ -/* 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 INCLUDE_ALPHA_COMPLEX_INTERFACE_H_ -#define INCLUDE_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 <iostream> -#include <vector> -#include <string> - -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; - - public: - Alpha_complex_interface(const std::vector<std::vector<double>>& points) { - alpha_complex_ = new Alpha_complex<Dynamic_kernel>(points); - } - - Alpha_complex_interface(const std::string& off_file_name, bool from_file = true) { - alpha_complex_ = new Alpha_complex<Dynamic_kernel>(off_file_name); - } - - ~Alpha_complex_interface() { - delete alpha_complex_; - } - - 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 // INCLUDE_ALPHA_COMPLEX_INTERFACE_H_ diff --git a/cython/include/Bottleneck_distance_interface.h b/cython/include/Bottleneck_distance_interface.h deleted file mode 100644 index 5ad9d77d..00000000 --- a/cython/include/Bottleneck_distance_interface.h +++ /dev/null @@ -1,53 +0,0 @@ -/* 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 INCLUDE_BOTTLENECK_DISTANCE_INTERFACE_H_ -#define INCLUDE_BOTTLENECK_DISTANCE_INTERFACE_H_ - -#include <gudhi/Bottleneck.h> - -#include <iostream> -#include <vector> -#include <utility> // for std::pair - -namespace Gudhi { - -namespace persistence_diagram { - - // bottleneck_distance function renamed for the python function can be called bottleneck_dstance - double bottleneck(const std::vector<std::pair<double, double>>& diag1, - const std::vector<std::pair<double, double>>& diag2, - double e) { - return bottleneck_distance(diag1, diag2, e); - } - - double bottleneck(const std::vector<std::pair<double, double>>& diag1, - const std::vector<std::pair<double, double>>& diag2) { - return bottleneck_distance(diag1, diag2); - } - -} // namespace persistence_diagram - -} // namespace Gudhi - - -#endif // INCLUDE_BOTTLENECK_DISTANCE_INTERFACE_H_ diff --git a/cython/include/Cubical_complex_interface.h b/cython/include/Cubical_complex_interface.h deleted file mode 100644 index 85b717b3..00000000 --- a/cython/include/Cubical_complex_interface.h +++ /dev/null @@ -1,62 +0,0 @@ -/* 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 INCLUDE_CUBICAL_COMPLEX_INTERFACE_H_ -#define INCLUDE_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 <iostream> -#include <vector> -#include <string> - -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::vector<unsigned>& dimensions, - const std::vector<double>& top_dimensional_cells, - const std::vector<bool>& periodic_dimensions) - : Bitmap_cubical_complex<CubicalComplexOptions>(dimensions, top_dimensional_cells, periodic_dimensions) { - } - - Cubical_complex_interface(const std::string& perseus_file) - : Bitmap_cubical_complex<CubicalComplexOptions>(perseus_file.c_str()) { - } -}; - -} // namespace cubical_complex - -} // namespace Gudhi - -#endif // INCLUDE_CUBICAL_COMPLEX_INTERFACE_H_ - diff --git a/cython/include/Euclidean_strong_witness_complex_interface.h b/cython/include/Euclidean_strong_witness_complex_interface.h deleted file mode 100644 index d86355d6..00000000 --- a/cython/include/Euclidean_strong_witness_complex_interface.h +++ /dev/null @@ -1,93 +0,0 @@ -/* 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 INCLUDE_EUCLIDEAN_STRONG_WITNESS_COMPLEX_INTERFACE_H_ -#define INCLUDE_EUCLIDEAN_STRONG_WITNESS_COMPLEX_INTERFACE_H_ - -#include <gudhi/Simplex_tree.h> -#include <gudhi/Euclidean_strong_witness_complex.h> - -#include "Simplex_tree_interface.h" - -#include <CGAL/Epick_d.h> - -#include <vector> -#include <utility> // std::pair -#include <iostream> -#include <cstddef> - -namespace Gudhi { - -namespace witness_complex { - - -class Euclidean_strong_witness_complex_interface { - using Dynamic_kernel = CGAL::Epick_d< CGAL::Dynamic_dimension_tag >; - using Point_d = Dynamic_kernel::Point_d; - - typedef typename Simplex_tree<>::Simplex_key Simplex_key; - - public: - Euclidean_strong_witness_complex_interface(const std::vector<std::vector<double>>& landmarks, - const std::vector<std::vector<double>>& witnesses) { - landmarks_.reserve(landmarks.size()); - for (auto& landmark : landmarks) - landmarks_.emplace_back(landmark.begin(), landmark.end()); - witness_complex_ = new Euclidean_strong_witness_complex<Dynamic_kernel>(landmarks_, witnesses); - } - - ~Euclidean_strong_witness_complex_interface() { - delete witness_complex_; - } - - void create_simplex_tree(Gudhi::Simplex_tree<>* simplex_tree, double max_alpha_square, - std::size_t limit_dimension) { - witness_complex_->create_complex(*simplex_tree, max_alpha_square, limit_dimension); - simplex_tree->initialize_filtration(); - } - - void create_simplex_tree(Gudhi::Simplex_tree<>* simplex_tree, double max_alpha_square) { - witness_complex_->create_complex(*simplex_tree, max_alpha_square); - simplex_tree->initialize_filtration(); - } - - std::vector<double> get_point(unsigned vh) { - std::vector<double> vd; - if (vh < landmarks_.size()) { - Point_d ph = witness_complex_->get_point(vh); - for (auto coord = ph.cartesian_begin(); coord < ph.cartesian_end(); coord++) - vd.push_back(*coord); - } - return vd; - } - - private: - std::vector<Point_d> landmarks_; - Euclidean_strong_witness_complex<Dynamic_kernel>* witness_complex_; -}; - -} // namespace witness_complex - -} // namespace Gudhi - -#endif // INCLUDE_EUCLIDEAN_STRONG_WITNESS_COMPLEX_INTERFACE_H_ - diff --git a/cython/include/Euclidean_witness_complex_interface.h b/cython/include/Euclidean_witness_complex_interface.h deleted file mode 100644 index dc303533..00000000 --- a/cython/include/Euclidean_witness_complex_interface.h +++ /dev/null @@ -1,92 +0,0 @@ -/* 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 INCLUDE_EUCLIDEAN_WITNESS_COMPLEX_INTERFACE_H_ -#define INCLUDE_EUCLIDEAN_WITNESS_COMPLEX_INTERFACE_H_ - -#include <gudhi/Simplex_tree.h> -#include <gudhi/Euclidean_witness_complex.h> - -#include "Simplex_tree_interface.h" - -#include <CGAL/Epick_d.h> - -#include <vector> -#include <utility> // std::pair -#include <iostream> -#include <cstddef> - -namespace Gudhi { - -namespace witness_complex { - - -class Euclidean_witness_complex_interface { - using Dynamic_kernel = CGAL::Epick_d< CGAL::Dynamic_dimension_tag >; - using Point_d = Dynamic_kernel::Point_d; - - typedef typename Simplex_tree<>::Simplex_key Simplex_key; - - public: - Euclidean_witness_complex_interface(const std::vector<std::vector<double>>& landmarks, - const std::vector<std::vector<double>>& witnesses) { - landmarks_.reserve(landmarks.size()); - for (auto& landmark : landmarks) - landmarks_.emplace_back(landmark.begin(), landmark.end()); - witness_complex_ = new Euclidean_witness_complex<Dynamic_kernel>(landmarks_, witnesses); - } - - ~Euclidean_witness_complex_interface() { - delete witness_complex_; - } - - void create_simplex_tree(Gudhi::Simplex_tree<>* simplex_tree, double max_alpha_square, std::size_t limit_dimension) { - witness_complex_->create_complex(*simplex_tree, max_alpha_square, limit_dimension); - simplex_tree->initialize_filtration(); - } - - void create_simplex_tree(Gudhi::Simplex_tree<>* simplex_tree, double max_alpha_square) { - witness_complex_->create_complex(*simplex_tree, max_alpha_square); - simplex_tree->initialize_filtration(); - } - - std::vector<double> get_point(unsigned vh) { - std::vector<double> vd; - if (vh < landmarks_.size()) { - Point_d ph = witness_complex_->get_point(vh); - for (auto coord = ph.cartesian_begin(); coord < ph.cartesian_end(); coord++) - vd.push_back(*coord); - } - return vd; - } - - private: - std::vector<Point_d> landmarks_; - Euclidean_witness_complex<Dynamic_kernel>* witness_complex_; -}; - -} // namespace witness_complex - -} // namespace Gudhi - -#endif // INCLUDE_EUCLIDEAN_WITNESS_COMPLEX_INTERFACE_H_ - diff --git a/cython/include/Nerve_gic_interface.h b/cython/include/Nerve_gic_interface.h deleted file mode 100644 index aa71e2a6..00000000 --- a/cython/include/Nerve_gic_interface.h +++ /dev/null @@ -1,61 +0,0 @@ -/* 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) 2018 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 INCLUDE_NERVE_GIC_INTERFACE_H_ -#define INCLUDE_NERVE_GIC_INTERFACE_H_ - -#include <gudhi/Simplex_tree.h> -#include <gudhi/distance_functions.h> -#include <gudhi/GIC.h> - -#include "Simplex_tree_interface.h" - -#include <iostream> -#include <vector> -#include <string> - -namespace Gudhi { - -namespace cover_complex { - -class Nerve_gic_interface : public Cover_complex<std::vector<double>> { - public: - void create_simplex_tree(Simplex_tree_interface<>* simplex_tree) { - create_complex(*simplex_tree); - simplex_tree->initialize_filtration(); - } - void set_cover_from_Euclidean_Voronoi(int m) { - set_cover_from_Voronoi(Gudhi::Euclidean_distance(), m); - } - double set_graph_from_automatic_euclidean_rips(int N) { - return set_graph_from_automatic_rips(Gudhi::Euclidean_distance(), N); - } - void set_graph_from_euclidean_rips(double threshold) { - set_graph_from_rips(threshold, Gudhi::Euclidean_distance()); - } -}; - -} // namespace cover_complex - -} // namespace Gudhi - -#endif // INCLUDE_NERVE_GIC_INTERFACE_H_ diff --git a/cython/include/Off_reader_interface.h b/cython/include/Off_reader_interface.h deleted file mode 100644 index f6b14f38..00000000 --- a/cython/include/Off_reader_interface.h +++ /dev/null @@ -1,42 +0,0 @@ -/* 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 INCLUDE_OFF_READER_INTERFACE_H_ -#define INCLUDE_OFF_READER_INTERFACE_H_ - -#include <gudhi/Points_off_io.h> - -#include <iostream> -#include <vector> -#include <string> - -namespace Gudhi { - -std::vector<std::vector<double>> read_points_from_OFF_file(const std::string& off_file) { - Gudhi::Points_off_reader<std::vector<double>> off_reader(off_file); - return off_reader.get_point_cloud(); -} - -} // namespace Gudhi - -#endif // INCLUDE_OFF_READER_INTERFACE_H_ - diff --git a/cython/include/Persistent_cohomology_interface.h b/cython/include/Persistent_cohomology_interface.h deleted file mode 100644 index 8cf71a4e..00000000 --- a/cython/include/Persistent_cohomology_interface.h +++ /dev/null @@ -1,121 +0,0 @@ -/* 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 INCLUDE_PERSISTENT_COHOMOLOGY_INTERFACE_H_ -#define INCLUDE_PERSISTENT_COHOMOLOGY_INTERFACE_H_ - -#include <gudhi/Persistent_cohomology.h> - -#include <vector> -#include <utility> // for std::pair -#include <algorithm> // for sort - -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; - } - - std::vector<std::pair<std::vector<int>, std::vector<int>>> persistence_pairs() { - auto pairs = persistent_cohomology::Persistent_cohomology<FilteredComplex, - persistent_cohomology::Field_Zp>::get_persistent_pairs(); - - std::vector<std::pair<std::vector<int>, std::vector<int>>> persistence_pairs; - persistence_pairs.reserve(pairs.size()); - for (auto pair : pairs) { - std::vector<int> birth; - if (get<0>(pair) != stptr_->null_simplex()) { - for (auto vertex : stptr_->simplex_vertex_range(get<0>(pair))) { - birth.push_back(vertex); - } - } - - std::vector<int> death; - if (get<1>(pair) != stptr_->null_simplex()) { - for (auto vertex : stptr_->simplex_vertex_range(get<1>(pair))) { - death.push_back(vertex); - } - } - - persistence_pairs.push_back(std::make_pair(birth, death)); - } - return persistence_pairs; - } - - private: - // A copy - FilteredComplex* stptr_; -}; - -} // namespace Gudhi - -#endif // INCLUDE_PERSISTENT_COHOMOLOGY_INTERFACE_H_ diff --git a/cython/include/Reader_utils_interface.h b/cython/include/Reader_utils_interface.h deleted file mode 100644 index 5f7527d9..00000000 --- a/cython/include/Reader_utils_interface.h +++ /dev/null @@ -1,56 +0,0 @@ -/* 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) 2017 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 INCLUDE_READER_UTILS_INTERFACE_H_ -#define INCLUDE_READER_UTILS_INTERFACE_H_ - -#include <gudhi/reader_utils.h> - -#include <iostream> -#include <vector> -#include <string> -#include <map> -#include <utility> // for pair<> - -namespace Gudhi { - -// Redefine functions with a different name in order the original name can be used in the Python version. -std::vector<std::vector<double>> read_matrix_from_csv_file(const std::string& filename, - const char separator = ';') { - return read_lower_triangular_matrix_from_csv_file<double>(filename, separator); -} - -inline std::map<int, std::vector<std::pair<double, double>>> - read_pers_intervals_grouped_by_dimension(std::string const& filename) { - return read_persistence_intervals_grouped_by_dimension(filename); -} - -inline std::vector<std::pair<double, double>> - read_pers_intervals_in_dimension(std::string const& filename, int only_this_dim = -1) { - return read_persistence_intervals_in_dimension(filename, only_this_dim); -} - - -} // namespace Gudhi - - -#endif // INCLUDE_READER_UTILS_INTERFACE_H_ diff --git a/cython/include/Rips_complex_interface.h b/cython/include/Rips_complex_interface.h deleted file mode 100644 index 8b6c9c35..00000000 --- a/cython/include/Rips_complex_interface.h +++ /dev/null @@ -1,74 +0,0 @@ -/* 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 INCLUDE_RIPS_COMPLEX_INTERFACE_H_ -#define INCLUDE_RIPS_COMPLEX_INTERFACE_H_ - -#include <gudhi/Simplex_tree.h> -#include <gudhi/Rips_complex.h> -#include <gudhi/distance_functions.h> - -#include "Simplex_tree_interface.h" - -#include <iostream> -#include <vector> -#include <utility> // std::pair -#include <string> - -namespace Gudhi { - -namespace rips_complex { - -class Rips_complex_interface { - using Point_d = std::vector<double>; - using Distance_matrix = std::vector<std::vector<Simplex_tree_interface<>::Filtration_value>>; - - public: - Rips_complex_interface(const std::vector<std::vector<double>>& values, double threshold, bool euclidean) { - if (euclidean) { - // Rips construction where values is a vector of points - rips_complex_ = new Rips_complex<Simplex_tree_interface<>::Filtration_value>(values, threshold, - Gudhi::Euclidean_distance()); - } else { - // Rips construction where values is a distance matrix - rips_complex_ = new Rips_complex<Simplex_tree_interface<>::Filtration_value>(values, threshold); - } - } - - ~Rips_complex_interface() { - delete rips_complex_; - } - - void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, int dim_max) { - rips_complex_->create_complex(*simplex_tree, dim_max); - simplex_tree->initialize_filtration(); - } - - private: - Rips_complex<Simplex_tree_interface<>::Filtration_value>* rips_complex_; -}; - -} // namespace rips_complex - -} // namespace Gudhi - -#endif // INCLUDE_RIPS_COMPLEX_INTERFACE_H_ diff --git a/cython/include/Simplex_tree_interface.h b/cython/include/Simplex_tree_interface.h deleted file mode 100644 index 3481eeff..00000000 --- a/cython/include/Simplex_tree_interface.h +++ /dev/null @@ -1,158 +0,0 @@ -/* 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 INCLUDE_SIMPLEX_TREE_INTERFACE_H_ -#define INCLUDE_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 <iostream> -#include <vector> -#include <utility> // std::pair - -namespace Gudhi { - -template<typename SimplexTreeOptions = Simplex_tree_options_full_featured> -class Simplex_tree_interface : public Simplex_tree<SimplexTreeOptions> { - public: - using Base = Simplex_tree<SimplexTreeOptions>; - using Filtration_value = typename Base::Filtration_value; - using Vertex_handle = typename Base::Vertex_handle; - using Simplex_handle = typename Base::Simplex_handle; - using Insertion_result = typename std::pair<Simplex_handle, bool>; - using Simplex = std::vector<Vertex_handle>; - using Complex = std::vector<std::pair<Simplex, Filtration_value>>; - - public: - bool find_simplex(const Simplex& vh) { - return (Base::find(vh) != Base::null_simplex()); - } - - void assign_simplex_filtration(const Simplex& vh, Filtration_value filtration) { - Base::assign_filtration(Base::find(vh), filtration); - } - - bool insert(const Simplex& simplex, Filtration_value filtration = 0) { - Insertion_result result = Base::insert_simplex_and_subfaces(simplex, filtration); - return (result.second); - } - - // Do not interface this function, only used in alpha complex interface for complex creation - bool insert_simplex(const Simplex& simplex, Filtration_value filtration = 0) { - Insertion_result result = Base::insert_simplex(simplex, filtration); - return (result.second); - } - - // Do not interface this function, only used in interface for complex creation - bool insert_simplex_and_subfaces(const Simplex& simplex, Filtration_value filtration = 0) { - Insertion_result result = Base::insert_simplex_and_subfaces(simplex, filtration); - return (result.second); - } - - // Do not interface this function, only used in strong witness interface for complex creation - bool insert_simplex(const std::vector<std::size_t>& simplex, Filtration_value filtration = 0) { - Insertion_result result = Base::insert_simplex(simplex, filtration); - return (result.second); - } - - // Do not interface this function, only used in strong witness interface for complex creation - bool insert_simplex_and_subfaces(const std::vector<std::size_t>& simplex, Filtration_value filtration = 0) { - Insertion_result result = Base::insert_simplex_and_subfaces(simplex, filtration); - return (result.second); - } - - Filtration_value simplex_filtration(const Simplex& simplex) { - return Base::filtration(Base::find(simplex)); - } - - void remove_maximal_simplex(const Simplex& simplex) { - Base::remove_maximal_simplex(Base::find(simplex)); - Base::initialize_filtration(); - } - - Complex get_filtration() { - Base::initialize_filtration(); - Complex filtrations; - for (auto f_simplex : Base::filtration_simplex_range()) { - Simplex simplex; - for (auto vertex : Base::simplex_vertex_range(f_simplex)) { - simplex.insert(simplex.begin(), vertex); - } - filtrations.push_back(std::make_pair(simplex, Base::filtration(f_simplex))); - } - return filtrations; - } - - Complex get_skeleton(int dimension) { - Complex skeletons; - for (auto f_simplex : Base::skeleton_simplex_range(dimension)) { - Simplex simplex; - for (auto vertex : Base::simplex_vertex_range(f_simplex)) { - simplex.insert(simplex.begin(), vertex); - } - skeletons.push_back(std::make_pair(simplex, Base::filtration(f_simplex))); - } - return skeletons; - } - - Complex get_star(const Simplex& simplex) { - Complex star; - for (auto f_simplex : Base::star_simplex_range(Base::find(simplex))) { - Simplex simplex_star; - for (auto vertex : Base::simplex_vertex_range(f_simplex)) { - std::cout << vertex << " "; - simplex_star.insert(simplex_star.begin(), vertex); - } - std::cout << std::endl; - star.push_back(std::make_pair(simplex_star, Base::filtration(f_simplex))); - } - return star; - } - - Complex get_cofaces(const Simplex& simplex, int dimension) { - Complex cofaces; - for (auto f_simplex : Base::cofaces_simplex_range(Base::find(simplex), dimension)) { - Simplex simplex_coface; - for (auto vertex : Base::simplex_vertex_range(f_simplex)) { - std::cout << vertex << " "; - simplex_coface.insert(simplex_coface.begin(), vertex); - } - std::cout << std::endl; - cofaces.push_back(std::make_pair(simplex_coface, Base::filtration(f_simplex))); - } - return cofaces; - } - - void create_persistence(Gudhi::Persistent_cohomology_interface<Base>* pcoh) { - Base::initialize_filtration(); - pcoh = new Gudhi::Persistent_cohomology_interface<Base>(*this); - } -}; - -} // namespace Gudhi - -#endif // INCLUDE_SIMPLEX_TREE_INTERFACE_H_ diff --git a/cython/include/Strong_witness_complex_interface.h b/cython/include/Strong_witness_complex_interface.h deleted file mode 100644 index 3c72c916..00000000 --- a/cython/include/Strong_witness_complex_interface.h +++ /dev/null @@ -1,73 +0,0 @@ -/* 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 INCLUDE_STRONG_WITNESS_COMPLEX_INTERFACE_H_ -#define INCLUDE_STRONG_WITNESS_COMPLEX_INTERFACE_H_ - -#include <gudhi/Simplex_tree.h> -#include <gudhi/Strong_witness_complex.h> - -#include "Simplex_tree_interface.h" - -#include <vector> -#include <utility> // std::pair -#include <iostream> -#include <cstddef> - -namespace Gudhi { - -namespace witness_complex { - -class Strong_witness_complex_interface { - using Nearest_landmark_range = std::vector<std::pair<std::size_t, double>>; - using Nearest_landmark_table = std::vector<Nearest_landmark_range>; - - public: - Strong_witness_complex_interface(const Nearest_landmark_table& nlt) { - witness_complex_ = new Strong_witness_complex<Nearest_landmark_table>(nlt); - } - - ~Strong_witness_complex_interface() { - delete witness_complex_; - } - - void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square, - std::size_t limit_dimension) { - witness_complex_->create_complex(*simplex_tree, max_alpha_square, limit_dimension); - simplex_tree->initialize_filtration(); - } - - void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, - double max_alpha_square) { - witness_complex_->create_complex(*simplex_tree, max_alpha_square); - simplex_tree->initialize_filtration(); - } - - private: - Strong_witness_complex<Nearest_landmark_table>* witness_complex_; -}; - -} // namespace witness_complex - -} // namespace Gudhi - -#endif // INCLUDE_STRONG_WITNESS_COMPLEX_INTERFACE_H_ diff --git a/cython/include/Subsampling_interface.h b/cython/include/Subsampling_interface.h deleted file mode 100644 index f990da0c..00000000 --- a/cython/include/Subsampling_interface.h +++ /dev/null @@ -1,119 +0,0 @@ -/* 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 INCLUDE_SUBSAMPLING_INTERFACE_H_ -#define INCLUDE_SUBSAMPLING_INTERFACE_H_ - -#include <gudhi/choose_n_farthest_points.h> -#include <gudhi/pick_n_random_points.h> -#include <gudhi/sparsify_point_set.h> -#include <gudhi/Points_off_io.h> -#include <CGAL/Epick_d.h> - -#include <iostream> -#include <vector> -#include <string> - -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; - -// ------ choose_n_farthest_points ------ -std::vector<std::vector<double>> subsampling_n_farthest_points(const std::vector<std::vector<double>>& points, - unsigned nb_points) { - std::vector<std::vector<double>> landmarks; - Subsampling_dynamic_kernel k; - choose_n_farthest_points(k, points, nb_points, random_starting_point, std::back_inserter(landmarks)); - - return landmarks; -} - -std::vector<std::vector<double>> subsampling_n_farthest_points(const std::vector<std::vector<double>>& points, - unsigned nb_points, unsigned starting_point) { - 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(const 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(const 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); -} - -// ------ pick_n_random_points ------ -std::vector<std::vector<double>> subsampling_n_random_points(const std::vector<std::vector<double>>& points, - unsigned nb_points) { - std::vector<std::vector<double>> landmarks; - pick_n_random_points(points, nb_points, std::back_inserter(landmarks)); - - return landmarks; -} - -std::vector<std::vector<double>> subsampling_n_random_points_from_file(const 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_random_points(points, nb_points); -} - -// ------ sparsify_point_set ------ -std::vector<std::vector<double>> subsampling_sparsify_points(const std::vector<std::vector<double>>& points, - double min_squared_dist) { - std::vector<Subsampling_point_d> input, output; - for (auto point : points) - input.push_back(Subsampling_point_d(point.size(), point.begin(), point.end())); - Subsampling_dynamic_kernel k; - sparsify_point_set(k, input, min_squared_dist, std::back_inserter(output)); - - std::vector<std::vector<double>> landmarks; - for (auto point : output) - landmarks.push_back(std::vector<double>(point.cartesian_begin(), point.cartesian_end())); - return landmarks; -} - -std::vector<std::vector<double>> subsampling_sparsify_points_from_file(const std::string& off_file, - double min_squared_dist) { - Gudhi::Points_off_reader<std::vector<double>> off_reader(off_file); - std::vector<std::vector<double>> points = off_reader.get_point_cloud(); - return subsampling_sparsify_points(points, min_squared_dist); -} - -} // namespace subsampling - -} // namespace Gudhi - -#endif // INCLUDE_SUBSAMPLING_INTERFACE_H_ diff --git a/cython/include/Tangential_complex_interface.h b/cython/include/Tangential_complex_interface.h deleted file mode 100644 index 71418886..00000000 --- a/cython/include/Tangential_complex_interface.h +++ /dev/null @@ -1,116 +0,0 @@ -/* 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 INCLUDE_TANGENTIAL_COMPLEX_INTERFACE_H_ -#define INCLUDE_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> -#include <string> - -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; - using TC = Tangential_complex<Dynamic_kernel, CGAL::Dynamic_dimension_tag, CGAL::Parallel_tag>; - - public: - Tangential_complex_interface(int intrisic_dim, const std::vector<std::vector<double>>& points) { - Dynamic_kernel k; - - tangential_complex_ = new TC(points, intrisic_dim, k); - tangential_complex_->compute_tangential_complex(); - num_inconsistencies_ = tangential_complex_->number_of_inconsistent_simplices(); - } - - Tangential_complex_interface(int intrisic_dim, const std::string& off_file_name, bool from_file = true) { - Dynamic_kernel k; - - Gudhi::Points_off_reader<Point_d> off_reader(off_file_name); - std::vector<Point_d> points = off_reader.get_point_cloud(); - - tangential_complex_ = new TC(points, intrisic_dim, k); - tangential_complex_->compute_tangential_complex(); - num_inconsistencies_ = tangential_complex_->number_of_inconsistent_simplices(); - } - - ~Tangential_complex_interface() { - delete tangential_complex_; - } - - 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) { - tangential_complex_->create_complex<Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_full_featured>>(*simplex_tree); - simplex_tree->initialize_filtration(); - } - - private: - TC* tangential_complex_; - TC::Num_inconsistencies num_inconsistencies_; -}; - -} // namespace tangential_complex - -} // namespace Gudhi - -#endif // INCLUDE_TANGENTIAL_COMPLEX_INTERFACE_H_ diff --git a/cython/include/Witness_complex_interface.h b/cython/include/Witness_complex_interface.h deleted file mode 100644 index 01b372e7..00000000 --- a/cython/include/Witness_complex_interface.h +++ /dev/null @@ -1,74 +0,0 @@ -/* 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 INCLUDE_WITNESS_COMPLEX_INTERFACE_H_ -#define INCLUDE_WITNESS_COMPLEX_INTERFACE_H_ - -#include <gudhi/Simplex_tree.h> -#include <gudhi/Witness_complex.h> - -#include "Simplex_tree_interface.h" - -#include <vector> -#include <utility> // std::pair -#include <iostream> -#include <cstddef> - -namespace Gudhi { - -namespace witness_complex { - -class Witness_complex_interface { - using Nearest_landmark_range = std::vector<std::pair<std::size_t, double>>; - using Nearest_landmark_table = std::vector<Nearest_landmark_range>; - - public: - Witness_complex_interface(const Nearest_landmark_table& nlt) { - witness_complex_ = new Witness_complex<Nearest_landmark_table>(nlt); - } - - ~Witness_complex_interface() { - delete witness_complex_; - } - - void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square, - std::size_t limit_dimension) { - witness_complex_->create_complex(*simplex_tree, max_alpha_square, limit_dimension); - simplex_tree->initialize_filtration(); - } - - void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, - double max_alpha_square) { - witness_complex_->create_complex(*simplex_tree, max_alpha_square); - simplex_tree->initialize_filtration(); - } - - private: - Witness_complex<Nearest_landmark_table>* witness_complex_; -}; - -} // namespace witness_complex - -} // namespace Gudhi - -#endif // INCLUDE_WITNESS_COMPLEX_INTERFACE_H_ - |