clang-format all files

Add safe version alpha complex 3d persistence utility


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

Former-commit-id: 54b2d0de9231511864df9fa637b60b7ccf34f50f

2 files changed, 61 insertions, 42 deletions

diff --git a/src/Alpha_complex/utilities/CMakeLists.txt b/src/Alpha_complex/utilities/CMakeLists.txt
index 80444de8..65ca1624 100644
--- a/src/Alpha_complex/utilities/CMakeLists.txt
+++ b/src/Alpha_complex/utilities/CMakeLists.txt
@@ -30,9 +30,15 @@ if(CGAL_FOUND)
             "${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off"
             "-p" "2" "-m" "0.45" "-o" "exact.pers" "-e")
 
+    add_test(NAME Alpha_complex_utilities_safe_alpha_complex_3d COMMAND $<TARGET_FILE:alpha_complex_3d_persistence>
+            "${CMAKE_SOURCE_DIR}/data/points/tore3D_300.off"
+            "-p" "2" "-m" "0.45" "-o" "safe.pers" "-s")
+
     if (DIFF_PATH)
       add_test(Alpha_complex_utilities_diff_alpha_complex_3d ${DIFF_PATH}
               "exact.pers" "alpha.pers")
+      add_test(Alpha_complex_utilities_diff_alpha_complex_3d ${DIFF_PATH}
+              "safe.pers" "alpha.pers")
     endif()
 
     add_test(NAME Alpha_complex_utilities_periodic_alpha_complex_3d_persistence COMMAND $<TARGET_FILE:alpha_complex_3d_persistence>
diff --git a/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp b/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp
index c2b49fed..d14ba375 100644
--- a/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp
+++ b/src/Alpha_complex/utilities/alpha_complex_3d_persistence.cpp
@@ -38,11 +38,12 @@ using Filtration_value = Simplex_tree::Filtration_value;
 using Persistent_cohomology =
     Gudhi::persistent_cohomology::Persistent_cohomology<Simplex_tree, Gudhi::persistent_cohomology::Field_Zp>;
 
-void program_options(int argc, char *argv[], std::string &off_file_points, bool& EXACT, std::string &weight_file,
-                     std::string &cuboid_file, std::string &output_file_diag, Filtration_value &alpha_square_max_value,
-                     int &coeff_field_characteristic, Filtration_value &min_persistence);
+void program_options(int argc, char *argv[], std::string &off_file_points, bool &exact, bool &safe,
+                     std::string &weight_file, std::string &cuboid_file, std::string &output_file_diag,
+                     Filtration_value &alpha_square_max_value, int &coeff_field_characteristic,
+                     Filtration_value &min_persistence);
 
-bool read_weight_file(const std::string& weight_file, std::vector<double>& weights) {
+bool read_weight_file(const std::string &weight_file, std::vector<double> &weights) {
   // Read weights information from file
   std::ifstream weights_ifstr(weight_file);
   if (weights_ifstr.good()) {
@@ -57,8 +58,8 @@ bool read_weight_file(const std::string& weight_file, std::vector<double>& weigh
   return true;
 }
 
-bool read_cuboid_file(const std::string& cuboid_file, double& x_min, double& y_min, double& z_min,
-                      double& x_max, double& y_max, double& z_max) {
+bool read_cuboid_file(const std::string &cuboid_file, double &x_min, double &y_min, double &z_min, double &x_max,
+                      double &y_max, double &z_max) {
   // Read weights information from file
   std::ifstream iso_cuboid_str(cuboid_file);
   if (iso_cuboid_str.is_open()) {
@@ -71,8 +72,8 @@ bool read_cuboid_file(const std::string& cuboid_file, double& x_min, double& y_m
   return true;
 }
 
-template<typename AlphaComplex3d>
-std::vector<typename AlphaComplex3d::Point_3> read_off(const std::string& off_file_points) {
+template <typename AlphaComplex3d>
+std::vector<typename AlphaComplex3d::Point_3> read_off(const std::string &off_file_points) {
   // Read the OFF file (input file name given as parameter) and triangulate points
   Gudhi::Points_3D_off_reader<typename AlphaComplex3d::Point_3> off_reader(off_file_points);
   // Check the read operation was correct
@@ -92,10 +93,11 @@ int main(int argc, char **argv) {
   int coeff_field_characteristic = 0;
   Filtration_value min_persistence = 0.;
   bool exact_version = false;
+  bool safe_version = false;
   bool weighted_version = false;
   bool periodic_version = false;
 
-  program_options(argc, argv, off_file_points, exact_version, weight_file, cuboid_file, output_file_diag,
+  program_options(argc, argv, off_file_points, exact_version, safe_version, weight_file, cuboid_file, output_file_diag,
                   alpha_square_max_value, coeff_field_characteristic, min_persistence);
 
   std::vector<double> weights;
@@ -107,7 +109,7 @@ int main(int argc, char **argv) {
     weighted_version = true;
   }
 
-  double x_min=0., y_min=0., z_min=0., x_max=0., y_max=0., z_max=0.;
+  double x_min = 0., y_min = 0., z_min = 0., x_max = 0., y_max = 0., z_max = 0.;
   std::ifstream iso_cuboid_str(argv[3]);
   if (cuboid_file != std::string()) {
     if (!read_cuboid_file(cuboid_file, x_min, y_min, z_min, x_max, y_max, z_max)) {
@@ -119,37 +121,44 @@ int main(int argc, char **argv) {
 
   Gudhi::alpha_complex::complexity complexity = Gudhi::alpha_complex::complexity::FAST;
   if (exact_version) {
+    if (safe_version) {
+      std::cerr << "You cannot set the exact and the safe version." << std::endl;
+      exit(-1);
+    }
     complexity = Gudhi::alpha_complex::complexity::EXACT;
   }
+  if (safe_version) {
+    complexity = Gudhi::alpha_complex::complexity::SAFE;
+  }
 
   Simplex_tree simplex_tree;
 
-  switch(complexity) {
+  switch (complexity) {
     case Gudhi::alpha_complex::complexity::FAST:
       if (weighted_version) {
         if (periodic_version) {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::FAST,
-              true, true>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::FAST, true, true>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points, weights, x_min, y_min, z_min, x_max, y_max, z_max);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
         } else {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::FAST,
-              true, false>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::FAST, true, false>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points, weights);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
         }
       } else {
         if (periodic_version) {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::FAST,
-              false, true>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::FAST, false, true>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points, x_min, y_min, z_min, x_max, y_max, z_max);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
         } else {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::FAST,
-              false, false>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::FAST, false, false>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
@@ -159,28 +168,28 @@ int main(int argc, char **argv) {
     case Gudhi::alpha_complex::complexity::EXACT:
       if (weighted_version) {
         if (periodic_version) {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::EXACT,
-              true, true>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::EXACT, true, true>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points, weights, x_min, y_min, z_min, x_max, y_max, z_max);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
         } else {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::EXACT,
-              true, false>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::EXACT, true, false>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points, weights);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
         }
       } else {
         if (periodic_version) {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::EXACT,
-              false, true>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::EXACT, false, true>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points, x_min, y_min, z_min, x_max, y_max, z_max);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
         } else {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::EXACT,
-              false, false>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::EXACT, false, false>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
@@ -190,28 +199,28 @@ int main(int argc, char **argv) {
     case Gudhi::alpha_complex::complexity::SAFE:
       if (weighted_version) {
         if (periodic_version) {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::SAFE,
-              true, true>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::SAFE, true, true>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points, weights, x_min, y_min, z_min, x_max, y_max, z_max);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
         } else {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::SAFE,
-              true, false>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::SAFE, true, false>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points, weights);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
         }
       } else {
         if (periodic_version) {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::SAFE,
-              false, true>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::SAFE, false, true>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points, x_min, y_min, z_min, x_max, y_max, z_max);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
         } else {
-          using Alpha_complex_3d = Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::SAFE,
-              false, false>;
+          using Alpha_complex_3d =
+              Gudhi::alpha_complex::Alpha_complex_3d<Gudhi::alpha_complex::complexity::SAFE, false, false>;
           auto points = read_off<Alpha_complex_3d>(off_file_points);
           Alpha_complex_3d alpha_complex(points);
           alpha_complex.create_complex(simplex_tree, alpha_square_max_value);
@@ -248,9 +257,10 @@ int main(int argc, char **argv) {
   return 0;
 }
 
-void program_options(int argc, char *argv[], std::string &off_file_points, bool& EXACT, std::string &weight_file,
-                     std::string &cuboid_file, std::string &output_file_diag, Filtration_value &alpha_square_max_value,
-                     int &coeff_field_characteristic, Filtration_value &min_persistence) {
+void program_options(int argc, char *argv[], std::string &off_file_points, bool &exact, bool &safe,
+                     std::string &weight_file, std::string &cuboid_file, std::string &output_file_diag,
+                     Filtration_value &alpha_square_max_value, int &coeff_field_characteristic,
+                     Filtration_value &min_persistence) {
   namespace po = boost::program_options;
   po::options_description hidden("Hidden options");
   hidden.add_options()("input-file", po::value<std::string>(&off_file_points),
@@ -258,15 +268,18 @@ void program_options(int argc, char *argv[], std::string &off_file_points, bool&
 
   po::options_description visible("Allowed options", 100);
   visible.add_options()("help,h", "produce help message")(
-      "EXACT,e", po::bool_switch(&EXACT),
-      "To activate EXACT version of Alpha complex 3d (default is false, not available for weighted and/or periodic)")(
+      "exact,e", po::bool_switch(&exact),
+      "To activate exact version of Alpha complex 3d (default is false, not available if safe is set)")(
+      "safe,s", po::bool_switch(&safe),
+      "To activate safe version of Alpha complex 3d (default is false, not available if exact is set)")(
       "weight-file,w", po::value<std::string>(&weight_file)->default_value(std::string()),
       "Name of file containing a point weights. Format is one weight per line:\n  W1\n  ...\n  Wn ")(
       "cuboid-file,c", po::value<std::string>(&cuboid_file),
       "Name of file describing the periodic domain. Format is:\n  min_hx min_hy min_hz\n  max_hx max_hy max_hz")(
       "output-file,o", po::value<std::string>(&output_file_diag)->default_value(std::string()),
       "Name of file in which the persistence diagram is written. Default print in std::cout")(
-      "max-alpha-square-value,r", po::value<Filtration_value>(&alpha_square_max_value)
+      "max-alpha-square-value,r",
+      po::value<Filtration_value>(&alpha_square_max_value)
           ->default_value(std::numeric_limits<Filtration_value>::infinity()),
       "Maximal alpha square value for the Alpha complex construction.")(
       "field-charac,p", po::value<int>(&coeff_field_characteristic)->default_value(11),
@@ -289,7 +302,7 @@ void program_options(int argc, char *argv[], std::string &off_file_points, bool&
     std::cout << std::endl;
     std::cout << "Compute the persistent homology with coefficient field Z/pZ \n";
     std::cout << "of a 3D Alpha complex defined on a set of input points.\n";
-    std::cout << "3D Alpha complex can be EXACT or weighted and/or periodic\n\n";
+    std::cout << "3D Alpha complex can be exact or safe, weighted and/or periodic\n\n";
     std::cout << "The output diagram contains one bar per line, written with the convention: \n";
     std::cout << "   p   dim b d \n";
     std::cout << "where dim is the dimension of the homological feature,\n";