Code review: Remove empty_point_set_ that can be deduced from num_vertices (new method in Alpha_complex -> Abstract_alpha_complex -> In/Exact_alpha_complex_dD -> Alpha_complex_interface

4 files changed, 38 insertions, 5 deletions

diff --git a/src/Alpha_complex/include/gudhi/Alpha_complex.h b/src/Alpha_complex/include/gudhi/Alpha_complex.h
index e03bb161..028ec9bb 100644
--- a/src/Alpha_complex/include/gudhi/Alpha_complex.h
+++ b/src/Alpha_complex/include/gudhi/Alpha_complex.h
@@ -20,6 +20,7 @@
 #include <stdlib.h>
 #include <math.h>  // isnan, fmax
 #include <memory>  // for std::unique_ptr
+#include <cstddef>  // for std::size_t
 
 #include <CGAL/Delaunay_triangulation.h>
 #include <CGAL/Regular_triangulation.h>  // aka. Weighted Delaunay triangulation
@@ -213,6 +214,15 @@ class Alpha_complex {
   Alpha_complex (Alpha_complex&& other) = delete;
   Alpha_complex& operator= (Alpha_complex&& other) = delete;
 
+  /** \brief Returns the number of finite vertices in the triangulation.
+   */
+  std::size_t num_vertices() const {
+    if (triangulation_ == nullptr)
+      return 0;
+    else
+      return triangulation_->number_of_vertices();
+  }
+
   /** \brief get_point returns the point corresponding to the vertex given as parameter.
    *
    * @param[in] vertex Vertex handle of the point to retrieve.
@@ -373,7 +383,7 @@ class Alpha_complex {
 
     // --------------------------------------------------------------------------------------------
     // Simplex_tree construction from loop on triangulation finite full cells list
-    if (triangulation_->number_of_vertices() > 0) {
+    if (num_vertices() > 0) {
       for (auto cit = triangulation_->finite_full_cells_begin();
            cit != triangulation_->finite_full_cells_end();
            ++cit) {
diff --git a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
index 4b37e4bd..f74ad217 100644
--- a/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
+++ b/src/Alpha_complex/test/Alpha_complex_unit_test.cpp
@@ -56,6 +56,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of
   Gudhi::Simplex_tree<> simplex_tree_60;
   BOOST_CHECK(alpha_complex_from_file.create_complex(simplex_tree_60, max_alpha_square_value));
 
+  std::clog << "alpha_complex_from_file.num_vertices()=" << alpha_complex_from_file.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_file.num_vertices() == 7);
+
   std::clog << "simplex_tree_60.dimension()=" << simplex_tree_60.dimension() << std::endl;
   BOOST_CHECK(simplex_tree_60.dimension() == 2);
 
@@ -72,6 +75,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_OFF_file, TestedKernel, list_of
   Gudhi::Simplex_tree<> simplex_tree_59;
   BOOST_CHECK(alpha_complex_from_file.create_complex(simplex_tree_59, max_alpha_square_value));
   
+  std::clog << "alpha_complex_from_file.num_vertices()=" << alpha_complex_from_file.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_file.num_vertices() == 7);
+
   std::clog << "simplex_tree_59.dimension()=" << simplex_tree_59.dimension() << std::endl;
   BOOST_CHECK(simplex_tree_59.dimension() == 2);
 
@@ -120,6 +126,9 @@ BOOST_AUTO_TEST_CASE(Alpha_complex_from_points) {
   Gudhi::Simplex_tree<> simplex_tree;
   BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree));
   
+  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_points.num_vertices() == points.size());
+
   // Another way to check num_simplices
   std::clog << "Iterator on alpha complex simplices in the filtration order, with [filtration value]:" << std::endl;
   int num_simplices = 0;
@@ -240,6 +249,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_from_empty_points, TestedKernel, lis
   // ----------------------------------------------------------------------------
   Gudhi::alpha_complex::Alpha_complex<TestedKernel> alpha_complex_from_points(points);
 
+  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_points.num_vertices() == points.size());
+
   // Test to the limit
   BOOST_CHECK_THROW (alpha_complex_from_points.get_point(0), std::out_of_range);
 
@@ -291,6 +303,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(Alpha_complex_with_duplicated_points, TestedKernel
   std::clog << "create_complex" << std::endl;
   BOOST_CHECK(alpha_complex_from_points.create_complex(simplex_tree));
   
+  std::clog << "alpha_complex_from_points.num_vertices()=" << alpha_complex_from_points.num_vertices() << std::endl;
+  BOOST_CHECK(alpha_complex_from_points.num_vertices() < points.size());
+
   std::clog << "simplex_tree.num_vertices()=" << simplex_tree.num_vertices()
       << std::endl;
   BOOST_CHECK(simplex_tree.num_vertices() < points.size());
diff --git a/src/python/include/Alpha_complex_factory.h b/src/python/include/Alpha_complex_factory.h
index 14ec1f86..3d20aa8f 100644
--- a/src/python/include/Alpha_complex_factory.h
+++ b/src/python/include/Alpha_complex_factory.h
@@ -70,6 +70,8 @@ class Abstract_alpha_complex {
 
   virtual bool create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square,
                                    bool default_filtration_value) = 0;
+  
+  virtual std::size_t num_vertices() const = 0;
 
   virtual ~Abstract_alpha_complex() = default;
 };
@@ -104,6 +106,10 @@ class Exact_alpha_complex_dD final : public Abstract_alpha_complex {
     return alpha_complex_.create_complex(*simplex_tree, max_alpha_square, exact_version_, default_filtration_value);
   }
 
+  virtual std::size_t num_vertices() const {
+    return alpha_complex_.num_vertices();
+  }
+
  private:
   bool exact_version_;
   Alpha_complex<Kernel, Weighted> alpha_complex_;
@@ -135,6 +141,10 @@ class Inexact_alpha_complex_dD final : public Abstract_alpha_complex {
     return alpha_complex_.create_complex(*simplex_tree, max_alpha_square, false, default_filtration_value);
   }
 
+  virtual std::size_t num_vertices() const {
+    return alpha_complex_.num_vertices();
+  }
+
  private:
   Alpha_complex<Kernel, Weighted> alpha_complex_;
 };
diff --git a/src/python/include/Alpha_complex_interface.h b/src/python/include/Alpha_complex_interface.h
index 188036ed..671af4a4 100644
--- a/src/python/include/Alpha_complex_interface.h
+++ b/src/python/include/Alpha_complex_interface.h
@@ -29,8 +29,7 @@ class Alpha_complex_interface {
  public:
   Alpha_complex_interface(const std::vector<std::vector<double>>& points,
                           const std::vector<double>& weights,
-                          bool fast_version, bool exact_version)
-  : empty_point_set_(points.size() == 0) {
+                          bool fast_version, bool exact_version) {
     const bool weighted = (weights.size() > 0);
     if (fast_version) {
       if (weighted) {
@@ -54,13 +53,12 @@ class Alpha_complex_interface {
   void create_simplex_tree(Simplex_tree_interface<>* simplex_tree, double max_alpha_square,
                            bool default_filtration_value) {
     // Nothing to be done in case of an empty point set
-    if (!empty_point_set_)
+    if (alpha_ptr_->num_vertices() > 0)
       alpha_ptr_->create_simplex_tree(simplex_tree, max_alpha_square, default_filtration_value);
   }
 
  private:
   std::unique_ptr<Abstract_alpha_complex> alpha_ptr_;
-  bool empty_point_set_;
 };
 
 }  // namespace alpha_complex