Add weight support

2 files changed, 79 insertions, 14 deletions

diff --git a/src/python/include/Alpha_complex_factory.h b/src/python/include/Alpha_complex_factory.h
index 3405fdd6..36e98615 100644
--- a/src/python/include/Alpha_complex_factory.h
+++ b/src/python/include/Alpha_complex_factory.h
@@ -55,13 +55,13 @@ class Abstract_alpha_complex {
   virtual ~Abstract_alpha_complex() = default;
 };
 
-class Exact_Alphacomplex_dD final : public Abstract_alpha_complex {
+class Exact_alpha_complex_dD final : public Abstract_alpha_complex {
  private:
   using Kernel = CGAL::Epeck_d<CGAL::Dynamic_dimension_tag>;
   using Point = typename Kernel::Point_d;
 
  public:
-  Exact_Alphacomplex_dD(const std::vector<std::vector<double>>& points, bool exact_version)
+  Exact_alpha_complex_dD(const std::vector<std::vector<double>>& points, bool exact_version)
     : exact_version_(exact_version),
       alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal<Point>)) {
   }
@@ -81,13 +81,13 @@ class Exact_Alphacomplex_dD final : public Abstract_alpha_complex {
   Alpha_complex<Kernel> alpha_complex_;
 };
 
-class Inexact_Alphacomplex_dD final : public Abstract_alpha_complex {
+class Inexact_alpha_complex_dD final : public Abstract_alpha_complex {
  private:
   using Kernel = CGAL::Epick_d<CGAL::Dynamic_dimension_tag>;
   using Point = typename Kernel::Point_d;
 
  public:
-  Inexact_Alphacomplex_dD(const std::vector<std::vector<double>>& points, bool exact_version)
+  Inexact_alpha_complex_dD(const std::vector<std::vector<double>>& points, bool exact_version)
     : exact_version_(exact_version),
       alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal<Point>)) {
   }
@@ -106,8 +106,61 @@ class Inexact_Alphacomplex_dD final : public Abstract_alpha_complex {
   Alpha_complex<Kernel> alpha_complex_;
 };
 
+class Exact_weighted_alpha_complex_dD final : public Abstract_alpha_complex {
+ private:
+  using Kernel = CGAL::Epeck_d<CGAL::Dynamic_dimension_tag>;
+  using Point = typename Kernel::Point_d;
+
+ public:
+  Exact_weighted_alpha_complex_dD(const std::vector<std::vector<double>>& points,
+                                  const std::vector<double>& weights, bool exact_version)
+    : exact_version_(exact_version),
+      alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal<Point>), weights) {
+  }
+
+  virtual std::vector<double> get_point(int vh) override {
+    Point const& point = alpha_complex_.get_point(vh).point();
+    return pt_cgal_to_cython(point);
+  }
+
+  virtual bool create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square,
+                                   bool default_filtration_value) override {
+    return alpha_complex_.create_complex(*simplex_tree, max_alpha_square, exact_version_, default_filtration_value);
+  }
+
+ private:
+  bool exact_version_;
+  Alpha_complex<Kernel, true> alpha_complex_;
+};
+
+class Inexact_weighted_alpha_complex_dD final : public Abstract_alpha_complex {
+ private:
+  using Kernel = CGAL::Epick_d<CGAL::Dynamic_dimension_tag>;
+  using Point = typename Kernel::Point_d;
+
+ public:
+  Inexact_weighted_alpha_complex_dD(const std::vector<std::vector<double>>& points,
+                                    const std::vector<double>& weights, bool exact_version)
+    : exact_version_(exact_version),
+      alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal<Point>), weights) {
+  }
+
+  virtual std::vector<double> get_point(int vh) override {
+    Point const& point = alpha_complex_.get_point(vh).point();
+    return pt_cgal_to_cython(point);
+  }
+  virtual bool create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square,
+                                   bool default_filtration_value) override {
+    return alpha_complex_.create_complex(*simplex_tree, max_alpha_square, exact_version_, default_filtration_value);
+  }
+
+ private:
+  bool exact_version_;
+  Alpha_complex<Kernel, true> alpha_complex_;
+};
+
 template <complexity Complexity>
