Code review : Cech_blocker was hardcoding double

replace point_iterator function in a get_point const function that returns a Point
InputPointRange description
Cech blocker is now templated with Cech complex, which is no more included.
Deep copy of the point cloud on Cech complex ctor



git-svn-id: svn+ssh://scm.gforge.inria.fr/svnroot/gudhi/branches/cechcomplex_vincent@3365 636b058d-ea47-450e-bf9e-a15bfbe3eedb

Former-commit-id: 93e3cf3fe61290b88a0714b9e55ad80e01a34f36

2 files changed, 30 insertions, 24 deletions

diff --git a/src/Cech_complex/include/gudhi/Cech_complex.h b/src/Cech_complex/include/gudhi/Cech_complex.h
index 52f03d6b..abad0c21 100644
--- a/src/Cech_complex/include/gudhi/Cech_complex.h
+++ b/src/Cech_complex/include/gudhi/Cech_complex.h
@@ -54,11 +54,20 @@ namespace cech_complex {
 template<typename SimplicialComplexForProximityGraph, typename InputPointRange>
 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>;
-  using Point_iterator = typename boost::range_const_iterator<InputPointRange>::type;
-  using Point= typename std::iterator_traits<Point_iterator>::value_type;
+
+  // Retrieve Coordinate type from InputPointRange
+  using Point_from_range_iterator = typename boost::range_const_iterator<InputPointRange>::type;
+  using Point_from_range = typename std::iterator_traits<Point_from_range_iterator>::value_type;
+  using Coordinate_iterator = typename boost::range_const_iterator<Point_from_range>::type;
+  using Coordinate= typename std::iterator_traits<Coordinate_iterator>::value_type;
+
+ public:
+  // Point and Point_cloud type definition
+  using Point = std::vector<Coordinate>;
   using Point_cloud = std::vector<Point>;
 
  public:
@@ -67,13 +76,20 @@ class Cech_complex {
    * @param[in] points Range of points.
    * @param[in] max_radius Maximal radius value.
    *
-   * \tparam InputPointRange 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.
+   * \tparam InputPointRange must be a range of Point. Point must be a range of <b>copyable</b> Cartesian coordinates.
    *
    */
   Cech_complex(const InputPointRange& points, Filtration_value max_radius)
-    : max_radius_(max_radius),
-      point_cloud_(std::begin(points), std::end(points)) {
+    : max_radius_(max_radius) {
+    // Point cloud deep copy
+    auto points_begin_itr = std::begin(points);
+    auto points_end_itr = std::end(points);
+
+    point_cloud_.reserve(points_end_itr - points_begin_itr);
+    for (auto point_itr = points_begin_itr; point_itr < points_end_itr; point_itr++) {
+      point_cloud_.push_back(Point(std::begin(*point_itr), std::end(*point_itr)));
+    }
+
     cech_skeleton_graph_ =
         Gudhi::compute_proximity_graph<SimplicialComplexForProximityGraph>(point_cloud_,
                                                                            max_radius_,
@@ -97,7 +113,7 @@ class Cech_complex {
     complex.insert_graph(cech_skeleton_graph_);
     // expand the graph until dimension dim_max
     complex.expansion_with_blockers(dim_max,
-                                    Cech_blocker<SimplicialComplexForCechComplex, InputPointRange>(&complex, this));
+                                    Cech_blocker<SimplicialComplexForCechComplex, Cech_complex>(&complex, this));
   }
 
   /** @return max_radius value given at construction. */
@@ -106,13 +122,10 @@ class Cech_complex {
   }
 
   /** @param[in] vertex Point position in the range.
-   * @return A const iterator on the point.
-   * @exception std::out_of_range In debug mode, if point position in the range is out.
+   * @return The point.
    */
-  typename InputPointRange::const_iterator point_iterator(std::size_t vertex) const {
-    GUDHI_CHECK((std::begin(point_cloud_) + vertex) < std::end(point_cloud_),
-                std::out_of_range("Cech_complex::point - simplicial complex is not empty"));
-    return (std::begin(point_cloud_) + vertex);
+  const Point& get_point(Vertex_handle vertex) const{
+    return point_cloud_[vertex];
   }
 
  private:
diff --git a/src/Cech_complex/include/gudhi/Cech_complex_blocker.h b/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
index ab56c10d..2ecef9cf 100644
--- a/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
+++ b/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
@@ -23,7 +23,6 @@
 #ifndef CECH_COMPLEX_BLOCKER_H_
 #define CECH_COMPLEX_BLOCKER_H_
 
-#include <gudhi/Cech_complex.h>        // Cech_blocker is using a pointer on Gudhi::cech_complex::Cech_complex
 #include <gudhi/distance_functions.h>  // for Gudhi::Minimal_enclosing_ball_radius
 
 #include <iostream>
@@ -34,10 +33,6 @@ namespace Gudhi {
 
 namespace cech_complex {
 
-// Just declaring Cech_complex class because used and not yet defined.
-template<typename SimplicialComplexForCechComplex, typename InputPointRange>
-class Cech_complex;
-
 /** \internal
  * \class Cech_blocker
  * \brief Cech complex blocker.
@@ -52,14 +47,13 @@ class Cech_complex;
  *
  * \tparam InputPointRange is required by the pointer on Chech_complex for type definition.
  */
-template <typename SimplicialComplexForCech, typename InputPointRange>
+template <typename SimplicialComplexForCech, typename Cech_complex>
 class Cech_blocker {
  private:
-  using Point = std::vector<double>;
-  using Point_cloud = std::vector<Point>;
+  using Point_cloud = typename Cech_complex::Point_cloud;
+
   using Simplex_handle = typename SimplicialComplexForCech::Simplex_handle;
   using Filtration_value = typename SimplicialComplexForCech::Filtration_value;
-  using Cech_complex = Gudhi::cech_complex::Cech_complex<SimplicialComplexForCech, InputPointRange>;
 
  public:
   /** \internal \brief Cech complex blocker operator() - the oracle - assigns the filtration value from the simplex
@@ -69,8 +63,7 @@ class Cech_blocker {
   bool operator()(Simplex_handle sh) {
     Point_cloud points;
     for (auto vertex : sc_ptr_->simplex_vertex_range(sh)) {
-      points.push_back(Point(cc_ptr_->point_iterator(vertex)->begin(),
-                             cc_ptr_->point_iterator(vertex)->end()));
+      points.push_back(cc_ptr_->get_point(vertex));
 #ifdef DEBUG_TRACES
       std::cout << "#(" << vertex << ")#";
 #endif  // DEBUG_TRACES