Do some code clean up/renaming

4 files changed, 89 insertions, 142 deletions

diff --git a/src/Cech_complex/include/gudhi/Cech_complex.h b/src/Cech_complex/include/gudhi/Cech_complex.h
index 0031d861..375be1d2 100644
--- a/src/Cech_complex/include/gudhi/Cech_complex.h
+++ b/src/Cech_complex/include/gudhi/Cech_complex.h
@@ -11,7 +11,7 @@
 #ifndef CECH_COMPLEX_H_
 #define CECH_COMPLEX_H_
 
-#include <gudhi/Cech_complex/Cech_kernel.h>  // for Gudhi::Minimal_enclosing_ball_radius
+#include <gudhi/sphere_circumradius.h>       // for Gudhi::cech_complex::Sphere_circumradius
 #include <gudhi/graph_simplicial_complex.h>  // for Gudhi::Proximity_graph
 #include <gudhi/Debug_utils.h>               // for GUDHI_CHECK
 #include <gudhi/Cech_complex_blocker.h>      // for Gudhi::cech_complex::Cech_blocker
@@ -31,23 +31,21 @@ namespace cech_complex {
  *
  * \details
  * The data structure is a proximity graph, containing edges when the edge length is less or equal
- * to a given max_radius. Edge length is computed from `Gudhi::Minimal_enclosing_ball_radius` distance function.
+ * to a given max_radius. Edge length is computed from `Gudhi::cech_complex::Sphere_circumradius` distance function.
  *
- * \tparam SimplicialComplexForProximityGraph furnishes `Vertex_handle` and `Filtration_value` type definition required
- * by `Gudhi::Proximity_graph`.
+ * \tparam Kernel CGAL kernel.
+ *
+ * \tparam SimplicialComplexForCechComplex furnishes `Vertex_handle` and `Filtration_value` type definition required
+ * by `Gudhi::Proximity_graph` and Cech blocker.
  *
- * \tparam ForwardPointRange must be a range for which `std::begin()` and `std::end()` methods return input
- * iterators on a point. `std::begin()` and `std::end()` methods are also required for a point.
  */
-template <typename SimplicialComplexForProximityGraph, typename ForwardPointRange, typename Kernel, typename SimplicialComplexForCechComplex>
+template <typename Kernel, typename SimplicialComplexForCechComplex>
 class Cech_complex {
  private:
   // Required by compute_proximity_graph
-  using Vertex_handle = typename SimplicialComplexForProximityGraph::Vertex_handle;
-  using Filtration_value = typename SimplicialComplexForProximityGraph::Filtration_value;
-  using Proximity_graph = Gudhi::Proximity_graph<SimplicialComplexForProximityGraph>;
-
- public:
+  using Vertex_handle = typename SimplicialComplexForCechComplex::Vertex_handle;
+  using Filtration_value = typename SimplicialComplexForCechComplex::Filtration_value;
+  using Proximity_graph = Gudhi::Proximity_graph<SimplicialComplexForCechComplex>;
 
   using cech_blocker = Cech_blocker<SimplicialComplexForCechComplex, Cech_complex, Kernel>;
 
@@ -57,27 +55,21 @@ class Cech_complex {
   // Numeric type of coordinates in the kernel
   using FT = typename cech_blocker::FT;
   // Sphere is a pair of point and squared radius.
-  using Sphere = typename std::pair<Point_d, FT>;
+  using Sphere = typename cech_blocker::Sphere;
 
- public:
+  public:
   /** \brief Cech_complex constructor from a list of points.
    *
-   * @param[in] points Range of points.
+   * @param[in] points Vector of points where each point is defined as `kernel::Point_d`.
    * @param[in] max_radius Maximal radius value.
    *
-   * \tparam ForwardPointRange must be a range of Point. Point must be a range of <b>copyable</b> Cartesian coordinates.
-   *
    */
-  Cech_complex(const ForwardPointRange& points, Filtration_value max_radius) : max_radius_(max_radius) {
-    // Point cloud deep copy
-
-//     point_cloud_.reserve(boost::size(points));
-//     for (auto&& point : points) point_cloud_.emplace_back(point.cartesian_begin(), point.cartesian_end());
+  Cech_complex(const Point_cloud & points, Filtration_value max_radius) : max_radius_(max_radius) {
 
     point_cloud_.assign(points.begin(), points.end());
 
-    cech_skeleton_graph_ = Gudhi::compute_proximity_graph<SimplicialComplexForProximityGraph>(
-        point_cloud_, max_radius_, Gudhi::Minimal_enclosing_ball_radius<Kernel>());
+    cech_skeleton_graph_ = Gudhi::compute_proximity_graph<SimplicialComplexForCechComplex>(
+        point_cloud_, max_radius_, Sphere_circumradius<Kernel>());
   }
 
   /** \brief Initializes the simplicial complex from the proximity graph and expands it until a given maximal
diff --git a/src/Cech_complex/include/gudhi/Cech_complex/Cech_kernel.h b/src/Cech_complex/include/gudhi/Cech_complex/Cech_kernel.h
deleted file mode 100644
index 89012206..00000000
--- a/src/Cech_complex/include/gudhi/Cech_complex/Cech_kernel.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*    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):       Hind Montassif
- *
- *    Copyright (C) 2021 Inria
- *
- *    Modification(s):
- *      - YYYY/MM Author: Description of the modification
- */
-
-#ifndef CECH_KERNEL_H_
-#define CECH_KERNEL_H_
-
-#include <CGAL/Epeck_d.h> // for #include <CGAL/NewKernel_d/KernelD_converter.h>
-
-#include <cmath>  // for std::sqrt
-#include <vector>
-
-namespace Gudhi {
-
-// namespace cech_complex {
-
-/** @brief Compute the radius of the minimal enclosing ball between Points given by a range of coordinates.
- * The points are assumed to have the same dimension. */
-template<typename Kernel>
-class Minimal_enclosing_ball_radius {
- private:
-    Kernel kernel_;
- public:
-    using Point = typename Kernel::Point_d;
-    using Point_cloud = typename std::vector<Point>;
-
-   /** \brief Enclosing ball radius from two points using CGAL.
-   *
-   * @param[in] point_1
-   * @param[in] point_2
-   * @return Enclosing ball radius for the two points.
-   * \tparam Point must be a Kernel::Point_d from CGAL.
-   *
-   */
-  double operator()(const Point& point_1, const Point& point_2) const {
-    return std::sqrt(CGAL::to_double(kernel_.squared_distance_d_object()(point_1, point_2))) / 2.;
-  }
-
-
-  /** \brief Enclosing ball radius from a point cloud using CGAL.
-   *
-   * @param[in] point_cloud The points.
-   * @return Enclosing ball radius for the points.
-   * \tparam Point_cloud must be a range of Kernel::Point_d points from CGAL.
-   *
-   */
-  double operator()(const Point_cloud& point_cloud) const {
-    return std::sqrt(CGAL::to_double(kernel_.compute_squared_radius_d_object()(point_cloud.begin(), point_cloud.end())));
-  }
-
-};
-
-/**
- * \class Cech_kernel
- * \brief Cech complex kernel container.
- * 
- * \details
- * The Cech complex kernel container stores CGAL Kernel and dispatch basic computations.
- */
-
-// template < typename Kernel >
-// class Cech_kernel<Kernel> {
-//  private:
-//   // Kernel for functions access.
-//   Kernel kernel_;
-//  public:
-//   using Point_d = typename Kernel::Point_d;
-//   // Numeric type of coordinates in the kernel
-//   using FT = typename Kernel::FT;
-//   // Sphere is a pair of point and squared radius.
-//   using Sphere = typename std::pair<Point_d, FT>;
-// 
-//   int get_dimension(const Point_d& p0) const {
-//     return kernel_.point_dimension_d_object()(p0);
-//   }
-// 
-//   template<class PointIterator>
-//   Sphere get_sphere(PointIterator begin, PointIterator end) const {
-//     Point_d c = kernel_.construct_circumcenter_d_object()(begin, end);
-//     FT r = kernel_.squared_distance_d_object()(c, *begin);
-//     return std::make_pair(std::move(c), std::move(r));
-//   }
-// 
-//   template<class PointIterator>
-//   FT get_squared_radius(PointIterator begin, PointIterator end) const {
-//     return kernel_.compute_squared_radius_d_object()(begin, end);
-//   }
-// 
-//   FT get_squared_radius(const Sphere& sph) const {
-//     return sph.second;
-//   }
-// };
-
-
-//}  // namespace cech_complex
-
-// namespace cechcomplex = cech_complex;
-
-}  // namespace Gudhi
-
-#endif  // CECH_KERNEL_H_
diff --git a/src/Cech_complex/include/gudhi/Cech_complex_blocker.h b/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
index f7f86534..1a696422 100644
--- a/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
+++ b/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
@@ -31,17 +31,15 @@ namespace cech_complex {
  * \details
  * Čech blocker is an oracle constructed from a Cech_complex and a simplicial complex.
  *
- * \tparam SimplicialComplexForProximityGraph furnishes `Simplex_handle` and `Filtration_value` type definition,
+ * \tparam SimplicialComplexForCech furnishes `Simplex_handle` and `Filtration_value` type definition,
  * `simplex_vertex_range(Simplex_handle sh)`and `assign_filtration(Simplex_handle sh, Filtration_value filt)` methods.
  *
- * \tparam Chech_complex is required by the blocker.
+ * \tparam Cech_complex is required by the blocker.
+ *
+ * \tparam Kernel CGAL kernel.
  */
 template <typename SimplicialComplexForCech, typename Cech_complex, typename Kernel>
 class Cech_blocker {
- private:
-
-  using Simplex_handle = typename SimplicialComplexForCech::Simplex_handle;
-  using Filtration_value = typename SimplicialComplexForCech::Filtration_value;
 
  public:
 
@@ -51,10 +49,10 @@ class Cech_blocker {
   // Sphere is a pair of point and squared radius.
   using Sphere = typename std::pair<Point_d, FT>;
 
-  template<class PointIterator>
-  FT get_squared_radius(PointIterator begin, PointIterator end) const {
-    return kernel_.compute_squared_radius_d_object()(begin, end);
-  }
+ private:
+
+  using Simplex_handle = typename SimplicialComplexForCech::Simplex_handle;
+  using Filtration_value = typename SimplicialComplexForCech::Filtration_value;
 
   template<class PointIterator>
   Sphere get_sphere(PointIterator begin, PointIterator end) const {
@@ -63,6 +61,7 @@ class Cech_blocker {
     return std::make_pair(std::move(c), std::move(r));
   }
 
+ public:
 
   /** \internal \brief Čech complex blocker operator() - the oracle - assigns the filtration value from the simplex
    * radius and returns if the simplex expansion must be blocked.
@@ -108,10 +107,11 @@ class Cech_blocker {
         if (kernel_.squared_distance_d_object()(sph.first, cc_ptr_->get_point(extra)) <= sph.second) {
             radius = std::sqrt(cast_to_double(sph.second));
             #ifdef DEBUG_TRACES
-                std::clog << "circumcenter: " << sph.first << ", radius: " <<  radius << std::endl;
+                std::clog << "center: " << sph.first << ", radius: " <<  radius << std::endl;
             #endif  // DEBUG_TRACES
             if (cast_to_double(sph.second) < cast_to_double(min_enclos_ball.second))
                 min_enclos_ball = sph;
+            break;
         }
     }
     // Get the minimal radius of all faces enclosing balls if exists
diff --git a/src/Cech_complex/include/gudhi/sphere_circumradius.h b/src/Cech_complex/include/gudhi/sphere_circumradius.h
new file mode 100644
index 00000000..a6dec3dc
--- /dev/null
+++ b/src/Cech_complex/include/gudhi/sphere_circumradius.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):       Hind Montassif
+ *
+ *    Copyright (C) 2021 Inria
+ *
+ *    Modification(s):
+ *      - YYYY/MM Author: Description of the modification
+ */
+
+#ifndef SPHERE_CIRCUMRADIUS_H_
+#define SPHERE_CIRCUMRADIUS_H_
+
+#include <CGAL/Epeck_d.h> // for #include <CGAL/NewKernel_d/KernelD_converter.h>
+
+#include <cmath>  // for std::sqrt
+#include <vector>
+
+namespace Gudhi {
+
+namespace cech_complex {
+
+/** @brief Compute the circumradius of the sphere passing through points given by a range of coordinates.
+ * The points are assumed to have the same dimension. */
+template<typename Kernel>
+class Sphere_circumradius {
+ private:
+    Kernel kernel_;
+ public:
+    using Point = typename Kernel::Point_d;
+    using Point_cloud = typename std::vector<Point>;
+
+   /** \brief Circumradius of sphere passing through two points using CGAL.
+   *
+   * @param[in] point_1
+   * @param[in] point_2
+   * @return Sphere circumradius passing through two points.
+   * \tparam Point must be a Kernel::Point_d from CGAL.
+   *
+   */
+  double operator()(const Point& point_1, const Point& point_2) const {
+    return std::sqrt(CGAL::to_double(kernel_.squared_distance_d_object()(point_1, point_2))) / 2.;
+  }
+
+  /** \brief Circumradius of sphere passing through point cloud using CGAL.
+   *
+   * @param[in] point_cloud The points.
+   * @return Sphere circumradius passing through the points.
+   * \tparam Point_cloud must be a range of Kernel::Point_d points from CGAL.
+   *
+   */
+  double operator()(const Point_cloud& point_cloud) const {
+    return std::sqrt(CGAL::to_double(kernel_.compute_squared_radius_d_object()(point_cloud.begin(), point_cloud.end())));
+  }
+
+};
+
+}  // namespace cech_complex
+
+}  // namespace Gudhi
+
+#endif  // SPHERE_CIRCUMRADIUS_H_