-class Alphacomplex_3D final : public Abstract_alpha_complex {
+class Alpha_complex_3D final : public Abstract_alpha_complex {
  private:
   using Point = typename Alpha_complex_3d<Complexity, false, false>::Bare_point_3;
 
@@ -116,7 +169,7 @@ class Alphacomplex_3D final : public Abstract_alpha_complex {
   }
 
  public:
-  Alphacomplex_3D(const std::vector<std::vector<double>>& points)
+  Alpha_complex_3D(const std::vector<std::vector<double>>& points)
     : alpha_complex_(boost::adaptors::transform(points, pt_cython_to_cgal_3)) {
   }
 
diff --git a/src/python/include/Alpha_complex_interface.h b/src/python/include/Alpha_complex_interface.h
index 23be194d..43c96b2f 100644
--- a/src/python/include/Alpha_complex_interface.h
+++ b/src/python/include/Alpha_complex_interface.h
@@ -27,8 +27,11 @@ namespace alpha_complex {
 
 class Alpha_complex_interface {
  public:
-  Alpha_complex_interface(const std::vector<std::vector<double>>& points, bool fast_version, bool exact_version)
+  Alpha_complex_interface(const std::vector<std::vector<double>>& points,
+                          const std::vector<double>& weights,
+                          bool fast_version, bool exact_version)
   : points_(points),
+    weights_(weights),
     fast_version_(fast_version),
     exact_version_(exact_version) {
   }
@@ -41,13 +44,13 @@ class Alpha_complex_interface {
                            bool default_filtration_value) {
     if (points_.size() > 0) {
       std::size_t dimension = points_[0].size();
-      if (dimension == 3 && !default_filtration_value) {
+      if (dimension == 3 && weights_.size() == 0 && !default_filtration_value) {
         if (fast_version_)
-          alpha_ptr_ = std::make_unique<Alphacomplex_3D<Gudhi::alpha_complex::complexity::FAST>>(points_);
+          alpha_ptr_ = std::make_unique<Alpha_complex_3D<Gudhi::alpha_complex::complexity::FAST>>(points_);
         else if (exact_version_)
-          alpha_ptr_ = std::make_unique<Alphacomplex_3D<Gudhi::alpha_complex::complexity::EXACT>>(points_);
+          alpha_ptr_ = std::make_unique<Alpha_complex_3D<Gudhi::alpha_complex::complexity::EXACT>>(points_);
         else
-          alpha_ptr_ = std::make_unique<Alphacomplex_3D<Gudhi::alpha_complex::complexity::SAFE>>(points_);
+          alpha_ptr_ = std::make_unique<Alpha_complex_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--;
@@ -55,11 +58,19 @@ class Alpha_complex_interface {
         }
       }
       // Not ** else ** because we have to take into account if 3d fails
-      if (dimension != 3 || default_filtration_value) {
+      if (dimension != 3 || weights_.size() != 0 || default_filtration_value) {
         if (fast_version_) {
-          alpha_ptr_ = std::make_unique<Inexact_Alphacomplex_dD>(points_, exact_version_);
+          if (weights_.size() == 0) {
+            alpha_ptr_ = std::make_unique<Inexact_alpha_complex_dD>(points_, exact_version_);
+          } else {
+            alpha_ptr_ = std::make_unique<Inexact_weighted_alpha_complex_dD>(points_, weights_, exact_version_);
+          }
         } else {
-          alpha_ptr_ = std::make_unique<Exact_Alphacomplex_dD>(points_, exact_version_);
+          if (weights_.size() == 0) {
+            alpha_ptr_ = std::make_unique<Exact_alpha_complex_dD>(points_, exact_version_);
+          } else {
+            alpha_ptr_ = std::make_unique<Exact_weighted_alpha_complex_dD>(points_, weights_, exact_version_);
+          }
         }
         alpha_ptr_->create_simplex_tree(simplex_tree, max_alpha_square, default_filtration_value);
       }
@@ -69,6 +80,7 @@ class Alpha_complex_interface {
  private:
   std::unique_ptr<Abstract_alpha_complex> alpha_ptr_;
   std::vector<std::vector<double>> points_;
+  std::vector<double> weights_;
   bool fast_version_;
   bool exact_version_;
 };