diff options
Diffstat (limited to 'src/python/include')
-rw-r--r-- | src/python/include/Alpha_complex_interface.h | 72 | ||||
-rw-r--r-- | src/python/include/Bottleneck_distance_interface.h | 43 | ||||
-rw-r--r-- | src/python/include/Cubical_complex_interface.h | 52 | ||||
-rw-r--r-- | src/python/include/Euclidean_strong_witness_complex_interface.h | 83 | ||||
-rw-r--r-- | src/python/include/Euclidean_witness_complex_interface.h | 82 | ||||
-rw-r--r-- | src/python/include/Nerve_gic_interface.h | 51 | ||||
-rw-r--r-- | src/python/include/Off_reader_interface.h | 32 | ||||
-rw-r--r-- | src/python/include/Persistent_cohomology_interface.h | 111 | ||||
-rw-r--r-- | src/python/include/Reader_utils_interface.h | 46 | ||||
-rw-r--r-- | src/python/include/Rips_complex_interface.h | 72 | ||||
-rw-r--r-- | src/python/include/Simplex_tree_interface.h | 144 | ||||
-rw-r--r-- | src/python/include/Strong_witness_complex_interface.h | 63 | ||||
-rw-r--r-- | src/python/include/Subsampling_interface.h | 109 | ||||
-rw-r--r-- | src/python/include/Tangential_complex_interface.h | 111 | ||||
-rw-r--r-- | src/python/include/Witness_complex_interface.h | 64 |
15 files changed, 1135 insertions, 0 deletions
diff --git a/src/python/include/Alpha_complex_interface.h b/src/python/include/Alpha_complex_interface.h new file mode 100644 index 00000000..1199b741 --- /dev/null +++ b/src/python/include/Alpha_complex_interface.h @@ -0,0 +1,72 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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 const&) { + // 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/src/python/include/Bottleneck_distance_interface.h b/src/python/include/Bottleneck_distance_interface.h new file mode 100644 index 00000000..22c9a97a --- /dev/null +++ b/src/python/include/Bottleneck_distance_interface.h @@ -0,0 +1,43 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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/src/python/include/Cubical_complex_interface.h b/src/python/include/Cubical_complex_interface.h new file mode 100644 index 00000000..7d32914c --- /dev/null +++ b/src/python/include/Cubical_complex_interface.h @@ -0,0 +1,52 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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/src/python/include/Euclidean_strong_witness_complex_interface.h b/src/python/include/Euclidean_strong_witness_complex_interface.h new file mode 100644 index 00000000..90bd54ac --- /dev/null +++ b/src/python/include/Euclidean_strong_witness_complex_interface.h @@ -0,0 +1,83 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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/src/python/include/Euclidean_witness_complex_interface.h b/src/python/include/Euclidean_witness_complex_interface.h new file mode 100644 index 00000000..0c01a741 --- /dev/null +++ b/src/python/include/Euclidean_witness_complex_interface.h @@ -0,0 +1,82 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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/src/python/include/Nerve_gic_interface.h b/src/python/include/Nerve_gic_interface.h new file mode 100644 index 00000000..729b39fb --- /dev/null +++ b/src/python/include/Nerve_gic_interface.h @@ -0,0 +1,51 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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/src/python/include/Off_reader_interface.h b/src/python/include/Off_reader_interface.h new file mode 100644 index 00000000..4b3643be --- /dev/null +++ b/src/python/include/Off_reader_interface.h @@ -0,0 +1,32 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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/src/python/include/Persistent_cohomology_interface.h b/src/python/include/Persistent_cohomology_interface.h new file mode 100644 index 00000000..64e2ddc8 --- /dev/null +++ b/src/python/include/Persistent_cohomology_interface.h @@ -0,0 +1,111 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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/src/python/include/Reader_utils_interface.h b/src/python/include/Reader_utils_interface.h new file mode 100644 index 00000000..5bddf9ce --- /dev/null +++ b/src/python/include/Reader_utils_interface.h @@ -0,0 +1,46 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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/src/python/include/Rips_complex_interface.h b/src/python/include/Rips_complex_interface.h new file mode 100644 index 00000000..f818a2ed --- /dev/null +++ b/src/python/include/Rips_complex_interface.h @@ -0,0 +1,72 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#ifndef INCLUDE_RIPS_COMPLEX_INTERFACE_H_ +#define INCLUDE_RIPS_COMPLEX_INTERFACE_H_ + +#include <gudhi/Simplex_tree.h> +#include <gudhi/Rips_complex.h> +#include <gudhi/Sparse_rips_complex.h> +#include <gudhi/distance_functions.h> + +#include <boost/optional.hpp> + +#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: + void init_points(const std::vector<std::vector<double>>& points, double threshold) { + rips_complex_.emplace(points, threshold, Gudhi::Euclidean_distance()); + } + void init_matrix(const std::vector<std::vector<double>>& matrix, double threshold) { + rips_complex_.emplace(matrix, threshold); + } + + void init_points_sparse(const std::vector<std::vector<double>>& points, double threshold, double epsilon) { + sparse_rips_complex_.emplace(points, Gudhi::Euclidean_distance(), epsilon, -std::numeric_limits<double>::infinity(), threshold); + } + void init_matrix_sparse(const std::vector<std::vector<double>>& matrix, double threshold, double epsilon) { + sparse_rips_complex_.emplace(matrix, epsilon, -std::numeric_limits<double>::infinity(), threshold); + } + + void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, int dim_max) { + if (rips_complex_) + rips_complex_->create_complex(*simplex_tree, dim_max); + else + sparse_rips_complex_->create_complex(*simplex_tree, dim_max); + simplex_tree->initialize_filtration(); + } + + private: + // std::variant would work, but we don't require C++17 yet, and boost::variant is not super convenient. + // Anyway, storing a graph would make more sense. Or changing the interface completely so there is no such storage. + boost::optional<Rips_complex<Simplex_tree_interface<>::Filtration_value>> rips_complex_; + boost::optional<Sparse_rips_complex<Simplex_tree_interface<>::Filtration_value>> sparse_rips_complex_; +}; + +} // namespace rips_complex + +} // namespace Gudhi + +#endif // INCLUDE_RIPS_COMPLEX_INTERFACE_H_ diff --git a/src/python/include/Simplex_tree_interface.h b/src/python/include/Simplex_tree_interface.h new file mode 100644 index 00000000..c15a44a5 --- /dev/null +++ b/src/python/include/Simplex_tree_interface.h @@ -0,0 +1,144 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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 Filtered_simplices = 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(); + } + + Filtered_simplices get_filtration() { + Base::initialize_filtration(); + Filtered_simplices 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; + } + + Filtered_simplices get_skeleton(int dimension) { + Filtered_simplices 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; + } + + Filtered_simplices get_star(const Simplex& simplex) { + Filtered_simplices star; + for (auto f_simplex : Base::star_simplex_range(Base::find(simplex))) { + Simplex simplex_star; + for (auto vertex : Base::simplex_vertex_range(f_simplex)) { + simplex_star.insert(simplex_star.begin(), vertex); + } + star.push_back(std::make_pair(simplex_star, Base::filtration(f_simplex))); + } + return star; + } + + Filtered_simplices get_cofaces(const Simplex& simplex, int dimension) { + Filtered_simplices 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)) { + simplex_coface.insert(simplex_coface.begin(), vertex); + } + 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/src/python/include/Strong_witness_complex_interface.h b/src/python/include/Strong_witness_complex_interface.h new file mode 100644 index 00000000..4c333da8 --- /dev/null +++ b/src/python/include/Strong_witness_complex_interface.h @@ -0,0 +1,63 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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/src/python/include/Subsampling_interface.h b/src/python/include/Subsampling_interface.h new file mode 100644 index 00000000..bc390485 --- /dev/null +++ b/src/python/include/Subsampling_interface.h @@ -0,0 +1,109 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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/src/python/include/Tangential_complex_interface.h b/src/python/include/Tangential_complex_interface.h new file mode 100644 index 00000000..7c3f2789 --- /dev/null +++ b/src/python/include/Tangential_complex_interface.h @@ -0,0 +1,111 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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_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_interface() { + delete tangential_complex_; + } + + void compute_tangential_complex() { + 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) { + tangential_complex_->create_complex<Gudhi::Simplex_tree<Gudhi::Simplex_tree_options_full_featured>>(*simplex_tree); + simplex_tree->initialize_filtration(); + } + + void set_max_squared_edge_length(double max_squared_edge_length) { + tangential_complex_->set_max_squared_edge_length(max_squared_edge_length); + } + +private: + TC* tangential_complex_; + TC::Num_inconsistencies num_inconsistencies_; +}; + +} // namespace tangential_complex + +} // namespace Gudhi + +#endif // INCLUDE_TANGENTIAL_COMPLEX_INTERFACE_H_ diff --git a/src/python/include/Witness_complex_interface.h b/src/python/include/Witness_complex_interface.h new file mode 100644 index 00000000..609277d6 --- /dev/null +++ b/src/python/include/Witness_complex_interface.h @@ -0,0 +1,64 @@ +/* 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 + * + * Modification(s): + * - YYYY/MM Author: Description of the modification + */ + +#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_ + |