1 files changed, 36 insertions, 56 deletions

diff --git a/src/python/include/Alpha_complex_interface.h b/src/python/include/Alpha_complex_interface.h
index 3ac5db1f..23be194d 100644
--- a/src/python/include/Alpha_complex_interface.h
+++ b/src/python/include/Alpha_complex_interface.h
@@ -11,12 +11,8 @@
 #ifndef INCLUDE_ALPHA_COMPLEX_INTERFACE_H_
 #define INCLUDE_ALPHA_COMPLEX_INTERFACE_H_
 
-#include <gudhi/Simplex_tree.h>
-#include <gudhi/Alpha_complex.h>
-#include <CGAL/Epeck_d.h>
-#include <CGAL/Epick_d.h>
-
-#include <boost/range/adaptor/transformed.hpp>
+#include "Alpha_complex_factory.h"
+#include <gudhi/Alpha_complex_options.h>
 
 #include "Simplex_tree_interface.h"
 
@@ -30,67 +26,51 @@ namespace Gudhi {
 namespace alpha_complex {
 
 class Alpha_complex_interface {
- private:
-  using Exact_kernel = CGAL::Epeck_d<CGAL::Dynamic_dimension_tag>;
-  using Inexact_kernel = CGAL::Epick_d<CGAL::Dynamic_dimension_tag>;
-  using Point_exact_kernel = typename Exact_kernel::Point_d;
-  using Point_inexact_kernel = typename Inexact_kernel::Point_d;
-
-  template <typename CgalPointType>
-  std::vector<double> pt_cgal_to_cython(CgalPointType& point) {
-    std::vector<double> vd;
-    for (auto coord = point.cartesian_begin(); coord != point.cartesian_end(); coord++)
-      vd.push_back(CGAL::to_double(*coord));
-    return vd;
-  }
-
-  template <typename CgalPointType>
-  static CgalPointType pt_cython_to_cgal(std::vector<double> const& vec) {
-    return CgalPointType(vec.size(), vec.begin(), vec.end());
-  }
-
  public:
-  Alpha_complex_interface(const std::vector<std::vector<double>>& points, bool fast_version)
-      : fast_version_(fast_version) {
-    if (fast_version_) {
-      ac_inexact_ptr_ = std::make_unique<Alpha_complex<Inexact_kernel>>(
-          boost::adaptors::transform(points, pt_cython_to_cgal<Point_inexact_kernel>));
-    } else {
-      ac_exact_ptr_ = std::make_unique<Alpha_complex<Exact_kernel>>(
-          boost::adaptors::transform(points, pt_cython_to_cgal<Point_exact_kernel>));
-    }
-  }
-
-  Alpha_complex_interface(const std::string& off_file_name, bool fast_version, bool from_file = true)
-      : fast_version_(fast_version) {
-    if (fast_version_)
-      ac_inexact_ptr_ = std::make_unique<Alpha_complex<Inexact_kernel>>(off_file_name);
-    else
-      ac_exact_ptr_ = std::make_unique<Alpha_complex<Exact_kernel>>(off_file_name);
+  Alpha_complex_interface(const std::vector<std::vector<double>>& points, bool fast_version, bool exact_version)
+  : points_(points),
+    fast_version_(fast_version),
+    exact_version_(exact_version) {
   }
 
   std::vector<double> get_point(int vh) {
-    if (fast_version_) {
-      Point_inexact_kernel const& point = ac_inexact_ptr_->get_point(vh);
-      return pt_cgal_to_cython(point);
-    } else {
-      Point_exact_kernel const& point = ac_exact_ptr_->get_point(vh);
-      return pt_cgal_to_cython(point);
-    }
+    return alpha_ptr_->get_point(vh);
   }
 
-  void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square, bool exact_version,
+  void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square,
                            bool default_filtration_value) {
-    if (fast_version_)
-      ac_inexact_ptr_->create_complex(*simplex_tree, max_alpha_square, exact_version, default_filtration_value);
-    else
-      ac_exact_ptr_->create_complex(*simplex_tree, max_alpha_square, exact_version, default_filtration_value);
+    if (points_.size() > 0) {
+      std::size_t dimension = points_[0].size();
+      if (dimension == 3 && !default_filtration_value) {
+        if (fast_version_)
+          alpha_ptr_ = std::make_unique<Alphacomplex_3D<Gudhi::alpha_complex::complexity::FAST>>(points_);
+        else if (exact_version_)
+          alpha_ptr_ = std::make_unique<Alphacomplex_3D<Gudhi::alpha_complex::complexity::EXACT>>(points_);
+        else
+          alpha_ptr_ = std::make_unique<Alphacomplex_3D<Gudhi::alpha_complex::complexity::SAFE>>(points_);
+        if (!alpha_ptr_->create_simplex_tree(simplex_tree, max_alpha_square, default_filtration_value)) {
+          // create_simplex_tree will fail if all points are on a plane - Retry with dD by setting dimension to 2
+          dimension--;
+          alpha_ptr_.reset();
+        }
+      }
+      // Not ** else ** because we have to take into account if 3d fails
+      if (dimension != 3 || default_filtration_value) {
+        if (fast_version_) {
+          alpha_ptr_ = std::make_unique<Inexact_Alphacomplex_dD>(points_, exact_version_);
+        } else {
+          alpha_ptr_ = std::make_unique<Exact_Alphacomplex_dD>(points_, exact_version_);
+        }
+        alpha_ptr_->create_simplex_tree(simplex_tree, max_alpha_square, default_filtration_value);
+      }
+    }
   }
 
  private:
+  std::unique_ptr<Abstract_alpha_complex> alpha_ptr_;
+  std::vector<std::vector<double>> points_;
   bool fast_version_;
-  std::unique_ptr<Alpha_complex<Exact_kernel>> ac_exact_ptr_;
-  std::unique_ptr<Alpha_complex<Inexact_kernel>> ac_inexact_ptr_;
+  bool exact_version_;
 };
 
 }  // namespace alpha_complex