Fix Cech with radius distance

Add a meta generation script for off_file_generator


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

Former-commit-id: fb13baa124ddc97c0dc61835ab0c72595d666155

2 files changed, 18 insertions, 34 deletions

diff --git a/src/Cech_complex/include/gudhi/Cech_complex.h b/src/Cech_complex/include/gudhi/Cech_complex.h
index e847c97f..a50ed9fa 100644
--- a/src/Cech_complex/include/gudhi/Cech_complex.h
+++ b/src/Cech_complex/include/gudhi/Cech_complex.h
@@ -23,12 +23,12 @@
 #ifndef CECH_COMPLEX_H_
 #define CECH_COMPLEX_H_
 
+#include <gudhi/distance_functions.h>        // for Gudhi::Squared_radius
 #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
 
 #include <iostream>
-#include <cstddef>    // for std::size_t
 #include <stdexcept>  // for exception management
 
 namespace Gudhi {
@@ -43,7 +43,7 @@ namespace cech_complex {
  * 
  * \details
  * The data structure is a proximity graph, containing edges when the edge length is less or equal
- * to a given threshold. Edge length is computed from a user given point cloud with a given distance function.
+ * to a given max_radius. Edge length is computed from `Gudhi::Squared_radius` distance function.
  *
  * \tparam SimplicialComplexForProximityGraph furnishes `Vertex_handle` and `Filtration_value` type definition required
  * by `Gudhi::Proximity_graph`.
@@ -62,23 +62,18 @@ class Cech_complex {
   /** \brief Cech_complex constructor from a list of points.
    *
    * @param[in] points Range of points.
-   * @param[in] threshold Rips value.
-   * @param[in] distance distance function that returns a `Filtration_value` from 2 given points.
+   * @param[in] max_radius Maximal radius value.
    *
    * \tparam ForwardPointRange must be a range for which `.size()`, `.begin()` and `.end()` methods return input
    * iterators on a point. `.begin()` and `.end()` methods are required for a point.
    *
-   * \tparam Distance furnishes `operator()(const Point& p1, const Point& p2)`, where
-   * `Point` is a point from the `ForwardPointRange`, and that returns a `Filtration_value`.
    */
-  template<typename Distance >
-  Cech_complex(const ForwardPointRange& points, Filtration_value threshold, Distance distance)
-    : threshold_(threshold),
+  Cech_complex(const ForwardPointRange& points, Filtration_value max_radius)
+    : max_radius_(max_radius),
       point_cloud_(points) {
-    dimension_ = points.begin()->end() - points.begin()->begin();
     cech_skeleton_graph_ = Gudhi::compute_proximity_graph<SimplicialComplexForProximityGraph>(point_cloud_,
-                                                                                              threshold_,
-                                                                                              distance);
+                                                                                              max_radius_,
+                                                                                              Gudhi::Radius_distance());
   }
 
   /** \brief Initializes the simplicial complex from the proximity graph and expands it until a given maximal
@@ -101,14 +96,9 @@ class Cech_complex {
                                     Cech_blocker<SimplicialComplexForCechComplex, ForwardPointRange>(complex, this));
   }
 
-  /** @return Threshold value given at construction. */
-  Filtration_value threshold() const {
-    return threshold_;
-  }
-
-  /** @return Dimension value given at construction by the first point dimension. */
-  std::size_t dimension() const {
-    return dimension_;
+  /** @return max_radius value given at construction. */
+  Filtration_value max_radius() const {
+    return max_radius_;
   }
 
   /** @param[in] vertex Point position in the range.
@@ -123,9 +113,8 @@ class Cech_complex {
 
  private:
   Proximity_graph cech_skeleton_graph_;
-  Filtration_value threshold_;
+  Filtration_value max_radius_;
   ForwardPointRange point_cloud_;
-  std::size_t dimension_;
 };
 
 }  // namespace cech_complex
diff --git a/src/Cech_complex/include/gudhi/Cech_complex_blocker.h b/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
index fb52f712..d718b56e 100644
--- a/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
+++ b/src/Cech_complex/include/gudhi/Cech_complex_blocker.h
@@ -23,9 +23,8 @@
 #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 <Miniball/Miniball.hpp>
+#include <gudhi/Cech_complex.h>        // Cech_blocker is using a pointer on Gudhi::cech_complex::Cech_complex
+#include <gudhi/distance_functions.h>  // for Gudhi::Squared_radius
 
 #include <iostream>
 #include <vector>
@@ -58,9 +57,6 @@ class Cech_blocker {
  private:
   using Point = std::vector<double>;
   using Point_cloud = std::vector<Point>;
-  using Point_iterator = Point_cloud::const_iterator;
-  using Coordinate_iterator = Point::const_iterator;
-  using Min_sphere = Miniball::Miniball<Miniball::CoordAccessor<Point_iterator, Coordinate_iterator>>;
   using Simplex_handle = typename SimplicialComplexForCech::Simplex_handle;
   using Filtration_value = typename SimplicialComplexForCech::Filtration_value;
   using Cech_complex = Gudhi::cech_complex::Cech_complex<SimplicialComplexForCech, ForwardPointRange>;
@@ -69,7 +65,7 @@ class Cech_blocker {
   /** \internal \brief Cech complex blocker operator() - the oracle - assigns the filtration value from the simplex
    * radius and returns if the simplex expansion must be blocked.
    *  \param[in] sh The Simplex_handle.
-   *  \return true if the simplex radius is greater than the Cech_complex threshold*/
+   *  \return true if the simplex radius is greater than the Cech_complex max_radius*/
   bool operator()(Simplex_handle sh) {
     Point_cloud points;
     for (auto vertex : simplicial_complex_.simplex_vertex_range(sh)) {
@@ -79,13 +75,12 @@ class Cech_blocker {
       std::cout << "#(" << vertex << ")#";
 #endif  // DEBUG_TRACES
     }
-    Min_sphere ms(cc_ptr_->dimension(), points.begin(),points.end());
-    Filtration_value diameter = 2 * std::sqrt(ms.squared_radius());
+    Filtration_value squared_radius = Gudhi::Radius_distance()(points);
 #ifdef DEBUG_TRACES
-    std::cout << "diameter = " << diameter << " - " << (diameter > cc_ptr_->threshold()) << std::endl;
+    std::cout << "squared_radius = " << squared_radius << " - " << (squared_radius > cc_ptr_->max_radius()) << std::endl;
 #endif  // DEBUG_TRACES
-    simplicial_complex_.assign_filtration(sh, diameter);
-    return (diameter > cc_ptr_->threshold());
+    simplicial_complex_.assign_filtration(sh, squared_radius);
+    return (squared_radius > cc_ptr_->max_radius());
   }
 
   /** \internal \brief Cech complex blocker constructor. */