Merge from trunk.

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

Former-commit-id: c8e1376894207c8c08896f750f71c115e07f6d95

8 files changed, 216 insertions, 215 deletions

diff --git a/src/Contraction/doc/sphere_contraction_representation.png b/src/Contraction/doc/sphere_contraction_representation.png
new file mode 100644
index 00000000..edf37bf3
--- /dev/null
+++ b/src/Contraction/doc/sphere_contraction_representation.png
diff --git a/src/Contraction/example/CMakeLists.txt b/src/Contraction/example/CMakeLists.txt
index 4889b82f..4c09a0a7 100644
--- a/src/Contraction/example/CMakeLists.txt
+++ b/src/Contraction/example/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 2.6)
-project(GUDHIskbl)
+project(Contraction_examples)
 
 
 add_executable(RipsContraction Rips_contraction.cpp)
@@ -9,5 +9,7 @@ target_link_libraries(RipsContraction ${Boost_TIMER_LIBRARY} ${Boost_SYSTEM_LIBR
 target_link_libraries(GarlandHeckbert ${Boost_TIMER_LIBRARY} ${Boost_SYSTEM_LIBRARY})	
 
 
-add_test(RipsContraction.sphere.0.2 ${CMAKE_CURRENT_BINARY_DIR}/RipsContraction ${CMAKE_SOURCE_DIR}/data/points/sphere3D_2646.off 0.2)
-add_test(RipsContraction.S0310000 ${CMAKE_CURRENT_BINARY_DIR}/RipsContraction ${CMAKE_SOURCE_DIR}/data/points/SO3_10000.off 0.3)
+add_test(RipsContraction.tore3D.0.2 ${CMAKE_CURRENT_BINARY_DIR}/RipsContraction ${CMAKE_SOURCE_DIR}/data/points/tore3D_1307.off 0.2)
+# TODO(DS) : These tests are too long under Windows
+#add_test(RipsContraction.sphere.0.2 ${CMAKE_CURRENT_BINARY_DIR}/RipsContraction ${CMAKE_SOURCE_DIR}/data/points/sphere3D_2646.off 0.2)
+#add_test(RipsContraction.S0310000 ${CMAKE_CURRENT_BINARY_DIR}/RipsContraction ${CMAKE_SOURCE_DIR}/data/points/SO3_10000.off 0.3)
diff --git a/src/Contraction/example/Garland_heckbert.cpp b/src/Contraction/example/Garland_heckbert.cpp
index 70f29b6a..5347830c 100644
--- a/src/Contraction/example/Garland_heckbert.cpp
+++ b/src/Contraction/example/Garland_heckbert.cpp
@@ -35,9 +35,8 @@
 
 #include "Garland_heckbert/Error_quadric.h"
 
-using namespace std;
 using namespace Gudhi;
-using namespace skbl;
+using namespace skeleton_blocker;
 using namespace contraction;
 
 struct Geometry_trait {
@@ -145,12 +144,13 @@ class GH_visitor : public Gudhi::contraction::Contraction_visitor<EdgeProfile> {
 
 int main(int argc, char *argv[]) {
   if (argc != 4) {
-    std::cerr << "Usage " << argv[0] << " input.off output.off N to load the file input.off, contract N edges and save "
-        << "the result to output.off.\n";
+    std::cerr << "Usage " << argv[0] <<
+        " input.off output.off N to load the file input.off, contract N edges and save the result to output.off.\n";
     return EXIT_FAILURE;
   }
 
   Complex complex;
+  typedef Complex::Vertex_handle Vertex_handle;
 
   // load the points
   Skeleton_blocker_off_reader<Complex> off_reader(argv[1], complex);
@@ -159,8 +159,12 @@ int main(int argc, char *argv[]) {
     return EXIT_FAILURE;
   }
 
-  std::cout << "Load complex with " << complex.num_vertices() << " vertices" << std::endl;
+  if (!complex.empty() && !(complex.point(Vertex_handle(0)).dimension() == 3)) {
+    std::cerr << "Only points of dimension 3 are supported." << std::endl;
+    return EXIT_FAILURE;
+  }
 
+  std::cout << "Load complex with " << complex.num_vertices() << " vertices" << std::endl;
 
   int num_contractions = atoi(argv[3]);
 
@@ -178,7 +182,7 @@ int main(int argc, char *argv[]) {
 
   std::cout << "Final complex has " <<
       complex.num_vertices() << " vertices, " <<
-      complex.num_edges() << " edges and" <<
+      complex.num_edges() << " edges and " <<
       complex.num_triangles() << " triangles." << std::endl;
 
   // write simplified complex
@@ -187,6 +191,8 @@ int main(int argc, char *argv[]) {
   return EXIT_SUCCESS;
 }
 
+#endif  // GARLAND_HECKBERT_H_
+
+
 
 
-#endif  // GARLAND_HECKBERT_H_
diff --git a/src/Contraction/example/Garland_heckbert/Error_quadric.h b/src/Contraction/example/Garland_heckbert/Error_quadric.h
index a033aa00..076f1be0 100644
--- a/src/Contraction/example/Garland_heckbert/Error_quadric.h
+++ b/src/Contraction/example/Garland_heckbert/Error_quadric.h
@@ -1,182 +1,182 @@
-/* This file is part of the Gudhi Library. The Gudhi library 

- *    (Geometric Understanding in Higher Dimensions) is a generic C++ 

- *    library for computational topology.

- *

- *    Author(s):       David Salinas

- *

- *    Copyright (C) 2014  INRIA Sophia Antipolis-M�diterran�e (France)

- *

- *    This program is free software: you can redistribute it and/or modify

- *    it under the terms of the GNU General Public License as published by

- *    the Free Software Foundation, either version 3 of the License, or

- *    (at your option) any later version.

- *

- *    This program is distributed in the hope that it will be useful,

- *    but WITHOUT ANY WARRANTY; without even the implied warranty of

- *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

- *    GNU General Public License for more details.

- *

- *    You should have received a copy of the GNU General Public License

- *    along with this program.  If not, see <http://www.gnu.org/licenses/>.

- * 

- */

-

-#ifndef ERROR_QUADRIC_H_

-#define ERROR_QUADRIC_H_

-

-#include <boost/optional/optional.hpp>

-

-#include <vector>

-#include <utility>

-

-template <typename Point> class Error_quadric {

- private:

-  double coeff[10];

-

- public:

-  Error_quadric() {

-    clear();

-  }

-

-  /**

-   * Quadric corresponding to the L2 distance to the plane.

-   *

-   * According to the notation of Garland Heckbert, they

-   * denote a quadric symetric matrix as :

-   * Q = [ q11 q12 q13 q14]

-   *     [ q12 q22 q23 q24]

-   *     [ q13 q23 q33 q34]

-   *     [ q14 q24 q34 q44]

-   *

-   * which is represented by a vector with 10 elts that

-   * are denoted ci for clarity with :

-   * Q = [ c0  c1  c2  c3 ]

-   *     [ c1  c4  c5  c6 ]

-   *     [ c2  c5  c7  c8 ]

-   *     [ c3  c6  c8  c9 ]

-   *

-   * The constructor return the quadrics that represents

-   * the squared distance to the plane defined by triangle p0,p1,p2

-   * times the area of triangle p0,p1,p2.

-   */

-  Error_quadric(const Point & p0, const Point & p1, const Point & p2) {

-    Point normal(unit_normal(p0, p1, p2));

-    double a = normal[0];

-    double b = normal[1];

-    double c = normal[2];

-    double d = -a * p0[0] - b * p0[1] - c * p0[2];

-    coeff[0] = a*a;

-    coeff[1] = a*b;

-    coeff[2] = a*c;

-    coeff[3] = a*d;

-    coeff[4] = b*b;

-    coeff[5] = b*c;

-    coeff[6] = b*d;

-    coeff[7] = c*c;

-    coeff[8] = c*d;

-    coeff[9] = d*d;

-

-    double area_p0p1p2 = std::sqrt(squared_area(p0, p1, p2));

-    for (auto& x : coeff)

-      x *= area_p0p1p2;

-  }

-

-  inline double squared_area(const Point& p0, const Point& p1, const Point& p2) {

-    // if (x1,x2,x3) = p1-p0 and (y1,y2,y3) = p2-p0

-    // then the squared area is = (u^2+v^2+w^2)/4

-    // with: u = x2 * y3 - x3 * y2;

-    //       v = x3 * y1 - x1 * y3;

-    //       w = x1 * y2 - x2 * y1;

-    Point p0p1(p1 - p0);

-    Point p0p2(p2 - p0);

-    double A = p0p1[1] * p0p2[2] - p0p1[2] * p0p2[1];

-    double B = p0p1[2] * p0p2[0] - p0p1[0] * p0p2[2];

-    double C = p0p1[0] * p0p2[1] - p0p1[1] * p0p2[0];

-    return 1. / 4. * (A * A + B * B + C * C);

-  }

-

-  void clear() {

-    for (auto& x : coeff)

-      x = 0;

-  }

-

-  Error_quadric& operator+=(const Error_quadric& other) {

-    if (this != &other) {

-      for (int i = 0; i < 10; ++i)

-        coeff[i] += other.coeff[i];

-    }

-    return *this;

-  }

-

-  /**

-   * @return The quadric quost defined by the scalar product v^T Q v where Q is the quadratic form of Garland/Heckbert

-   */

-  inline double cost(const Point& point) const {

-    double cost =

-        coeff[0] * point.x() * point.x() + coeff[4] * point.y() * point.y() + coeff[7] * point.z() * point.z()

-        + 2 * (coeff[1] * point.x() * point.y() + coeff[5] * point.y() * point.z() + coeff[2] * point.z() * point.x())

-        + 2 * (coeff[3] * point.x() + coeff[6] * point.y() + coeff[8] * point.z())

-        + coeff[9];

-    if (cost < 0) {

-      return 0;

-    } else {

-      return cost;

-    }

-  }

-

-  inline double grad_determinant() const {

-    return

-    coeff[0] * coeff[4] * coeff[7]

-        - coeff[0] * coeff[5] * coeff[5]

-        - coeff[1] * coeff[1] * coeff[7]

-        + 2 * coeff[1] * coeff[5] * coeff[2]

-        - coeff[4] * coeff[2] * coeff[2];

-  }

-

-  /**

-   * Return the point such that it minimizes the gradient of the quadric.

-   * Det must be passed with the determinant value of the gradient (should be non zero).

-   */

-  inline Point solve_linear_gradient(double det) const {

-    return Point({

-                 (-coeff[1] * coeff[5] * coeff[8] + coeff[1] * coeff[7] * coeff[6] + coeff[2] * coeff[8] * coeff[4] -

-                     coeff[2] * coeff[5] * coeff[6] - coeff[3] * coeff[4] * coeff[7] + coeff[3] * coeff[5] * coeff[5])

-                     / det,

-                 (coeff[0] * coeff[5] * coeff[8] - coeff[0] * coeff[7] * coeff[6] - coeff[5] * coeff[2] * coeff[3] -

-                     coeff[1] * coeff[2] * coeff[8] + coeff[6] * coeff[2] * coeff[2] + coeff[1] * coeff[3] * coeff[7])

-                     / det,

-                 (-coeff[8] * coeff[0] * coeff[4] + coeff[8] * coeff[1] * coeff[1] + coeff[2] * coeff[3] * coeff[4] +

-                     coeff[5] * coeff[0] * coeff[6] - coeff[5] * coeff[1] * coeff[3] - coeff[1] * coeff[2] * coeff[6])

-                     / det

-    });

-  }

-

-  /**

-   * returns the point that minimizes the quadric.

-   * It inverses the quadric if its determinant is higher that a given threshold .

-   * If the determinant is lower than this value the returned value is uninitialized.

-   */

-  boost::optional<Point> min_cost(double scale = 1) const {

-    // const double min_determinant = 1e-4 * scale*scale;

-    const double min_determinant = 1e-5;

-    boost::optional<Point> pt_res;

-    double det = grad_determinant();

-    if (std::abs(det) > min_determinant)

-      pt_res = solve_linear_gradient(det);

-    return pt_res;

-  }

-

-  friend std::ostream& operator<<(std::ostream& stream, const Error_quadric& quadric) {

-    stream << "\n[ " << quadric.coeff[0] << "," << quadric.coeff[1] << "," << quadric.coeff[2] << "," <<

-        quadric.coeff[3] << ";\n";

-    stream << " " << quadric.coeff[1] << "," << quadric.coeff[4] << "," << quadric.coeff[5] << "," <<

-        quadric.coeff[6] << ";\n";

-    stream << " " << quadric.coeff[2] << "," << quadric.coeff[5] << "," << quadric.coeff[7] << "," <<

-        quadric.coeff[8] << ";\n";

-    stream << " " << quadric.coeff[3] << "," << quadric.coeff[6] << "," << quadric.coeff[8] << "," <<

-        quadric.coeff[9] << "]";

-    return stream;

-  }

-};

-

-#endif  // ERROR_QUADRIC_H_

+/* This file is part of the Gudhi Library. The Gudhi library 
+ *    (Geometric Understanding in Higher Dimensions) is a generic C++ 
+ *    library for computational topology.
+ *
+ *    Author(s):       David Salinas
+ *
+ *    Copyright (C) 2014  INRIA Sophia Antipolis-M�diterran�e (France)
+ *
+ *    This program is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+#ifndef ERROR_QUADRIC_H_
+#define ERROR_QUADRIC_H_
+
+#include <boost/optional/optional.hpp>
+
+#include <vector>
+#include <utility>
+
+template <typename Point> class Error_quadric {
+ private:
+  double coeff[10];
+
+ public:
+  Error_quadric() {
+    clear();
+  }
+
+  /**
+   * Quadric corresponding to the L2 distance to the plane.
+   *
+   * According to the notation of Garland Heckbert, they
+   * denote a quadric symetric matrix as :
+   * Q = [ q11 q12 q13 q14]
+   *     [ q12 q22 q23 q24]
+   *     [ q13 q23 q33 q34]
+   *     [ q14 q24 q34 q44]
+   *
+   * which is represented by a vector with 10 elts that
+   * are denoted ci for clarity with :
+   * Q = [ c0  c1  c2  c3 ]
+   *     [ c1  c4  c5  c6 ]
+   *     [ c2  c5  c7  c8 ]
+   *     [ c3  c6  c8  c9 ]
+   *
+   * The constructor return the quadrics that represents
+   * the squared distance to the plane defined by triangle p0,p1,p2
+   * times the area of triangle p0,p1,p2.
+   */
+  Error_quadric(const Point & p0, const Point & p1, const Point & p2) {
+    Point normal(unit_normal(p0, p1, p2));
+    double a = normal[0];
+    double b = normal[1];
+    double c = normal[2];
+    double d = -a * p0[0] - b * p0[1] - c * p0[2];
+    coeff[0] = a*a;
+    coeff[1] = a*b;
+    coeff[2] = a*c;
+    coeff[3] = a*d;
+    coeff[4] = b*b;
+    coeff[5] = b*c;
+    coeff[6] = b*d;
+    coeff[7] = c*c;
+    coeff[8] = c*d;
+    coeff[9] = d*d;
+
+    double area_p0p1p2 = std::sqrt(squared_area(p0, p1, p2));
+    for (auto& x : coeff)
+      x *= area_p0p1p2;
+  }
+
+  inline double squared_area(const Point& p0, const Point& p1, const Point& p2) {
+    // if (x1,x2,x3) = p1-p0 and (y1,y2,y3) = p2-p0
+    // then the squared area is = (u^2+v^2+w^2)/4
+    // with: u = x2 * y3 - x3 * y2;
+    //       v = x3 * y1 - x1 * y3;
+    //       w = x1 * y2 - x2 * y1;
+    Point p0p1(p1 - p0);
+    Point p0p2(p2 - p0);
+    double A = p0p1[1] * p0p2[2] - p0p1[2] * p0p2[1];
+    double B = p0p1[2] * p0p2[0] - p0p1[0] * p0p2[2];
+    double C = p0p1[0] * p0p2[1] - p0p1[1] * p0p2[0];
+    return 1. / 4. * (A * A + B * B + C * C);
+  }
+
+  void clear() {
+    for (auto& x : coeff)
+      x = 0;
+  }
+
+  Error_quadric& operator+=(const Error_quadric& other) {
+    if (this != &other) {
+      for (int i = 0; i < 10; ++i)
+        coeff[i] += other.coeff[i];
+    }
+    return *this;
+  }
+
+  /**
+   * @return The quadric quost defined by the scalar product v^T Q v where Q is the quadratic form of Garland/Heckbert
+   */
+  inline double cost(const Point& point) const {
+    double cost =
+        coeff[0] * point.x() * point.x() + coeff[4] * point.y() * point.y() + coeff[7] * point.z() * point.z()
+        + 2 * (coeff[1] * point.x() * point.y() + coeff[5] * point.y() * point.z() + coeff[2] * point.z() * point.x())
+        + 2 * (coeff[3] * point.x() + coeff[6] * point.y() + coeff[8] * point.z())
+        + coeff[9];
+    if (cost < 0) {
+      return 0;
+    } else {
+      return cost;
+    }
+  }
+
+  inline double grad_determinant() const {
+    return
+    coeff[0] * coeff[4] * coeff[7]
+        - coeff[0] * coeff[5] * coeff[5]
+        - coeff[1] * coeff[1] * coeff[7]
+        + 2 * coeff[1] * coeff[5] * coeff[2]
+        - coeff[4] * coeff[2] * coeff[2];
+  }
+
+  /**
+   * Return the point such that it minimizes the gradient of the quadric.
+   * Det must be passed with the determinant value of the gradient (should be non zero).
+   */
+  inline Point solve_linear_gradient(double det) const {
+    return Point({
+                 (-coeff[1] * coeff[5] * coeff[8] + coeff[1] * coeff[7] * coeff[6] + coeff[2] * coeff[8] * coeff[4] -
+                     coeff[2] * coeff[5] * coeff[6] - coeff[3] * coeff[4] * coeff[7] + coeff[3] * coeff[5] * coeff[5])
+                     / det,
+                 (coeff[0] * coeff[5] * coeff[8] - coeff[0] * coeff[7] * coeff[6] - coeff[5] * coeff[2] * coeff[3] -
+                     coeff[1] * coeff[2] * coeff[8] + coeff[6] * coeff[2] * coeff[2] + coeff[1] * coeff[3] * coeff[7])
+                     / det,
+                 (-coeff[8] * coeff[0] * coeff[4] + coeff[8] * coeff[1] * coeff[1] + coeff[2] * coeff[3] * coeff[4] +
+                     coeff[5] * coeff[0] * coeff[6] - coeff[5] * coeff[1] * coeff[3] - coeff[1] * coeff[2] * coeff[6])
+                     / det
+    });
+  }
+
+  /**
+   * returns the point that minimizes the quadric.
+   * It inverses the quadric if its determinant is higher that a given threshold .
+   * If the determinant is lower than this value the returned value is uninitialized.
+   */
+  boost::optional<Point> min_cost(double scale = 1) const {
+    // const double min_determinant = 1e-4 * scale*scale;
+    const double min_determinant = 1e-5;
+    boost::optional<Point> pt_res;
+    double det = grad_determinant();
+    if (std::abs(det) > min_determinant)
+      pt_res = solve_linear_gradient(det);
+    return pt_res;
+  }
+
+  friend std::ostream& operator<<(std::ostream& stream, const Error_quadric& quadric) {
+    stream << "\n[ " << quadric.coeff[0] << "," << quadric.coeff[1] << "," << quadric.coeff[2] << "," <<
+        quadric.coeff[3] << ";\n";
+    stream << " " << quadric.coeff[1] << "," << quadric.coeff[4] << "," << quadric.coeff[5] << "," <<
+        quadric.coeff[6] << ";\n";
+    stream << " " << quadric.coeff[2] << "," << quadric.coeff[5] << "," << quadric.coeff[7] << "," <<
+        quadric.coeff[8] << ";\n";
+    stream << " " << quadric.coeff[3] << "," << quadric.coeff[6] << "," << quadric.coeff[8] << "," <<
+        quadric.coeff[9] << "]";
+    return stream;
+  }
+};
+
+#endif  // ERROR_QUADRIC_H_
diff --git a/src/Contraction/example/Rips_contraction.cpp b/src/Contraction/example/Rips_contraction.cpp
index d21246ed..7f19e239 100644
--- a/src/Contraction/example/Rips_contraction.cpp
+++ b/src/Contraction/example/Rips_contraction.cpp
@@ -27,9 +27,8 @@
 #include <boost/timer/timer.hpp>
 #include <iostream>
 
-using namespace std;
 using namespace Gudhi;
-using namespace skbl;
+using namespace skeleton_blocker;
 using namespace contraction;
 
 struct Geometry_trait {
@@ -49,7 +48,7 @@ void build_rips(ComplexType& complex, double offset) {
   for (auto p = vertices.begin(); p != vertices.end(); ++p)
     for (auto q = p; ++q != vertices.end(); /**/) {
       if (squared_dist(complex.point(*p), complex.point(*q)) < 4 * offset * offset)
-        complex.add_edge(*p, *q);
+        complex.add_edge_without_blockers(*p, *q);
     }
 }
 
@@ -87,7 +86,7 @@ int main(int argc, char *argv[]) {
   contractor.contract_edges();
 
   std::cout << "Counting final number of simplices \n";
-  unsigned num_simplices = std::distance(complex.simplex_range().begin(), complex.simplex_range().end());
+  unsigned num_simplices = std::distance(complex.complex_simplex_range().begin(), complex.complex_simplex_range().end());
 
   std::cout << "Final complex has " <<
       complex.num_vertices() << " vertices, " <<
diff --git a/src/Contraction/include/gudhi/Contraction/policies/Link_condition_valid_contraction.h b/src/Contraction/include/gudhi/Contraction/policies/Link_condition_valid_contraction.h
index 919df243..250bba27 100644
--- a/src/Contraction/include/gudhi/Contraction/policies/Link_condition_valid_contraction.h
+++ b/src/Contraction/include/gudhi/Contraction/policies/Link_condition_valid_contraction.h
@@ -23,8 +23,8 @@
 #ifndef CONTRACTION_POLICIES_LINK_CONDITION_VALID_CONTRACTION_H_
 #define CONTRACTION_POLICIES_LINK_CONDITION_VALID_CONTRACTION_H_
 
-#include <gudhi/Utils.h>
 #include <gudhi/Contraction/policies/Valid_contraction_policy.h>
+#include <gudhi/Debug_utils.h>
 
 
 namespace Gudhi {
diff --git a/src/Contraction/include/gudhi/Edge_contraction.h b/src/Contraction/include/gudhi/Edge_contraction.h
index dfce8d1b..61f2d945 100644
--- a/src/Contraction/include/gudhi/Edge_contraction.h
+++ b/src/Contraction/include/gudhi/Edge_contraction.h
@@ -30,23 +30,23 @@
 #include <gudhi/Contraction/policies/Valid_contraction_policy.h>
 #include <gudhi/Contraction/policies/Dummy_valid_contraction.h>
 #include <gudhi/Contraction/policies/Link_condition_valid_contraction.h>
-#include <gudhi/Utils.h>
+#include <gudhi/Debug_utils.h>
 
 namespace Gudhi {
 
 namespace contraction {
 
 
-/** \defgroup contr Contraction
+/** \defgroup contr Edge contraction
 
 \author David Salinas
 
-\section Introduction
+\section edgecontractionintroduction Introduction
 
 The purpose of this package is to offer a user-friendly interface for edge contraction simplification of huge simplicial complexes.
 It uses the \ref skbl data-structure whose size remains small  during simplification  
 of  most used geometrical complexes of topological data analysis such as the Rips or the Delaunay complexes. In practice, the 
-size of this data-structure is even uch lower than the total number of simplices.
+size of this data-structure is even much lower than the total number of simplices.
 
 The edge contraction operation consists in identifying two vertices of a simplicial complex. 
 A lot of algorithms have been developed in computer graphics that allows to reduce efficiently the size of 2-dimensional simplicial complexes
@@ -127,7 +127,7 @@ while ensuring its homotopy type is preserved during the contraction (edge are c
 
 using namespace std;
 using namespace Gudhi;
-using namespace skbl;
+using namespace skeleton_blocker;
 using namespace contraction;
 
 struct Geometry_trait{
@@ -158,7 +158,7 @@ void build_rips(ComplexType& complex, double offset){
 	for (auto p = vertices.begin(); p != vertices.end(); ++p)
 		for (auto q = p; ++q != vertices.end(); )
 			if (eucl_distance(complex.point(*p), complex.point(*q)) < 2 * offset)
-				complex.add_edge(*p,*q);
+				complex.add_edge_without_blockers(*p,*q);
 }
 
 int main (int argc, char *argv[])
@@ -194,7 +194,7 @@ int main (int argc, char *argv[])
 	contractor.contract_edges();
 
 	std::cout << "Counting final number of simplices \n";
-	unsigned num_simplices = std::distance(complex.simplex_range().begin(),complex.simplex_range().end());
+	unsigned num_simplices = std::distance(complex.star_simplex_range().begin(),complex.star_simplex_range().end());
 
 	std::cout << "Final complex has "<<
 			complex.num_vertices()<<" vertices, "<<
@@ -226,7 +226,6 @@ Time to simplify and enumerate simplices:
 
 
 \copyright GNU General Public License v3.                         
-\verbatim  Contact: David Salinas,     david.salinas@inria.fr \endverbatim
 */
 /** @} */  // end defgroup
 }  // namespace contraction
diff --git a/src/Contraction/include/gudhi/Skeleton_blocker_contractor.h b/src/Contraction/include/gudhi/Skeleton_blocker_contractor.h
index 2759b540..df884c93 100644
--- a/src/Contraction/include/gudhi/Skeleton_blocker_contractor.h
+++ b/src/Contraction/include/gudhi/Skeleton_blocker_contractor.h
@@ -37,7 +37,7 @@
 #include <gudhi/Contraction/policies/Contraction_visitor.h>
 
 #include <gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h>
-#include <gudhi/Utils.h>
+#include <gudhi/Debug_utils.h>
 
 
 #include <boost/scoped_array.hpp>
@@ -100,20 +100,15 @@ Contraction_visitor<Profile>* make_remove_popable_blockers_visitor() {
  *
  */
 template<class GeometricSimplifiableComplex, class EdgeProfile = Edge_profile<GeometricSimplifiableComplex>>
-class Skeleton_blocker_contractor : private skbl::Dummy_complex_visitor<
+class Skeleton_blocker_contractor : private skeleton_blocker::Dummy_complex_visitor<
 typename GeometricSimplifiableComplex::Vertex_handle> {
   GeometricSimplifiableComplex& complex_;
 
  public:
   typedef typename GeometricSimplifiableComplex::Graph_vertex Graph_vertex;
   typedef typename GeometricSimplifiableComplex::Vertex_handle Vertex_handle;
-  typedef typename GeometricSimplifiableComplex::Simplex_handle Simplex_handle;
-  typedef typename GeometricSimplifiableComplex::Simplex_handle_iterator Simplex_handle_iterator;
-
-
-
+  typedef typename GeometricSimplifiableComplex::Simplex Simplex;
   typedef typename GeometricSimplifiableComplex::Root_vertex_handle Root_vertex_handle;
-
   typedef typename GeometricSimplifiableComplex::Graph_edge Graph_edge;
   typedef typename GeometricSimplifiableComplex::Edge_handle Edge_handle;
   typedef typename GeometricSimplifiableComplex::Point Point;
@@ -535,14 +530,14 @@ typename GeometricSimplifiableComplex::Vertex_handle> {
    * All the edges that passes through the blocker may be edge-contractible
    * again and are thus reinserted in the heap.
    */
-  void on_delete_blocker(const Simplex_handle * blocker) override {
+  void on_delete_blocker(const Simplex * blocker) override {
     // we go for all pairs xy that belongs to the blocker
     // note that such pairs xy are necessarily edges of the complex
     // by definition of a blocker
 
     // todo uniqument utile pour la link condition
     // laisser a l'utilisateur ? booleen update_heap_on_removed_blocker?
-    Simplex_handle blocker_copy(*blocker);
+    Simplex blocker_copy(*blocker);
     for (auto x = blocker_copy.begin(); x != blocker_copy.end(); ++x) {
       for (auto y = x; ++y != blocker_copy.end();) {
         auto edge_descr(complex_[std::make_pair(*x, *y)]);