15 files changed, 1105 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..b3553d32
--- /dev/null
+++ b/src/python/include/Alpha_complex_interface.h
@@ -0,0 +1,70 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..a4f3eaf1
--- /dev/null
+++ b/src/python/include/Bottleneck_distance_interface.h
@@ -0,0 +1,41 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..648598e1
--- /dev/null
+++ b/src/python/include/Cubical_complex_interface.h
@@ -0,0 +1,50 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..c1c72737
--- /dev/null
+++ b/src/python/include/Euclidean_strong_witness_complex_interface.h
@@ -0,0 +1,81 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..5d7dbdc2
--- /dev/null
+++ b/src/python/include/Euclidean_witness_complex_interface.h
@@ -0,0 +1,80 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..5e7f8ae6
--- /dev/null
+++ b/src/python/include/Nerve_gic_interface.h
@@ -0,0 +1,49 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..e6e1f931
--- /dev/null
+++ b/src/python/include/Off_reader_interface.h
@@ -0,0 +1,30 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..8c79e6f3
--- /dev/null
+++ b/src/python/include/Persistent_cohomology_interface.h
@@ -0,0 +1,109 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..5f0deb87
--- /dev/null
+++ b/src/python/include/Reader_utils_interface.h
@@ -0,0 +1,44 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..a66b0e5b
--- /dev/null
+++ b/src/python/include/Rips_complex_interface.h
@@ -0,0 +1,70 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..06f31341
--- /dev/null
+++ b/src/python/include/Simplex_tree_interface.h
@@ -0,0 +1,142 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..cda5b514
--- /dev/null
+++ b/src/python/include/Strong_witness_complex_interface.h
@@ -0,0 +1,61 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..cdda851f
--- /dev/null
+++ b/src/python/include/Subsampling_interface.h
@@ -0,0 +1,107 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..698226cc
--- /dev/null
+++ b/src/python/include/Tangential_complex_interface.h
@@ -0,0 +1,109 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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..45e14253
--- /dev/null
+++ b/src/python/include/Witness_complex_interface.h
@@ -0,0 +1,62 @@
+/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
+ *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
+ *    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_
+