From db938dbd74460e7a0fd705be8628984052f71dc0 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Fri, 4 Sep 2020 17:23:16 +0200
Subject: Alpha_kernel_d, its tests and Alpha complex to use it

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 106 +++++++++++++-----------
 1 file changed, 57 insertions(+), 49 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index ba91998d..8e9fe773 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -12,6 +12,7 @@
 #ifndef ALPHA_COMPLEX_H_
 #define ALPHA_COMPLEX_H_
 
+#include <gudhi/Alpha_complex/Alpha_kernel_d.h>
 #include <gudhi/Debug_utils.h>
 // to construct Alpha_complex from a OFF file of points
 #include <gudhi/Points_off_io.h>
@@ -20,6 +21,7 @@
 #include <math.h>  // isnan, fmax
 
 #include <CGAL/Delaunay_triangulation.h>
+#include <CGAL/Regular_triangulation.h>  // aka. Weighted Delaunay triangulation
 #include <CGAL/Epeck_d.h>  // For EXACT or SAFE version
 #include <CGAL/Epick_d.h>  // For FAST version
 #include <CGAL/Spatial_sort_traits_adapter_d.h>
@@ -91,49 +93,55 @@ template<typename D> struct Is_Epeck_D<CGAL::Epeck_d<D>> { static const bool val
  * guarantee that the output is a valid filtration (faces have a filtration value no larger than their cofaces).
  * - For performances reasons, it is advised to use `Alpha_complex` with \ref cgal &ge; 5.0.0.
  */
-template<class Kernel = CGAL::Epeck_d<CGAL::Dynamic_dimension_tag>>
+template<class Kernel = CGAL::Epeck_d<CGAL::Dynamic_dimension_tag>, bool Weighted = false>
 class Alpha_complex {
  public:
+  /** \brief Geometric traits class that provides the geometric types and predicates needed by the triangulations.*/
+  using Geom_traits = typename std::conditional<Weighted, CGAL::Regular_triangulation_traits_adapter<Kernel>,
+                                                          Kernel>::type;
   // Add an int in TDS to save point index in the structure
-  typedef CGAL::Triangulation_data_structure<typename Kernel::Dimension,
-                              CGAL::Triangulation_vertex<Kernel, std::ptrdiff_t>,
-                              CGAL::Triangulation_full_cell<Kernel> > TDS;
-  /** \brief A Delaunay triangulation of a set of points in \f$ \mathbb{R}^D\f$.*/
-  typedef CGAL::Delaunay_triangulation<Kernel, TDS> Delaunay_triangulation;
+  using TDS = CGAL::Triangulation_data_structure<typename Geom_traits::Dimension,
+                                                 CGAL::Triangulation_vertex<Geom_traits, std::ptrdiff_t>,
+                                                 CGAL::Triangulation_full_cell<Geom_traits> >;
+  /** \brief A (Weighted or not) Delaunay triangulation of a set of points in \f$ \mathbb{R}^D\f$.*/
+  using Triangulation = typename std::conditional<Weighted, CGAL::Regular_triangulation<Kernel, TDS>,
+                                                            CGAL::Delaunay_triangulation<Kernel, TDS>>::type;
+
+  using A_kernel_d = Alpha_kernel_d<Kernel, Weighted>;
+
+  // Numeric type of coordinates in the kernel
+  using FT = typename A_kernel_d::FT;
+
+  /** \brief If Weighted, the weighted point is cached (point + weight [= squared radius]),
+   * else a pair of point and squared radius is cached.
+  */
+  using Sphere = typename A_kernel_d::Sphere;
 
   /** \brief A point in Euclidean space.*/
-  typedef typename Kernel::Point_d Point_d;
-  /** \brief Geometric traits class that provides the geometric types and predicates needed by Delaunay
-   * triangulations.*/
-  typedef Kernel Geom_traits;
+  using Point_d = typename std::conditional<Weighted, typename A_kernel_d::Weighted_point_d,
+                                                      typename A_kernel_d::Point_d>::type;
 
  private:
-  typedef typename Kernel::Compute_squared_radius_d Squared_Radius;
-  typedef typename Kernel::Side_of_bounded_sphere_d Is_Gabriel;
-  typedef typename Kernel::Point_dimension_d        Point_Dimension;
-
   // Vertex_iterator type from CGAL.
-  typedef typename Delaunay_triangulation::Vertex_iterator CGAL_vertex_iterator;
+  using CGAL_vertex_iterator = typename Triangulation::Vertex_iterator;
 
   // size_type type from CGAL.
-  typedef typename Delaunay_triangulation::size_type size_type;
+  using size_type = typename Triangulation::size_type;
 
   // Structure to switch from simplex tree vertex handle to CGAL vertex iterator.
-  typedef typename std::vector< CGAL_vertex_iterator > Vector_vertex_iterator;
-
-  // Numeric type of coordinates in the kernel
-  typedef typename Kernel::FT FT;
+  using Vector_vertex_iterator = typename std::vector< CGAL_vertex_iterator >;
 
  private:
   /** \brief Vertex iterator vector to switch from simplex tree vertex handle to CGAL vertex iterator.
    * Vertex handles are inserted sequentially, starting at 0.*/
   Vector_vertex_iterator vertex_handle_to_iterator_;
   /** \brief Pointer on the CGAL Delaunay triangulation.*/
-  Delaunay_triangulation* triangulation_;
+  Triangulation* triangulation_;
   /** \brief Kernel for triangulation_ functions access.*/
-  Kernel kernel_;
+  A_kernel_d kernel_;
+
   /** \brief Cache for geometric constructions: circumcenter and squared radius of a simplex.*/
-  std::vector<std::pair<Point_d, FT>> cache_, old_cache_;
+  std::vector<Sphere> cache_, old_cache_;
 
  public:
   /** \brief Alpha_complex constructor from an OFF file name.
@@ -160,10 +168,10 @@ class Alpha_complex {
    *
    * Duplicate points are inserted once in the Alpha_complex. This is the reason why the vertices may be not contiguous.
    * 
-   * @param[in] points Range of points to triangulate. Points must be in Kernel::Point_d
+   * @param[in] points Range of points to triangulate. Points must be in Kernel::Point_d or Kernel::Weighted_point_d.
    * 
    * The type InputPointRange must be a range for which std::begin and
-   * std::end return input iterators on a Kernel::Point_d.
+   * std::end return input iterators on a Kernel::Point_d or Kernel::Weighted_point_d.
    */
   template<typename InputPointRange >
   Alpha_complex(const InputPointRange& points)
@@ -206,11 +214,8 @@ class Alpha_complex {
     auto last = std::end(points);
 
     if (first != last) {
-      // point_dimension function initialization
-      Point_Dimension point_dimension = kernel_.point_dimension_d_object();
-
-      // Delaunay triangulation is point dimension.
-      triangulation_ = new Delaunay_triangulation(point_dimension(*first));
+      // Delaunay triangulation init with point dimension.
+      triangulation_ = new Triangulation(kernel_.get_dimension(*first));
 
       std::vector<Point_d> point_cloud(first, last);
 
@@ -218,18 +223,22 @@ class Alpha_complex {
       std::vector<std::ptrdiff_t> indices(boost::counting_iterator<std::ptrdiff_t>(0),
                                           boost::counting_iterator<std::ptrdiff_t>(point_cloud.size()));
 
-      typedef boost::iterator_property_map<typename std::vector<Point_d>::iterator,
-                                           CGAL::Identity_property_map<std::ptrdiff_t>> Point_property_map;
-      typedef CGAL::Spatial_sort_traits_adapter_d<Kernel, Point_property_map> Search_traits_d;
+      using Point_property_map = boost::iterator_property_map<typename std::vector<Point_d>::iterator,
+                                                              CGAL::Identity_property_map<std::ptrdiff_t>>;
+      using Search_traits_d = CGAL::Spatial_sort_traits_adapter_d<Geom_traits, Point_property_map>;
 
       CGAL::spatial_sort(indices.begin(), indices.end(), Search_traits_d(std::begin(point_cloud)));
 
-      typename Delaunay_triangulation::Full_cell_handle hint;
+      typename Triangulation::Full_cell_handle hint;
       for (auto index : indices) {
-        typename Delaunay_triangulation::Vertex_handle pos = triangulation_->insert(point_cloud[index], hint);
-        // Save index value as data to retrieve it after insertion
-        pos->data() = index;
-        hint = pos->full_cell();
+        typename Triangulation::Vertex_handle pos = triangulation_->insert(point_cloud[index], hint);
+        if (pos != nullptr) {
+          // Save index value as data to retrieve it after insertion
+          pos->data() = index;
+          hint = pos->full_cell();
+        } else {
+          std::cout << "NULLPTR" << std::endl;
+        }
       }
       // --------------------------------------------------------------------------------------------
       // structure to retrieve CGAL points from vertex handle - one vertex handle per point.
@@ -270,9 +279,7 @@ class Alpha_complex {
       v.clear();
       for (auto vertex : cplx.simplex_vertex_range(s))
         v.push_back(get_point_(vertex));
-      Point_d c = kernel_.construct_circumcenter_d_object()(v.cbegin(), v.cend());
-      FT r = kernel_.squared_distance_d_object()(c, v[0]);
-      cache_.emplace_back(std::move(c), std::move(r));
+      cache_.emplace_back(kernel_.get_sphere(v.cbegin(), v.cend()));
     }
     return cache_[k];
   }
@@ -282,13 +289,13 @@ class Alpha_complex {
   auto radius(SimplicialComplexForAlpha& cplx, typename SimplicialComplexForAlpha::Simplex_handle s) {
     auto k = cplx.key(s);
     if(k!=cplx.null_key())
-      return old_cache_[k].second;
+      return kernel_.get_squared_radius(old_cache_[k]);
     // Using a transform_range is slower, currently.
     thread_local std::vector<Point_d> v;
     v.clear();
     for (auto vertex : cplx.simplex_vertex_range(s))
       v.push_back(get_point_(vertex));
-    return kernel_.compute_squared_radius_d_object()(v.cbegin(), v.cend());
+    return kernel_.get_squared_radius(v.cbegin(), v.cend());
   }
 
  public:
@@ -322,9 +329,9 @@ class Alpha_complex {
                       bool exact = false,
                       bool default_filtration_value = false) {
     // From SimplicialComplexForAlpha type required to insert into a simplicial complex (with or without subfaces).
-    typedef typename SimplicialComplexForAlpha::Vertex_handle Vertex_handle;
-    typedef typename SimplicialComplexForAlpha::Simplex_handle Simplex_handle;
-    typedef std::vector<Vertex_handle> Vector_vertex;
+    using Vertex_handle = typename SimplicialComplexForAlpha::Vertex_handle;
+    using Simplex_handle = typename SimplicialComplexForAlpha::Simplex_handle;
+    using Vector_vertex = std::vector<Vertex_handle>;
 
     if (triangulation_ == nullptr) {
       std::cerr << "Alpha_complex cannot create_complex from a NULL triangulation\n";
@@ -416,8 +423,8 @@ class Alpha_complex {
   template <typename SimplicialComplexForAlpha, typename Simplex_handle>
   void propagate_alpha_filtration(SimplicialComplexForAlpha& complex, Simplex_handle f_simplex) {
     // From SimplicialComplexForAlpha type required to assign filtration values.
-    typedef typename SimplicialComplexForAlpha::Filtration_value Filtration_value;
-    typedef typename SimplicialComplexForAlpha::Vertex_handle Vertex_handle;
+    using Filtration_value = typename SimplicialComplexForAlpha::Filtration_value;
+    using Vertex_handle = typename SimplicialComplexForAlpha::Vertex_handle;
 
     // ### Foreach Tau face of Sigma
     for (auto f_boundary : complex.boundary_simplex_range(f_simplex)) {
@@ -450,7 +457,8 @@ class Alpha_complex {
         while(shortiter != enditer && *longiter == *shortiter) { ++longiter; ++shortiter; }
         Vertex_handle extra = *longiter;
         auto const& cache=get_cache(complex, f_boundary);
-        bool is_gab = kernel_.squared_distance_d_object()(cache.first, get_point_(extra)) >= cache.second;
+        bool is_gab = kernel_.get_squared_distance(kernel_.get_circumcenter(cache), get_point_(extra)) >=
+                      kernel_.get_squared_radius(cache);
 #ifdef DEBUG_TRACES
         std::clog << " | Tau is_gabriel(Sigma)=" << is_gab << " - vertexForGabriel=" << extra << std::endl;
 #endif  // DEBUG_TRACES
-- 
cgit v1.2.3


From 171ddab9b7a50f0303d7201fa547dbfb445f9698 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Fri, 11 Sep 2020 11:55:55 +0200
Subject: Requires CGAL >= 5.1. Fix is_gabriel computation

---
 src/Alpha_complex/example/CMakeLists.txt                | 14 +++++++++-----
 .../example/Weighted_alpha_complex_from_points.cpp      | 14 +++++++-------
 src/Alpha_complex/include/gudhi/Alpha_complex.h         |  8 ++++++--
 .../include/gudhi/Alpha_complex/Alpha_kernel_d.h        | 17 ++++-------------
 src/Alpha_complex/test/CMakeLists.txt                   | 13 +++++++++----
 5 files changed, 35 insertions(+), 31 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/example/CMakeLists.txt b/src/Alpha_complex/example/CMakeLists.txt
index 17dc896c..1fc2330a 100644
--- a/src/Alpha_complex/example/CMakeLists.txt
+++ b/src/Alpha_complex/example/CMakeLists.txt
@@ -7,13 +7,10 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
   target_link_libraries(Alpha_complex_example_from_off ${CGAL_LIBRARY})
   add_executable ( Alpha_complex_example_fast_from_off Fast_alpha_complex_from_off.cpp )
   target_link_libraries(Alpha_complex_example_fast_from_off ${CGAL_LIBRARY})
-  add_executable ( Weighted_alpha_complex_example_from_points Weighted_alpha_complex_from_points.cpp )
-  target_link_libraries(Weighted_alpha_complex_example_from_points  ${CGAL_LIBRARY})
   if (TBB_FOUND)
     target_link_libraries(Alpha_complex_example_from_points ${TBB_LIBRARIES})
     target_link_libraries(Alpha_complex_example_from_off ${TBB_LIBRARIES})
     target_link_libraries(Alpha_complex_example_fast_from_off ${TBB_LIBRARIES})
-    target_link_libraries(Weighted_alpha_complex_example_from_points ${TBB_LIBRARIES})
   endif()
 
   add_test(NAME Alpha_complex_example_from_points COMMAND $<TARGET_FILE:Alpha_complex_example_from_points>)
@@ -28,8 +25,6 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
   add_test(NAME Alpha_complex_example_fast_from_off_32 COMMAND $<TARGET_FILE:Alpha_complex_example_fast_from_off>
       "${CMAKE_SOURCE_DIR}/data/points/alphacomplexdoc.off" "32.0" "${CMAKE_CURRENT_BINARY_DIR}/fastalphaoffreader_result_32.txt")
 
-  add_test(NAME Weighted_alpha_complex_example_from_points COMMAND $<TARGET_FILE:Weighted_alpha_complex_example_from_points>)
-
   if (DIFF_PATH)
     # Do not forget to copy test results files in current binary dir
     file(COPY "alphaoffreader_for_doc_32.txt" DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/)
@@ -69,3 +64,12 @@ if (NOT CGAL_VERSION VERSION_LESS 4.11.0)
           COMMAND $<TARGET_FILE:Alpha_complex_example_3d_from_points>)
 
 endif(NOT CGAL_VERSION VERSION_LESS 4.11.0)
+
+if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
+  add_executable ( Weighted_alpha_complex_example_from_points Weighted_alpha_complex_from_points.cpp )
+  target_link_libraries(Weighted_alpha_complex_example_from_points  ${CGAL_LIBRARY})
+  if (TBB_FOUND)
+    target_link_libraries(Weighted_alpha_complex_example_from_points ${TBB_LIBRARIES})
+  endif()
+  add_test(NAME Weighted_alpha_complex_example_from_points COMMAND $<TARGET_FILE:Weighted_alpha_complex_example_from_points>)
+endif(NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
diff --git a/src/Alpha_complex/example/Weighted_alpha_complex_from_points.cpp b/src/Alpha_complex/example/Weighted_alpha_complex_from_points.cpp
index 05858084..19a04282 100644
--- a/src/Alpha_complex/example/Weighted_alpha_complex_from_points.cpp
+++ b/src/Alpha_complex/example/Weighted_alpha_complex_from_points.cpp
@@ -18,13 +18,13 @@ int main() {
   // Init of a list of points
   // ----------------------------------------------------------------------------
   Vector_of_points points;
-  points.push_back(Weighted_point(Bare_point(1.0, 1.0) , 0.));
-  points.push_back(Weighted_point(Bare_point(7.0, 0.0) , 0.));
-  points.push_back(Weighted_point(Bare_point(4.0, 6.0) , 0.));
-  points.push_back(Weighted_point(Bare_point(9.0, 6.0) , 0.));
-  points.push_back(Weighted_point(Bare_point(0.0, 14.0), 0.));
-  points.push_back(Weighted_point(Bare_point(2.0, 19.0), 0.));
-  points.push_back(Weighted_point(Bare_point(9.0, 17.0), 0.));
+  points.push_back(Weighted_point(Bare_point(1.0, 1.0) , 1.));
+  points.push_back(Weighted_point(Bare_point(7.0, 0.0) , 1.));
+  points.push_back(Weighted_point(Bare_point(4.0, 6.0) , 1.));
+  points.push_back(Weighted_point(Bare_point(9.0, 6.0) , 1.));
+  points.push_back(Weighted_point(Bare_point(0.0, 14.0), 1.));
+  points.push_back(Weighted_point(Bare_point(2.0, 19.0), 1.));
+  points.push_back(Weighted_point(Bare_point(9.0, 17.0), 1.));
 
   // ----------------------------------------------------------------------------
   // Init of an alpha complex from the list of points
diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index 8e9fe773..4316d9bc 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -210,6 +210,11 @@ class Alpha_complex {
                 << std::endl;
     #endif
 
+#if CGAL_VERSION_NR < 1050101000
+    // Make compilation fail if weighted and CGAL < 5.1
+    static_assert(!Weighted, "Weighted Alpha_complex is only available for CGAL >= 5.1");
+#endif
+
     auto first = std::begin(points);
     auto last = std::end(points);
 
@@ -457,8 +462,7 @@ class Alpha_complex {
         while(shortiter != enditer && *longiter == *shortiter) { ++longiter; ++shortiter; }
         Vertex_handle extra = *longiter;
         auto const& cache=get_cache(complex, f_boundary);
-        bool is_gab = kernel_.get_squared_distance(kernel_.get_circumcenter(cache), get_point_(extra)) >=
-                      kernel_.get_squared_radius(cache);
+        bool is_gab = kernel_.is_gabriel(cache, get_point_(extra));
 #ifdef DEBUG_TRACES
         std::clog << " | Tau is_gabriel(Sigma)=" << is_gab << " - vertexForGabriel=" << extra << std::endl;
 #endif  // DEBUG_TRACES
diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex/Alpha_kernel_d.h b/src/Alpha_complex/include/gudhi/Alpha_complex/Alpha_kernel_d.h
index a3e3845a..b64e4f59 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex/Alpha_kernel_d.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex/Alpha_kernel_d.h
@@ -71,13 +71,8 @@ class Alpha_kernel_d<Kernel, false> {
     return sph.second;
   }
 
-  auto get_circumcenter(const Sphere& sph) const {
-    return sph.first;
-  }
-
-  template<class Point>
-  FT get_squared_distance(const Point& first, const Point& second) const {
-    return kernel_.squared_distance_d_object()(first, second);
+  bool is_gabriel(const Sphere& circumcenter, const Point_d& point) {
+    return kernel_.squared_distance_d_object()(circumcenter.first, point) >= circumcenter.second;
   }
 };
 
@@ -116,12 +111,8 @@ class Alpha_kernel_d<Kernel, true> {
     return sph.weight();
   }
 
-  auto get_circumcenter(const Sphere& sph) const {
-    return sph;
-  }
-
-  FT get_squared_distance(const Weighted_point_d& first, const Weighted_point_d& second) const {
-    return kernel_.power_distance_d_object()(first, second);
+  bool is_gabriel(const Sphere& circumcenter, const Weighted_point_d& point) {
+    return kernel_.power_distance_d_object()(circumcenter, point) >= 0;
   }
 };
 
diff --git a/src/Alpha_complex/test/CMakeLists.txt b/src/Alpha_complex/test/CMakeLists.txt
index 71e4ea7c..837d2948 100644
--- a/src/Alpha_complex/test/CMakeLists.txt
+++ b/src/Alpha_complex/test/CMakeLists.txt
@@ -10,17 +10,13 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
   target_link_libraries(Alpha_complex_test_unit ${CGAL_LIBRARY})
   add_executable ( Delaunay_complex_test_unit Delaunay_complex_unit_test.cpp )
   target_link_libraries(Delaunay_complex_test_unit ${CGAL_LIBRARY})
-  add_executable ( Alpha_kernel_d_test_unit Alpha_kernel_d_unit_test.cpp )
-  target_link_libraries(Alpha_kernel_d_test_unit ${CGAL_LIBRARY})
   if (TBB_FOUND)
     target_link_libraries(Alpha_complex_test_unit ${TBB_LIBRARIES})
     target_link_libraries(Delaunay_complex_test_unit ${TBB_LIBRARIES})
-    target_link_libraries(Alpha_kernel_d_test_unit ${TBB_LIBRARIES})
   endif()
 
   gudhi_add_boost_test(Alpha_complex_test_unit)
   gudhi_add_boost_test(Delaunay_complex_test_unit)
-  gudhi_add_boost_test(Alpha_kernel_d_test_unit)
 
 endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 4.11.0)
 
@@ -47,3 +43,12 @@ if (NOT CGAL_VERSION VERSION_LESS 4.11.0)
   gudhi_add_boost_test(Weighted_periodic_alpha_complex_3d_test_unit)
 
 endif (NOT CGAL_VERSION VERSION_LESS 4.11.0)
+
+if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
+  add_executable ( Alpha_kernel_d_test_unit Alpha_kernel_d_unit_test.cpp )
+  target_link_libraries(Alpha_kernel_d_test_unit ${CGAL_LIBRARY})
+  if (TBB_FOUND)
+    target_link_libraries(Alpha_kernel_d_test_unit ${TBB_LIBRARIES})
+  endif()
+  gudhi_add_boost_test(Alpha_kernel_d_test_unit)
+endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
\ No newline at end of file
-- 
cgit v1.2.3


From 54e0cec31e556c88d9f8107394ad972883fdbbdf Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Fri, 11 Sep 2020 17:41:39 +0200
Subject: Add weighted ctor and its test

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h    | 26 +++++++
 src/Alpha_complex/test/CMakeLists.txt              |  8 +++
 .../test/Weighted_alpha_complex_unit_test.cpp      | 82 ++++++++++++++++++++++
 3 files changed, 116 insertions(+)
 create mode 100644 src/Alpha_complex/test/Weighted_alpha_complex_unit_test.cpp

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index 4316d9bc..00231e1c 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -31,6 +31,10 @@
 
 #include <Eigen/src/Core/util/Macros.h>  // for EIGEN_VERSION_AT_LEAST
 
+#include <boost/range/size.hpp>
+#include <boost/range/combine.hpp>
+#include <boost/range/adaptor/transformed.hpp>
+
 #include <iostream>
 #include <vector>
 #include <string>
@@ -179,6 +183,28 @@ class Alpha_complex {
     init_from_range(points);
   }
 
+  /** \brief Alpha_complex constructor from a list of points and weights.
+   *
+   * Duplicate points are inserted once in the Alpha_complex. This is the reason why the vertices may be not contiguous.
+   * 
+   * @param[in] points Range of points to triangulate. Points must be in Kernel::Point_d or Kernel::Weighted_point_d.
+   * 
+   * @param[in] weights Range of points weights. Weights must be in Kernel::FT.
+   * 
+   * The type InputPointRange must be a range for which std::begin and
+   * std::end return input iterators on a Kernel::Point_d.
+   */
+  template <typename InputPointRange, typename WeightRange>
+  Alpha_complex(const InputPointRange& points, WeightRange weights) {
+    static_assert(Weighted, "This constructor is not available for non-weighted versions of Alpha_complex_3d");
+    // FIXME: this test is only valid if we have a forward range
+    GUDHI_CHECK(boost::size(weights) == boost::size(points),
+                std::invalid_argument("Points number in range different from weights range number"));
+    auto weighted_points = boost::range::combine(points, weights)
+      | boost::adaptors::transformed([](auto const&t){return Point_d(boost::get<0>(t), boost::get<1>(t));});
+    init_from_range(weighted_points);
+  }
+
   /** \brief Alpha_complex destructor deletes the Delaunay triangulation.
    */
   ~Alpha_complex() {
diff --git a/src/Alpha_complex/test/CMakeLists.txt b/src/Alpha_complex/test/CMakeLists.txt
index 837d2948..db5d840f 100644
--- a/src/Alpha_complex/test/CMakeLists.txt
+++ b/src/Alpha_complex/test/CMakeLists.txt
@@ -51,4 +51,12 @@ if (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
     target_link_libraries(Alpha_kernel_d_test_unit ${TBB_LIBRARIES})
   endif()
   gudhi_add_boost_test(Alpha_kernel_d_test_unit)
+  
+  add_executable ( Weighted_alpha_complex_test_unit Weighted_alpha_complex_unit_test.cpp )
+  target_link_libraries(Weighted_alpha_complex_test_unit ${CGAL_LIBRARY})
+  if (TBB_FOUND)
+    target_link_libraries(Weighted_alpha_complex_test_unit ${TBB_LIBRARIES})
+  endif()
+  gudhi_add_boost_test(Weighted_alpha_complex_test_unit)
+
 endif (NOT CGAL_WITH_EIGEN3_VERSION VERSION_LESS 5.1.0)
\ No newline at end of file
diff --git a/src/Alpha_complex/test/Weighted_alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Weighted_alpha_complex_unit_test.cpp
new file mode 100644
index 00000000..b4fc76de
--- /dev/null
+++ b/src/Alpha_complex/test/Weighted_alpha_complex_unit_test.cpp
@@ -0,0 +1,82 @@
+/*    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) 2020 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#define BOOST_TEST_DYN_LINK
+#define BOOST_TEST_MODULE "weighted_alpha_complex"
+#include <boost/test/unit_test.hpp>
+#include <boost/mpl/list.hpp>
+
+#include <CGAL/Epick_d.h>
+#include <CGAL/Epeck_d.h>
+
+#include <cmath>  // float comparison
+#include <vector>
+#include <random>
+
+#include <gudhi/Alpha_complex.h>
+#include <gudhi/Simplex_tree.h>
+#include <gudhi/Unitary_tests_utils.h>
+
+// Use dynamic_dimension_tag for the user to be able to set dimension
+typedef CGAL::Epeck_d< CGAL::Dynamic_dimension_tag > Exact_kernel_d;
+// Use static dimension_tag for the user not to be able to set dimension
+typedef CGAL::Epeck_d< CGAL::Dimension_tag<4> > Exact_kernel_s;
+// Use dynamic_dimension_tag for the user to be able to set dimension
+typedef CGAL::Epick_d< CGAL::Dynamic_dimension_tag > Inexact_kernel_d;
+// Use static dimension_tag for the user not to be able to set dimension
+typedef CGAL::Epick_d< CGAL::Dimension_tag<4> > Inexact_kernel_s;
+// The triangulation uses the default instantiation of the TriangulationDataStructure template parameter
+
+typedef boost::mpl::list<Exact_kernel_d, Exact_kernel_s, Inexact_kernel_d, Inexact_kernel_s> list_of_kernel_variants;
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(Zero_weighted_alpha_complex, Kernel, list_of_kernel_variants) {
+  // Random points construction
+  using Point_d = typename Kernel::Point_d;
+  std::vector<Point_d> points;
+  std::uniform_real_distribution<double> rd_pts(-10., 10.);
+  std::random_device rand_dev;
+  std::mt19937 rand_engine(rand_dev());
+  for (int idx = 0; idx < 20; idx++) {
+    std::vector<double> point {rd_pts(rand_engine), rd_pts(rand_engine), rd_pts(rand_engine), rd_pts(rand_engine)};
+    points.emplace_back(Point_d(point.begin(), point.end()));
+  }
+  
+  // Alpha complex from points
+  Gudhi::alpha_complex::Alpha_complex<Kernel, false> alpha_complex_from_points(points);
+  Gudhi::Simplex_tree<> simplex;
+  BOOST_CHECK(alpha_complex_from_points.create_complex(simplex));
+  std::clog << "Iterator on alpha complex simplices in the filtration order, with [filtration value]:" << std::endl;
+  for (auto f_simplex : simplex.filtration_simplex_range()) {
+    std::clog << "   ( ";
+    for (auto vertex : simplex.simplex_vertex_range(f_simplex)) {
+      std::clog << vertex << " ";
+    }
+    std::clog << ") -> " << "[" << simplex.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
+  }
+
+  // Alpha complex from zero weighted points
+  std::vector<typename Kernel::FT> weights(20, 0.);
+  Gudhi::alpha_complex::Alpha_complex<Kernel, true> alpha_complex_from_zero_weighted_points(points, weights);
+  Gudhi::Simplex_tree<> zw_simplex;
+  BOOST_CHECK(alpha_complex_from_zero_weighted_points.create_complex(zw_simplex));
+
+  std::clog << "Iterator on zero weighted alpha complex simplices in the filtration order, with [filtration value]:" << std::endl;
+  for (auto f_simplex : zw_simplex.filtration_simplex_range()) {
+    std::clog << "   ( ";
+    for (auto vertex : zw_simplex.simplex_vertex_range(f_simplex)) {
+      std::clog << vertex << " ";
+    }
+    std::clog << ") -> " << "[" << zw_simplex.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
+  }
+
+  BOOST_CHECK(zw_simplex == simplex);
+}
\ No newline at end of file
-- 
cgit v1.2.3


From de39546182c20a69e45aa07830351f6e9d2e4b84 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Mon, 14 Sep 2020 17:27:40 +0200
Subject: Add but comment a test to compare dD and 3D alpha complex

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h    |  2 -
 .../test/Weighted_alpha_complex_unit_test.cpp      | 79 +++++++++++++++++++++-
 2 files changed, 78 insertions(+), 3 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index 00231e1c..e1aae2d4 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -267,8 +267,6 @@ class Alpha_complex {
           // Save index value as data to retrieve it after insertion
           pos->data() = index;
           hint = pos->full_cell();
-        } else {
-          std::cout << "NULLPTR" << std::endl;
         }
       }
       // --------------------------------------------------------------------------------------------
diff --git a/src/Alpha_complex/test/Weighted_alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Weighted_alpha_complex_unit_test.cpp
index 57a57058..bf659ef7 100644
--- a/src/Alpha_complex/test/Weighted_alpha_complex_unit_test.cpp
+++ b/src/Alpha_complex/test/Weighted_alpha_complex_unit_test.cpp
@@ -79,4 +79,81 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Zero_weighted_alpha_complex, Kernel, list_of_kerne
   }
 
   BOOST_CHECK(zw_simplex == simplex);
-}
\ No newline at end of file
+}
+
+template <typename Point_d>
+bool cgal_3d_point_sort (Point_d a,Point_d b) {
+  if (a[0] != b[0])
+    return a[0] < b[0];
+  if (a[1] != b[1])
+    return a[1] < b[1];
+  return a[2] < b[2];
+}
+
+/*BOOST_AUTO_TEST_CASE(Weighted_alpha_complex_3d_comparison) {
+  // Random points construction
+  using Kernel_dD = CGAL::Epeck_d< CGAL::Dimension_tag<3> >;
+  using Bare_point_d = typename Kernel_dD::Point_d;
+  using Weighted_point_d = typename Kernel_dD::Weighted_point_d;
+  std::vector<Weighted_point_d> w_points_d;
+
+  using Exact_weighted_alpha_complex_3d =
+    Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::EXACT, true, false>;
+  using Bare_point_3 = typename Exact_weighted_alpha_complex_3d::Bare_point_3;
+  using Weighted_point_3 = typename Exact_weighted_alpha_complex_3d::Weighted_point_3;
+  std::vector<Weighted_point_3> w_points_3;
+
+  std::uniform_real_distribution<double> rd_pts(-10., 10.);
+  std::uniform_real_distribution<double> rd_wghts(-0.5, 0.5);
+  std::random_device rand_dev;
+  std::mt19937 rand_engine(rand_dev());
+  for (int idx = 0; idx < 20; idx++) {
+    std::vector<double> point {rd_pts(rand_engine), rd_pts(rand_engine), rd_pts(rand_engine)};
+    double weight = rd_wghts(rand_engine);
+    w_points_d.emplace_back(Weighted_point_d(Bare_point_d(point.begin(), point.end()), weight));
+    w_points_3.emplace_back(Weighted_point_3(Bare_point_3(point[0], point[1], point[2]), weight));
+  }
+
+  // Weighted alpha complex for dD version
+  Gudhi::alpha_complex::Alpha_complex<Kernel_dD, true> alpha_complex_dD_from_weighted_points(w_points_d);
+  Gudhi::Simplex_tree<> w_simplex_d;
+  BOOST_CHECK(alpha_complex_dD_from_weighted_points.create_complex(w_simplex_d));
+
+  std::clog << "Iterator on weighted alpha complex dD simplices in the filtration order, with [filtration value]:" << std::endl;
+  for (auto f_simplex : w_simplex_d.filtration_simplex_range()) {
+    std::clog << "   ( ";
+    std::vector<Bare_point_d> points;
+    for (auto vertex : w_simplex_d.simplex_vertex_range(f_simplex)) {
+      points.emplace_back(alpha_complex_dD_from_weighted_points.get_point(vertex).point());
+    }
+    std::sort (points.begin(), points.end(), cgal_3d_point_sort<Bare_point_d>);
+    for (auto point : points) {
+      std::clog << point[0] << " " << point[1] << " " << point[2] << " | ";
+    }
+    std::clog << ") -> " << "[" << w_simplex_d.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
+  }
+
+  // Weighted alpha complex for 3D version
+  Exact_weighted_alpha_complex_3d alpha_complex_3D_from_weighted_points(w_points_3);
+  Gudhi::Simplex_tree<> w_simplex_3;
+  BOOST_CHECK(alpha_complex_3D_from_weighted_points.create_complex(w_simplex_3));
+
+  std::clog << "Iterator on weighted alpha complex 3D simplices in the filtration order, with [filtration value]:" << std::endl;
+  for (auto f_simplex : w_simplex_3.filtration_simplex_range()) {
+    std::clog << "   ( ";
+    std::vector<Bare_point_3> points;
+    for (auto vertex : w_simplex_3.simplex_vertex_range(f_simplex)) {
+      points.emplace_back(alpha_complex_3D_from_weighted_points.get_point(vertex).point());
+    }
+    std::sort (points.begin(), points.end());
+    for (auto point : points) {
+      std::clog << point[0] << " " << point[1] << " " << point[2] << " | ";
+    }
+    std::clog << ") -> " << "[" << w_simplex_3.filtration(f_simplex) << "] ";
+    std::clog << std::endl;
+  }
+
+  BOOST_CHECK(w_simplex_d == w_simplex_3);
+
+}*/
\ No newline at end of file
-- 
cgit v1.2.3


From 53d09e2f7770f7e95d765d527712ef3c0758cf08 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Mon, 14 Sep 2020 21:35:23 +0200
Subject: Fix Alpha complex to have the same results than Alpha complex 3d

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 31 +++++++++++++++++++++++--
 1 file changed, 29 insertions(+), 2 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index e1aae2d4..f43cd071 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -60,6 +60,27 @@ namespace alpha_complex {
 template<typename D> struct Is_Epeck_D { static const bool value = false; };
 template<typename D> struct Is_Epeck_D<CGAL::Epeck_d<D>> { static const bool value = true; };
 
+template<class Kernel, bool Weighted>
+struct Weight;
+
+template<class Kernel>
+struct Weight<Kernel, true>
+{
+  typename Kernel::FT operator()(const typename Kernel::Weighted_point_d& p) const 
+  {
+    return p.weight();
+  }
+};
+
+template<class Kernel>
+struct Weight<Kernel, false>
+{
+  typename Kernel::FT operator()(const typename Kernel::Point_d& p) const 
+  {
+    return 0.;
+  }
+};
+
 /**
  * \class Alpha_complex Alpha_complex.h gudhi/Alpha_complex.h
  * \brief Alpha complex data structure.
@@ -404,6 +425,7 @@ class Alpha_complex {
     // --------------------------------------------------------------------------------------------
 
     if (!default_filtration_value) {
+      CGAL::NT_converter<FT, Filtration_value> cgal_converter;
       // --------------------------------------------------------------------------------------------
       // ### For i : d -> 0
       for (int decr_dim = triangulation_->maximal_dimension(); decr_dim >= 0; decr_dim--) {
@@ -420,8 +442,7 @@ class Alpha_complex {
 #if CGAL_VERSION_NR >= 1050000000
                 if(exact) CGAL::exact(sqrad);
 #endif
-                CGAL::NT_converter<FT, Filtration_value> cv;
-                alpha_complex_filtration = cv(sqrad);
+                alpha_complex_filtration = cgal_converter(sqrad);
               }
               complex.assign_filtration(f_simplex, alpha_complex_filtration);
 #ifdef DEBUG_TRACES
@@ -431,6 +452,12 @@ class Alpha_complex {
             // No need to propagate further, unweighted points all have value 0
             if (decr_dim > 1)
               propagate_alpha_filtration(complex, f_simplex);
+            // For weighted points, assign point weight as filtration value
+            if (Weighted && decr_dim == 0) {
+              Vertex_handle vertex = *(complex.simplex_vertex_range(f_simplex).begin());
+              FT wght = Weight<Kernel, Weighted>()(get_point(vertex));
+              complex.assign_filtration(f_simplex, cgal_converter(wght)*(-1.));
+            }
           }
         }
         old_cache_ = std::move(cache_);
-- 
cgit v1.2.3


From 6db3b5db0f8b6dfae2b9b6eadb8bccdfdc613fb5 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Tue, 15 Sep 2020 13:45:37 +0200
Subject: This should be correct and efficient for 0-dimension weighted alpha

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index f43cd071..b66ec20d 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -436,8 +436,8 @@ class Alpha_complex {
             // ### If filt(Sigma) is NaN : filt(Sigma) = alpha(Sigma)
             if (std::isnan(complex.filtration(f_simplex))) {
               Filtration_value alpha_complex_filtration = 0.0;
-              // No need to compute squared_radius on a single point - alpha is 0.0
-              if (f_simplex_dim > 0) {
+              // No need to compute squared_radius on a non-weighted single point - alpha is 0.0
+              if (Weighted || f_simplex_dim > 0) {
                 auto const& sqrad = radius(complex, f_simplex);
 #if CGAL_VERSION_NR >= 1050000000
                 if(exact) CGAL::exact(sqrad);
@@ -450,14 +450,8 @@ class Alpha_complex {
 #endif  // DEBUG_TRACES
             }
             // No need to propagate further, unweighted points all have value 0
-            if (decr_dim > 1)
+            if (decr_dim > !Weighted)
               propagate_alpha_filtration(complex, f_simplex);
-            // For weighted points, assign point weight as filtration value
-            if (Weighted && decr_dim == 0) {
-              Vertex_handle vertex = *(complex.simplex_vertex_range(f_simplex).begin());
-              FT wght = Weight<Kernel, Weighted>()(get_point(vertex));
-              complex.assign_filtration(f_simplex, cgal_converter(wght)*(-1.));
-            }
           }
         }
         old_cache_ = std::move(cache_);
-- 
cgit v1.2.3


From 837ffddda60d3f389184fe167710f74ad8adf36b Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Thu, 17 Sep 2020 09:37:25 +0200
Subject: Some documentation for weighted version

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h                | 7 ++++---
 src/Alpha_complex/include/gudhi/Alpha_complex/Alpha_kernel_d.h | 8 ++++++++
 2 files changed, 12 insertions(+), 3 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index b66ec20d..1d395bd8 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -132,17 +132,18 @@ class Alpha_complex {
   using Triangulation = typename std::conditional<Weighted, CGAL::Regular_triangulation<Kernel, TDS>,
                                                             CGAL::Delaunay_triangulation<Kernel, TDS>>::type;
 
+  /** \brief CGAL kernel container for computations in function of the weighted or not characteristics.*/
   using A_kernel_d = Alpha_kernel_d<Kernel, Weighted>;
 
   // Numeric type of coordinates in the kernel
   using FT = typename A_kernel_d::FT;
 
-  /** \brief If Weighted, the weighted point is cached (point + weight [= squared radius]),
-   * else a pair of point and squared radius is cached.
+  /** \brief Sphere is a std::pair<Kernel::Point_d, Kernel::FT> (aka. circurmcenter and squared radius).
+   * If Weighted, Sphere is a Kernel::Weighted_point_d (aka. circurmcenter and the weight value is the squared radius).
   */
   using Sphere = typename A_kernel_d::Sphere;
 
-  /** \brief A point in Euclidean space.*/
+  /** \brief A point, or a weighted point in Euclidean space.*/
   using Point_d = typename std::conditional<Weighted, typename A_kernel_d::Weighted_point_d,
                                                       typename A_kernel_d::Point_d>::type;
 
diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex/Alpha_kernel_d.h b/src/Alpha_complex/include/gudhi/Alpha_complex/Alpha_kernel_d.h
index a4824207..e3567a6d 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex/Alpha_kernel_d.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex/Alpha_kernel_d.h
@@ -32,6 +32,14 @@ namespace Gudhi {
 
 namespace alpha_complex {
 
+/**
+ * \class Alpha_kernel_d
+ * \brief Alpha complex kernel container.
+ * 
+ * \details
+ * The Alpha complex kernel container stores CGAL Kernel and dispatch basics computations in function of the weighted
+ * or not version of the Alpha complex.
+ */
 template < typename Kernel, bool Weighted = false >
 class Alpha_kernel_d {
 };
-- 
cgit v1.2.3


From 77c0275031f47bb94f94d02d63182178e46f6570 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Thu, 17 Sep 2020 10:24:30 +0200
Subject: Remove useless code

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 21 ---------------------
 1 file changed, 21 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index 1d395bd8..be0a5b95 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -60,27 +60,6 @@ namespace alpha_complex {
 template<typename D> struct Is_Epeck_D { static const bool value = false; };
 template<typename D> struct Is_Epeck_D<CGAL::Epeck_d<D>> { static const bool value = true; };
 
-template<class Kernel, bool Weighted>
-struct Weight;
-
-template<class Kernel>
-struct Weight<Kernel, true>
-{
-  typename Kernel::FT operator()(const typename Kernel::Weighted_point_d& p) const 
-  {
-    return p.weight();
-  }
-};
-
-template<class Kernel>
-struct Weight<Kernel, false>
-{
-  typename Kernel::FT operator()(const typename Kernel::Point_d& p) const 
-  {
-    return 0.;
-  }
-};
-
 /**
  * \class Alpha_complex Alpha_complex.h gudhi/Alpha_complex.h
  * \brief Alpha complex data structure.
-- 
cgit v1.2.3


From b08a52c3b625e70d1c69834df7253e115da7946e Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Tue, 29 Sep 2020 15:35:11 +0200
Subject: code review: use of std::conditional_t c++14 helper

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index be0a5b95..e8bf1f74 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -101,15 +101,16 @@ template<class Kernel = CGAL::Epeck_d<CGAL::Dynamic_dimension_tag>, bool Weighte
 class Alpha_complex {
  public:
   /** \brief Geometric traits class that provides the geometric types and predicates needed by the triangulations.*/
-  using Geom_traits = typename std::conditional<Weighted, CGAL::Regular_triangulation_traits_adapter<Kernel>,
-                                                          Kernel>::type;
+  using Geom_traits = std::conditional_t<Weighted, CGAL::Regular_triangulation_traits_adapter<Kernel>, Kernel>;
+
   // Add an int in TDS to save point index in the structure
   using TDS = CGAL::Triangulation_data_structure<typename Geom_traits::Dimension,
                                                  CGAL::Triangulation_vertex<Geom_traits, std::ptrdiff_t>,
                                                  CGAL::Triangulation_full_cell<Geom_traits> >;
+
   /** \brief A (Weighted or not) Delaunay triangulation of a set of points in \f$ \mathbb{R}^D\f$.*/
-  using Triangulation = typename std::conditional<Weighted, CGAL::Regular_triangulation<Kernel, TDS>,
-                                                            CGAL::Delaunay_triangulation<Kernel, TDS>>::type;
+  using Triangulation = std::conditional_t<Weighted, CGAL::Regular_triangulation<Kernel, TDS>,
+                                                     CGAL::Delaunay_triangulation<Kernel, TDS>>;
 
   /** \brief CGAL kernel container for computations in function of the weighted or not characteristics.*/
   using A_kernel_d = Alpha_kernel_d<Kernel, Weighted>;
@@ -123,8 +124,7 @@ class Alpha_complex {
   using Sphere = typename A_kernel_d::Sphere;
 
   /** \brief A point, or a weighted point in Euclidean space.*/
-  using Point_d = typename std::conditional<Weighted, typename A_kernel_d::Weighted_point_d,
-                                                      typename A_kernel_d::Point_d>::type;
+  using Point_d = std::conditional_t<Weighted, typename A_kernel_d::Weighted_point_d, typename A_kernel_d::Point_d>;
 
  private:
   // Vertex_iterator type from CGAL.
-- 
cgit v1.2.3


From 44473bcd93892c7034fa21599509d4271f2d8bb2 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Tue, 29 Sep 2020 17:16:02 +0200
Subject: doc review: rephrase non contiguous vertices

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index e8bf1f74..38201027 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -171,7 +171,8 @@ class Alpha_complex {
 
   /** \brief Alpha_complex constructor from a list of points.
    *
-   * Duplicate points are inserted once in the Alpha_complex. This is the reason why the vertices may be not contiguous.
+   * The vertices may be not contiguous as some points may be discarded in the triangulation (duplicate points,
+   * weighted hidden point, ...).
    * 
    * @param[in] points Range of points to triangulate. Points must be in Kernel::Point_d or Kernel::Weighted_point_d.
    * 
@@ -186,7 +187,8 @@ class Alpha_complex {
 
   /** \brief Alpha_complex constructor from a list of points and weights.
    *
-   * Duplicate points are inserted once in the Alpha_complex. This is the reason why the vertices may be not contiguous.
+   * The vertices may be not contiguous as some points may be discarded in the triangulation (duplicate points,
+   * weighted hidden point, ...).
    * 
    * @param[in] points Range of points to triangulate. Points must be in Kernel::Point_d or Kernel::Weighted_point_d.
    * 
-- 
cgit v1.2.3


From dab93ead76f1435f6b74937ef0377aafb0517439 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Tue, 29 Sep 2020 17:53:34 +0200
Subject: doc review: Modify ctor with points and weights documentation

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index 38201027..a692dbc6 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -176,8 +176,8 @@ class Alpha_complex {
    * 
    * @param[in] points Range of points to triangulate. Points must be in Kernel::Point_d or Kernel::Weighted_point_d.
    * 
-   * The type InputPointRange must be a range for which std::begin and
-   * std::end return input iterators on a Kernel::Point_d or Kernel::Weighted_point_d.
+   * The type InputPointRange must be a range for which std::begin and std::end return input iterators on a
+   * Kernel::Point_d or Kernel::Weighted_point_d.
    */
   template<typename InputPointRange >
   Alpha_complex(const InputPointRange& points)
@@ -190,12 +190,12 @@ class Alpha_complex {
    * The vertices may be not contiguous as some points may be discarded in the triangulation (duplicate points,
    * weighted hidden point, ...).
    * 
-   * @param[in] points Range of points to triangulate. Points must be in Kernel::Point_d or Kernel::Weighted_point_d.
+   * @param[in] points Range of points to triangulate. Points must be in Kernel::Point_d.
    * 
    * @param[in] weights Range of points weights. Weights must be in Kernel::FT.
    * 
-   * The type InputPointRange must be a range for which std::begin and
-   * std::end return input iterators on a Kernel::Point_d.
+   * The type InputPointRange must be a range for which std::begin and std::end return input iterators on a
+   * Kernel::Point_d.
    */
   template <typename InputPointRange, typename WeightRange>
   Alpha_complex(const InputPointRange& points, WeightRange weights) {
-- 
cgit v1.2.3


From c1b317640f81fefff7f7a774b239957fb632fa43 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Wed, 30 Sep 2020 09:18:36 +0200
Subject: code review: emplace_back versus push_back

---
 .../Weighted_alpha_complex_3d_from_points.cpp        | 10 +++++-----
 .../example/Weighted_alpha_complex_from_points.cpp   | 10 +++++-----
 src/Alpha_complex/include/gudhi/Alpha_complex.h      |  6 +++---
 src/Alpha_complex/test/Alpha_kernel_d_unit_test.cpp  | 20 ++++++++++----------
 .../utilities/alpha_complex_persistence.cpp          |  2 +-
 5 files changed, 24 insertions(+), 24 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/example/Weighted_alpha_complex_3d_from_points.cpp b/src/Alpha_complex/example/Weighted_alpha_complex_3d_from_points.cpp
index a8d00272..09431d6e 100644
--- a/src/Alpha_complex/example/Weighted_alpha_complex_3d_from_points.cpp
+++ b/src/Alpha_complex/example/Weighted_alpha_complex_3d_from_points.cpp
@@ -18,11 +18,11 @@ int main(int argc, char **argv) {
   // Init of a list of points and weights from a small molecule
   // ----------------------------------------------------------------------------
   std::vector<Weighted_point> weighted_points;
-  weighted_points.push_back(Weighted_point(Bare_point(1, -1, -1), 4.));
-  weighted_points.push_back(Weighted_point(Bare_point(-1, 1, -1), 4.));
-  weighted_points.push_back(Weighted_point(Bare_point(-1, -1, 1), 4.));
-  weighted_points.push_back(Weighted_point(Bare_point(1, 1, 1), 4.));
-  weighted_points.push_back(Weighted_point(Bare_point(2, 2, 2), 1.));
+  weighted_points.emplace_back(Bare_point(1, -1, -1), 4.);
+  weighted_points.emplace_back(Bare_point(-1, 1, -1), 4.);
+  weighted_points.emplace_back(Bare_point(-1, -1, 1), 4.);
+  weighted_points.emplace_back(Bare_point(1, 1, 1),   4.);
+  weighted_points.emplace_back(Bare_point(2, 2, 2),   1.);
 
   // ----------------------------------------------------------------------------
   // Init of an alpha complex from the list of points
diff --git a/src/Alpha_complex/example/Weighted_alpha_complex_from_points.cpp b/src/Alpha_complex/example/Weighted_alpha_complex_from_points.cpp
index d49d3e93..d1f3e436 100644
--- a/src/Alpha_complex/example/Weighted_alpha_complex_from_points.cpp
+++ b/src/Alpha_complex/example/Weighted_alpha_complex_from_points.cpp
@@ -18,11 +18,11 @@ int main() {
   // Init of a list of points and weights from a small molecule
   // ----------------------------------------------------------------------------
   Vector_of_points points;
-  points.push_back(Weighted_point(Bare_point(1, -1, -1), 4.));
-  points.push_back(Weighted_point(Bare_point(-1, 1, -1), 4.));
-  points.push_back(Weighted_point(Bare_point(-1, -1, 1), 4.));
-  points.push_back(Weighted_point(Bare_point(1, 1, 1),   4.));
-  points.push_back(Weighted_point(Bare_point(2, 2, 2),   1.));
+  points.emplace_back(Bare_point(1, -1, -1), 4.);
+  points.emplace_back(Bare_point(-1, 1, -1), 4.);
+  points.emplace_back(Bare_point(-1, -1, 1), 4.);
+  points.emplace_back(Bare_point(1, 1, 1),   4.);
+  points.emplace_back(Bare_point(2, 2, 2),   1.);
 
   // ----------------------------------------------------------------------------
   // Init of an alpha complex from the list of points
diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index a692dbc6..4f8e3d54 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -310,7 +310,7 @@ class Alpha_complex {
       thread_local std::vector<Point_d> v;
       v.clear();
       for (auto vertex : cplx.simplex_vertex_range(s))
-        v.push_back(get_point_(vertex));
+        v.emplace_back(get_point_(vertex));
       cache_.emplace_back(kernel_.get_sphere(v.cbegin(), v.cend()));
     }
     return cache_[k];
@@ -326,7 +326,7 @@ class Alpha_complex {
     thread_local std::vector<Point_d> v;
     v.clear();
     for (auto vertex : cplx.simplex_vertex_range(s))
-      v.push_back(get_point_(vertex));
+      v.emplace_back(get_point_(vertex));
     return kernel_.get_squared_radius(v.cbegin(), v.cend());
   }
 
@@ -394,7 +394,7 @@ class Alpha_complex {
             std::clog << " " << (*vit)->data();
 #endif  // DEBUG_TRACES
             // Vector of vertex construction for simplex_tree structure
-            vertexVector.push_back((*vit)->data());
+            vertexVector.emplace_back((*vit)->data());
           }
         }
 #ifdef DEBUG_TRACES
diff --git a/src/Alpha_complex/test/Alpha_kernel_d_unit_test.cpp b/src/Alpha_complex/test/Alpha_kernel_d_unit_test.cpp
index 192834b3..6eae103d 100644
--- a/src/Alpha_complex/test/Alpha_kernel_d_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_kernel_d_unit_test.cpp
@@ -63,11 +63,11 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_kernel_d_sphere, TestedKernel, list_of_kerne
 
   using Point_d = typename Unweighted_kernel::Point_d;
   std::vector<Point_d> unw_pts;
-  unw_pts.push_back(Point_d(p0.begin(), p0.end()));
-  unw_pts.push_back(Point_d(p1.begin(), p1.end()));
-  unw_pts.push_back(Point_d(p2.begin(), p2.end()));
-  unw_pts.push_back(Point_d(p3.begin(), p3.end()));
-  unw_pts.push_back(Point_d(p4.begin(), p4.end()));
+  unw_pts.emplace_back(p0.begin(), p0.end());
+  unw_pts.emplace_back(p1.begin(), p1.end());
+  unw_pts.emplace_back(p2.begin(), p2.end());
+  unw_pts.emplace_back(p3.begin(), p3.end());
+  unw_pts.emplace_back(p4.begin(), p4.end());
 
   Unweighted_kernel kernel;
   auto unw_sphere = kernel.get_sphere(unw_pts.cbegin(), unw_pts.cend());
@@ -79,11 +79,11 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_kernel_d_sphere, TestedKernel, list_of_kerne
   using Weighted_point_d = typename Weighted_kernel::Weighted_point_d;
   using Bare_point_d = typename Weighted_kernel::Bare_point_d;
   std::vector<Weighted_point_d> w_pts;
-  w_pts.push_back(Weighted_point_d(Bare_point_d(p0.begin(), p0.end()), 0.));
-  w_pts.push_back(Weighted_point_d(Bare_point_d(p1.begin(), p1.end()), 0.));
-  w_pts.push_back(Weighted_point_d(Bare_point_d(p2.begin(), p2.end()), 0.));
-  w_pts.push_back(Weighted_point_d(Bare_point_d(p3.begin(), p3.end()), 0.));
-  w_pts.push_back(Weighted_point_d(Bare_point_d(p4.begin(), p4.end()), 0.));
+  w_pts.emplace_back(Bare_point_d(p0.begin(), p0.end()), 0.);
+  w_pts.emplace_back(Bare_point_d(p1.begin(), p1.end()), 0.);
+  w_pts.emplace_back(Bare_point_d(p2.begin(), p2.end()), 0.);
+  w_pts.emplace_back(Bare_point_d(p3.begin(), p3.end()), 0.);
+  w_pts.emplace_back(Bare_point_d(p4.begin(), p4.end()), 0.);
 
   Weighted_kernel w_kernel;
   auto w_sphere = w_kernel.get_sphere(w_pts.cbegin(), w_pts.cend());
diff --git a/src/Alpha_complex/utilities/alpha_complex_persistence.cpp b/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
index e86b34e2..3ce7b440 100644
--- a/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
+++ b/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
@@ -50,7 +50,7 @@ std::vector<double> read_weight_file(const std::string &weight_file) {
     double weight = 0.0;
     // Attempt read the weight in a double format, return false if it fails
     while (weights_ifstr >> weight) {
-      weights.push_back(weight);
+      weights.emplace_back(weight);
     }
   } else {
     std::cerr << "Unable to read weights file " << weight_file << std::endl;
-- 
cgit v1.2.3


From 74143b372d3d93fc2139974fa85906047acee8a7 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Mon, 5 Oct 2020 10:33:23 +0200
Subject: code review: push_back versus emplace_back

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h           | 6 +++---
 src/Alpha_complex/utilities/alpha_complex_persistence.cpp | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index 4f8e3d54..a692dbc6 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -310,7 +310,7 @@ class Alpha_complex {
       thread_local std::vector<Point_d> v;
       v.clear();
       for (auto vertex : cplx.simplex_vertex_range(s))
-        v.emplace_back(get_point_(vertex));
+        v.push_back(get_point_(vertex));
       cache_.emplace_back(kernel_.get_sphere(v.cbegin(), v.cend()));
     }
     return cache_[k];
@@ -326,7 +326,7 @@ class Alpha_complex {
     thread_local std::vector<Point_d> v;
     v.clear();
     for (auto vertex : cplx.simplex_vertex_range(s))
-      v.emplace_back(get_point_(vertex));
+      v.push_back(get_point_(vertex));
     return kernel_.get_squared_radius(v.cbegin(), v.cend());
   }
 
@@ -394,7 +394,7 @@ class Alpha_complex {
             std::clog << " " << (*vit)->data();
 #endif  // DEBUG_TRACES
             // Vector of vertex construction for simplex_tree structure
-            vertexVector.emplace_back((*vit)->data());
+            vertexVector.push_back((*vit)->data());
           }
         }
 #ifdef DEBUG_TRACES
diff --git a/src/Alpha_complex/utilities/alpha_complex_persistence.cpp b/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
index 3ce7b440..e86b34e2 100644
--- a/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
+++ b/src/Alpha_complex/utilities/alpha_complex_persistence.cpp
@@ -50,7 +50,7 @@ std::vector<double> read_weight_file(const std::string &weight_file) {
     double weight = 0.0;
     // Attempt read the weight in a double format, return false if it fails
     while (weights_ifstr >> weight) {
-      weights.emplace_back(weight);
+      weights.push_back(weight);
     }
   } else {
     std::cerr << "Unable to read weights file " << weight_file << std::endl;
-- 
cgit v1.2.3


From 9bba01c0afb2c931553d2c47af0104f407d22c01 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Mon, 5 Oct 2020 13:18:59 +0200
Subject: code review: typename is useless here

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index a692dbc6..ae04e6e8 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -134,7 +134,7 @@ class Alpha_complex {
   using size_type = typename Triangulation::size_type;
 
   // Structure to switch from simplex tree vertex handle to CGAL vertex iterator.
-  using Vector_vertex_iterator = typename std::vector< CGAL_vertex_iterator >;
+  using Vector_vertex_iterator = std::vector< CGAL_vertex_iterator >;
 
  private:
   /** \brief Vertex iterator vector to switch from simplex tree vertex handle to CGAL vertex iterator.
-- 
cgit v1.2.3


From 298925b9c2dc3629f2d20ad9b85f5a410dee6fab Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Mon, 5 Oct 2020 15:29:25 +0200
Subject: code review: use geom_trait for Point_d type

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index ae04e6e8..1963f02b 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -124,7 +124,7 @@ class Alpha_complex {
   using Sphere = typename A_kernel_d::Sphere;
 
   /** \brief A point, or a weighted point in Euclidean space.*/
-  using Point_d = std::conditional_t<Weighted, typename A_kernel_d::Weighted_point_d, typename A_kernel_d::Point_d>;
+  using Point_d = typename Geom_traits::Point_d;
 
  private:
   // Vertex_iterator type from CGAL.
-- 
cgit v1.2.3


From 30efe05d095051e14cbaf26d12fc2a67134e5a60 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Thu, 15 Oct 2020 16:43:54 +0200
Subject: Use unique_ptr for triangulation_

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index 1963f02b..4f7a7bd2 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -19,6 +19,7 @@
 
 #include <stdlib.h>
 #include <math.h>  // isnan, fmax
+#include <memory>  // for std::unique_ptr
 
 #include <CGAL/Delaunay_triangulation.h>
 #include <CGAL/Regular_triangulation.h>  // aka. Weighted Delaunay triangulation
@@ -141,7 +142,7 @@ class Alpha_complex {
    * Vertex handles are inserted sequentially, starting at 0.*/
   Vector_vertex_iterator vertex_handle_to_iterator_;
   /** \brief Pointer on the CGAL Delaunay triangulation.*/
-  Triangulation* triangulation_;
+  std::unique_ptr<Triangulation> triangulation_;
   /** \brief Kernel for triangulation_ functions access.*/
   A_kernel_d kernel_;
 
@@ -158,8 +159,7 @@ class Alpha_complex {
    *
    * @param[in] off_file_name OFF file [path and] name.
    */
-  Alpha_complex(const std::string& off_file_name)
-      : triangulation_(nullptr) {
+  Alpha_complex(const std::string& off_file_name) {
     Gudhi::Points_off_reader<Point_d> off_reader(off_file_name);
     if (!off_reader.is_valid()) {
       std::cerr << "Alpha_complex - Unable to read file " << off_file_name << "\n";
@@ -180,8 +180,7 @@ class Alpha_complex {
    * Kernel::Point_d or Kernel::Weighted_point_d.
    */
   template<typename InputPointRange >
-  Alpha_complex(const InputPointRange& points)
-      : triangulation_(nullptr) {
+  Alpha_complex(const InputPointRange& points) {
     init_from_range(points);
   }
 
@@ -208,12 +207,6 @@ class Alpha_complex {
     init_from_range(weighted_points);
   }
 
-  /** \brief Alpha_complex destructor deletes the Delaunay triangulation.
-   */
-  ~Alpha_complex() {
-    delete triangulation_;
-  }
-
   // Forbid copy/move constructor/assignment operator
   Alpha_complex(const Alpha_complex& other) = delete;
   Alpha_complex& operator= (const Alpha_complex& other) = delete;
@@ -249,7 +242,7 @@ class Alpha_complex {
 
     if (first != last) {
       // Delaunay triangulation init with point dimension.
-      triangulation_ = new Triangulation(kernel_.get_dimension(*first));
+      triangulation_ = std::make_unique<Triangulation>(kernel_.get_dimension(*first));
 
       std::vector<Point_d> point_cloud(first, last);
 
-- 
cgit v1.2.3


From 699a89819da922222cedcd81b4a1553ee161a633 Mon Sep 17 00:00:00 2001
From: ROUVREAU Vincent <vincent.rouvreau@inria.fr>
Date: Mon, 26 Oct 2020 10:58:19 +0100
Subject: code review: bad copy/paste that needs rephrase

---
 src/Alpha_complex/include/gudhi/Alpha_complex.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/Alpha_complex/include/gudhi/Alpha_complex.h')

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index 4f7a7bd2..b315fa99 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -198,7 +198,7 @@ class Alpha_complex {
    */
   template <typename InputPointRange, typename WeightRange>
   Alpha_complex(const InputPointRange& points, WeightRange weights) {
-    static_assert(Weighted, "This constructor is not available for non-weighted versions of Alpha_complex_3d");
+    static_assert(Weighted, "This constructor is not available for non-weighted versions of Alpha_complex");
     // FIXME: this test is only valid if we have a forward range
     GUDHI_CHECK(boost::size(weights) == boost::size(points),
                 std::invalid_argument("Points number in range different from weights range number"));
-- 
cgit v1.2.3