cpplint fixes - simplex_tree_from_file.cpp renamed simplex_tree_from_cliques_of_graph.cpp - #include "" vs #include <> for skeleton blockers

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

Former-commit-id: 1bd1ad535e4283bce35eeb31fa8d7896b9de474b

20 files changed, 966 insertions, 1033 deletions

diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
index 289819b5..792a7994 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker.h
@@ -19,23 +19,24 @@
   *    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 SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_H_
 
-#include "gudhi/Skeleton_blocker_complex.h"
-#include "gudhi/Skeleton_blocker_geometric_complex.h"
-#include "gudhi/Skeleton_blocker_simplifiable_complex.h"
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h"
+#ifndef SKELETON_BLOCKER_H_
+#define SKELETON_BLOCKER_H_
 
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h"
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h"
+#include <gudhi/Skeleton_blocker_complex.h>
+#include <gudhi/Skeleton_blocker_geometric_complex.h>
+#include <gudhi/Skeleton_blocker_simplifiable_complex.h>
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h>
 
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h>
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h>
 
-#include "gudhi/Utils.h"  // xxx
-
+#include <gudhi/Utils.h>  // xxx
 
 namespace Gudhi {
+
 namespace skbl {
+
 /** \defgroup skbl Skeleton-Blocker 
 
 \author David Salinas
@@ -243,11 +244,9 @@ their collaboration to write the two initial papers
 \verbatim  Contact: David Salinas,     david.salinas@inria.fr \endverbatim
 */
 /** @} */  // end defgroup
-}  // namespace skbl
-}  // namespace Gudhi
-
-
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_H_
 
+}  // namespace skbl
 
+}  // namespace Gudhi
 
+#endif  // SKELETON_BLOCKER_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h
index 829ab1e8..72bdf4c9 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h
@@ -19,10 +19,10 @@
  *    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 SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_COMPLEX_VISITOR_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_COMPLEX_VISITOR_H_
+#ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_COMPLEX_VISITOR_H_
+#define SKELETON_BLOCKER_SKELETON_BLOCKER_COMPLEX_VISITOR_H_
 
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h"
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h>
 
 namespace Gudhi {
 
@@ -59,7 +59,7 @@ class Skeleton_blocker_complex_visitor {
    * remove_edge(b,x)
    */
   virtual void on_swaped_edge(Vertex_handle a, Vertex_handle b,
-                              Vertex_handle x)=0;
+                              Vertex_handle x) = 0;
   virtual void on_add_blocker(
       const Skeleton_blocker_simplex<Vertex_handle>&) = 0;
   virtual void on_delete_blocker(
@@ -132,4 +132,4 @@ class Print_complex_visitor : public Skeleton_blocker_complex_visitor<
 
 }  // namespace Gudhi
 
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_COMPLEX_VISITOR_H_
+#endif  // SKELETON_BLOCKER_SKELETON_BLOCKER_COMPLEX_VISITOR_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h
index 17d58956..d39fa9f3 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h
@@ -19,10 +19,10 @@
  *    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 SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_LINK_SUPERIOR_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_LINK_SUPERIOR_H_
+#ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_LINK_SUPERIOR_H_
+#define SKELETON_BLOCKER_SKELETON_BLOCKER_LINK_SUPERIOR_H_
 
-#include "gudhi/Skeleton_blocker_link_complex.h"
+#include <gudhi/Skeleton_blocker_link_complex.h>
 
 namespace Gudhi {
 
@@ -74,4 +74,4 @@ class Skeleton_blocker_link_superior : public Skeleton_blocker_link_complex<
 
 }  // namespace Gudhi
 
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_LINK_SUPERIOR_H_
+#endif  // SKELETON_BLOCKER_SKELETON_BLOCKER_LINK_SUPERIOR_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h
index 6ad1fdd3..ec000986 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_off_io.h
@@ -19,15 +19,15 @@
  *    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 SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_OFF_IO_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_OFF_IO_H_
+#ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_OFF_IO_H_
+#define SKELETON_BLOCKER_SKELETON_BLOCKER_OFF_IO_H_
+
+#include <gudhi/Off_reader.h>
 
 #include <string>
 #include <vector>
 #include <map>
 
-#include "gudhi/Off_reader.h"
-
 namespace Gudhi {
 
 namespace skbl {
@@ -197,4 +197,4 @@ class Skeleton_blocker_off_writer {
 
 }  // namespace Gudhi
 
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_OFF_IO_H_
+#endif  // SKELETON_BLOCKER_SKELETON_BLOCKER_OFF_IO_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h
index d3a5b9d8..8508d9a5 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_geometric_traits.h
@@ -19,14 +19,14 @@
  *    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 SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_GEOMETRIC_TRAITS_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_GEOMETRIC_TRAITS_H_
+#ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_GEOMETRIC_TRAITS_H_
+#define SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_GEOMETRIC_TRAITS_H_
+
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h>
 
 #include <string>
 #include <sstream>
 
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h"
-
 namespace Gudhi {
 
 namespace skbl {
@@ -91,4 +91,4 @@ struct Skeleton_blocker_simple_geometric_traits :
 
 }  // namespace Gudhi
 
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_GEOMETRIC_TRAITS_H_
+#endif  // SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_GEOMETRIC_TRAITS_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h
index 52e454ea..10d552ec 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simple_traits.h
@@ -19,12 +19,13 @@
  *    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 SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_TRAITS_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_TRAITS_H_
+#ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_TRAITS_H_
+#define SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLE_TRAITS_H_
+
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h>
 
 #include <string>
 #include <sstream>
-#include "Skeleton_blocker_simplex.h"
 
 namespace Gudhi {
 
@@ -77,7 +78,7 @@ struct Skeleton_blocker_simple_traits {
         : vertex(val) {
     }
 
-    operator int() const { return (int)vertex; }
+    operator int() const { return static_cast<int>(vertex); }
 
     boost_vertex_handle vertex;
 
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h
index 0a2fcb9a..0d838d50 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h
@@ -20,8 +20,8 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLEX_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLEX_H_
+#ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLEX_H_
+#define SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLEX_H_
 
 #include <cassert>
 #include <iostream>
@@ -371,5 +371,4 @@ class Skeleton_blocker_simplex {
 
 }  // namespace Gudhi
 
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLEX_H_
-
+#endif  // SKELETON_BLOCKER_SKELETON_BLOCKER_SIMPLEX_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h
index 40e26c68..b33b9606 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h
@@ -20,16 +20,16 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SUB_COMPLEX_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SUB_COMPLEX_H_
+#ifndef SKELETON_BLOCKER_SKELETON_BLOCKER_SUB_COMPLEX_H_
+#define SKELETON_BLOCKER_SKELETON_BLOCKER_SUB_COMPLEX_H_
+
+#include <gudhi/Skeleton_blocker_complex.h>
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h>
+#include <gudhi/Utils.h>
 
 #include <map>
 #include <vector>
 
-#include "gudhi/Skeleton_blocker_complex.h"
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h"
-#include "gudhi/Utils.h"
-
 namespace Gudhi {
 
 namespace skbl {
@@ -75,7 +75,6 @@ class Skeleton_blocker_sub_complex : public ComplexType {
   typedef typename ComplexType::Root_simplex_handle Root_simplex_handle;
 
  protected:
-  
   /**
    * @brief Determines whether all proper faces of simplex 'sigma' belong to 'link1' \cup 'link2'
    * where 'link1' and 'link2' are subcomplexes of the same complex of type ComplexType
@@ -287,5 +286,5 @@ bool proper_faces_in_union(
 
 }  // namespace Gudhi
 
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SKELETON_BLOCKER_SUB_COMPLEX_H_
+#endif  // SKELETON_BLOCKER_SKELETON_BLOCKER_SUB_COMPLEX_H_
 
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Top_faces.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Top_faces.h
index 32538f38..eb970195 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Top_faces.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Top_faces.h
@@ -1,67 +1,70 @@
- /*    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-Mediterranee (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 TOP_FACES_H_
-#define TOP_FACES_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-Mediterranee (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 SKELETON_BLOCKER_INTERNAL_TOP_FACES_H_
+#define SKELETON_BLOCKER_INTERNAL_TOP_FACES_H_
 
 #include <list>
 #include <vector>
 #include <set>
 
+namespace Gudhi {
+
+namespace skbl {
+
 template<typename SimplexHandle>
-std::list<SimplexHandle> subfaces(SimplexHandle top_face){
-	std::list<SimplexHandle> res;
-	if(top_face.dimension()==-1) return res;
-	if(top_face.dimension()==0) {
-		res.push_back(top_face);
-		return res;
-	}
-	else{
-		auto first_vertex = top_face.first_vertex();
-		top_face.remove_vertex(first_vertex);
-		res = subfaces(top_face);
-		std::list<SimplexHandle> copy = res;
-		for(auto& simplex : copy){
-			simplex.add_vertex(first_vertex);
-		}
-		res.push_back(SimplexHandle(first_vertex));
-		res.splice(res.end(),copy);
-		return res;
-	}
+std::list<SimplexHandle> subfaces(SimplexHandle top_face) {
+  std::list<SimplexHandle> res;
+  if (top_face.dimension() == -1) return res;
+  if (top_face.dimension() == 0) {
+    res.push_back(top_face);
+    return res;
+  } else {
+    auto first_vertex = top_face.first_vertex();
+    top_face.remove_vertex(first_vertex);
+    res = subfaces(top_face);
+    std::list<SimplexHandle> copy = res;
+    for (auto& simplex : copy) {
+      simplex.add_vertex(first_vertex);
+    }
+    res.push_back(SimplexHandle(first_vertex));
+    res.splice(res.end(), copy);
+    return res;
+  }
 }
 
 /**
  * add all faces of top_face in simplices_per_dimension
  */
 template<typename SimplexHandle>
-void register_faces(
-		std::vector< std::set<SimplexHandle> >& simplices_per_dimension,
-		const SimplexHandle& top_face){
-	std::list<SimplexHandle> subfaces_list = subfaces(top_face);
-	for(auto& simplex : subfaces_list ){
-		simplices_per_dimension[simplex.dimension()].insert(simplex);
-	}
+void register_faces(std::vector< std::set<SimplexHandle> >& simplices_per_dimension,
+                    const SimplexHandle& top_face) {
+  std::list<SimplexHandle> subfaces_list = subfaces(top_face);
+  for (auto& simplex : subfaces_list) {
+    simplices_per_dimension[simplex.dimension()].insert(simplex);
+  }
 }
 
+}  // namespace skbl
 
+}  // namespace Gudhi
 
-
-#endif /* TOP_FACES_H_ */
+#endif  // SKELETON_BLOCKER_INTERNAL_TOP_FACES_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Trie.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Trie.h
index f2a443dc..aa0416ef 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Trie.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/internal/Trie.h
@@ -1,13 +1,10 @@
-/*
- * Trie.h
- *  Created on: Jan 29, 2015
- * This file is part of the Gudhi Library. The Gudhi library 
+/* 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)
+ *    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
@@ -25,8 +22,8 @@
  */
 
 
-#ifndef TRIE_H_
-#define TRIE_H_
+#ifndef SKELETON_BLOCKER_INTERNAL_TRIE_H_
+#define SKELETON_BLOCKER_INTERNAL_TRIE_H_
 
 #include <memory>
 #include <vector>
@@ -35,242 +32,237 @@
 
 namespace Gudhi {
 
-
 namespace skbl {
 
-
 template<typename SimplexHandle>
-struct Trie{
-	typedef SimplexHandle Simplex_handle;
-	typedef typename SimplexHandle::Vertex_handle Vertex_handle;
-
-	Vertex_handle v;
-	std::vector<std::shared_ptr<Trie> > childs;
-	//std::vector<std::unique_ptr<Trie> > childs; -> use of deleted function
-private:
-	const Trie* parent_;
-public:
-	Trie():parent_(0){}
-	Trie(Vertex_handle v_):v(v_),parent_(0){}
-
-	Trie(Vertex_handle v_,Trie* parent):v(v_),parent_(parent){}
-
-
-	bool operator==(const Trie& other) const{
-		return (v == other.v) ;
-	}
-
-	void add_child(Trie* child){
-		if(child){
-			std::shared_ptr<Trie> ptr_to_add(child);
-			childs.push_back(ptr_to_add);
-			child->parent_ = this;
-		}
-	}
-
-	typedef typename Simplex_handle::Simplex_vertex_const_iterator Simplex_vertex_const_iterator;
-
-
-	Trie* make_trie(Simplex_vertex_const_iterator s_it,Simplex_vertex_const_iterator s_end){
-		if(s_it == s_end) return 0;
-		else{
-			Trie* res = new Trie(*s_it);
-			Trie* child = make_trie(++s_it,s_end);
-			res->add_child(child);
-			return res;
-		}
-	}
-private:
-	//go down recursively in the tree while advancing the simplex iterator.
-	//when it reaches a leaf, it inserts the remaining that is not present
-	void add_simplex_helper(Simplex_vertex_const_iterator s_it,Simplex_vertex_const_iterator s_end){
-		assert(*s_it == v);
-		++s_it;
-		if(s_it==s_end) return ;
-		if(!is_leaf()){
-			for(auto child : childs){
-				if(child->v == *s_it)
-					return child->add_simplex_helper(s_it,s_end);
-			}
-			//s_it is not found and needs to be inserted
-		}
-		//not leaf -> remaining of s needs to be inserted
-		Trie* son_with_what_remains_of_s(make_trie(s_it,s_end));
-		add_child(son_with_what_remains_of_s);
-		return;
-	}
-
-	void maximal_faces_helper(std::vector<Simplex_handle>& res) const{
-		if(is_leaf()) res.push_back(simplex());
-		else
-			for(auto child : childs)
-				child->maximal_faces_helper(res);
-	}
-
-public:
-	/**
-	 * adds the simplex to the trie
-	 */
-	void add_simplex(const Simplex_handle& s){
-		if(s.empty()) return;
-		assert(v==s.first_vertex());
-		add_simplex_helper(s.begin(),s.end());
-	}
-
-	std::vector<Simplex_handle> maximal_faces() const{
-		std::vector<Simplex_handle> res;
-		maximal_faces_helper(res);
-		return res;
-	}
-
-	/**
-	 * Goes to the root in the trie to consitute simplex
-	 */
-	void add_vertices_up_to_the_root(Simplex_handle& res) const{
-		res.add_vertex(v);
-		if(parent_)
-			parent_->add_vertices_up_to_the_root(res);
-	}
-
-	Simplex_handle simplex() const{
-		Simplex_handle res;
-		add_vertices_up_to_the_root(res);
-		return res;
-	}
-
-	bool is_leaf() const{
-		return childs.empty();
-	}
-
-	bool is_root() const{
-		return parent_==0;
-	}
-
-	const Trie* parent() {
-		return parent_;
-	}
-
-	void remove_leaf() {
-		assert(is_leaf);
-		if(!is_root())
-			parent_->childs.erase(this);
-	}
-
-	/**
-	 * true iff the simplex corresponds to one node in the trie
-	 */
-	bool contains(const Simplex_handle& s) const{
-		Trie const* current = this;
-		if(s.empty()) return true;
-		if(current->v != s.first_vertex()) return false;
-		auto s_pos = s.begin();
-		++s_pos;
-		while(s_pos != s.end() && current != 0){
-			bool found = false;
-			for(const auto child : current->childs){
-				if(child->v == *s_pos) {
-					++s_pos;
-					current = child.get();
-					found = true;
-					break;
-				}
-			}
-			if(!found) return false;
-		}
-		return current!=0;
-	}
-
-	Trie* go_bottom_left(){
-		if(is_leaf())
-			return this;
-		else
-			return (*childs.begin())->go_bottom_left();
-	}
-
-	friend std::ostream& operator<<(std::ostream& stream, const Trie& trie){
-		stream<< "T( "<< trie.v<< " ";
-		for(auto t : trie.childs)
-			stream << *t ;
-		stream<<")";
-		return stream;
-	}
+struct Trie {
+  typedef SimplexHandle Simplex_handle;
+  typedef typename SimplexHandle::Vertex_handle Vertex_handle;
+
+  Vertex_handle v;
+  std::vector<std::shared_ptr<Trie> > childs;
+  // std::vector<std::unique_ptr<Trie> > childs; -> use of deleted function
+ private:
+  const Trie* parent_;
+
+ public:
+  Trie() : parent_(0) { }
+
+  Trie(Vertex_handle v_) : v(v_), parent_(0) { }
+
+  Trie(Vertex_handle v_, Trie* parent) : v(v_), parent_(parent) { }
+
+  bool operator==(const Trie& other) const {
+    return (v == other.v);
+  }
+
+  void add_child(Trie* child) {
+    if (child) {
+      std::shared_ptr<Trie> ptr_to_add(child);
+      childs.push_back(ptr_to_add);
+      child->parent_ = this;
+    }
+  }
+
+  typedef typename Simplex_handle::Simplex_vertex_const_iterator Simplex_vertex_const_iterator;
+
+  Trie* make_trie(Simplex_vertex_const_iterator s_it, Simplex_vertex_const_iterator s_end) {
+    if (s_it == s_end) {
+      return 0;
+    } else {
+      Trie* res = new Trie(*s_it);
+      Trie* child = make_trie(++s_it, s_end);
+      res->add_child(child);
+      return res;
+    }
+  }
+
+ private:
+  // go down recursively in the tree while advancing the simplex iterator.
+  // when it reaches a leaf, it inserts the remaining that is not present
+  void add_simplex_helper(Simplex_vertex_const_iterator s_it, Simplex_vertex_const_iterator s_end) {
+    assert(*s_it == v);
+    ++s_it;
+    if (s_it == s_end) return;
+    if (!is_leaf()) {
+      for (auto child : childs) {
+        if (child->v == *s_it)
+          return child->add_simplex_helper(s_it, s_end);
+      }
+      // s_it is not found and needs to be inserted
+    }
+    // not leaf -> remaining of s needs to be inserted
+    Trie * son_with_what_remains_of_s(make_trie(s_it, s_end));
+    add_child(son_with_what_remains_of_s);
+    return;
+  }
+
+  void maximal_faces_helper(std::vector<Simplex_handle>& res) const {
+    if (is_leaf()) res.push_back(simplex());
+    else
+      for (auto child : childs)
+        child->maximal_faces_helper(res);
+  }
+
+ public:
+  /**
+   * adds the simplex to the trie
+   */
+  void add_simplex(const Simplex_handle& s) {
+    if (s.empty()) return;
+    assert(v == s.first_vertex());
+    add_simplex_helper(s.begin(), s.end());
+  }
+
+  std::vector<Simplex_handle> maximal_faces() const {
+    std::vector<Simplex_handle> res;
+    maximal_faces_helper(res);
+    return res;
+  }
+
+  /**
+   * Goes to the root in the trie to consitute simplex
+   */
+  void add_vertices_up_to_the_root(Simplex_handle& res) const {
+    res.add_vertex(v);
+    if (parent_)
+      parent_->add_vertices_up_to_the_root(res);
+  }
+
+  Simplex_handle simplex() const {
+    Simplex_handle res;
+    add_vertices_up_to_the_root(res);
+    return res;
+  }
+
+  bool is_leaf() const {
+    return childs.empty();
+  }
+
+  bool is_root() const {
+    return parent_ == 0;
+  }
+
+  const Trie* parent() {
+    return parent_;
+  }
+
+  void remove_leaf() {
+    assert(is_leaf);
+    if (!is_root())
+      parent_->childs.erase(this);
+  }
+
+  /**
+   * true iff the simplex corresponds to one node in the trie
+   */
+  bool contains(const Simplex_handle& s) const {
+    Trie const* current = this;
+    if (s.empty()) return true;
+    if (current->v != s.first_vertex()) return false;
+    auto s_pos = s.begin();
+    ++s_pos;
+    while (s_pos != s.end() && current != 0) {
+      bool found = false;
+      for (const auto child : current->childs) {
+        if (child->v == *s_pos) {
+          ++s_pos;
+          current = child.get();
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+    return current != 0;
+  }
+
+  Trie* go_bottom_left() {
+    if (is_leaf())
+      return this;
+    else
+      return (*childs.begin())->go_bottom_left();
+  }
+
+  friend std::ostream& operator<<(std::ostream& stream, const Trie& trie) {
+    stream << "T( " << trie.v << " ";
+    for (auto t : trie.childs)
+      stream << *t;
+    stream << ")";
+    return stream;
+  }
 };
 
-
 template<typename SimplexHandle>
-struct Tries{
-	typedef typename SimplexHandle::Vertex_handle Vertex_handle;
-	typedef SimplexHandle Simplex_handle;
-
-	typedef Trie<Simplex_handle> STrie;
-
-
-	template<typename SimpleHandleOutputIterator>
-	Tries(unsigned num_vertices,SimpleHandleOutputIterator simplex_begin, SimpleHandleOutputIterator simplex_end):
-	cofaces_(num_vertices,0){
-		for (auto i = 0u; i < num_vertices; ++i)
-			cofaces_[i] = new STrie(Vertex_handle(i));
-		for (auto s_it = simplex_begin; s_it != simplex_end; ++s_it) {
-			if (s_it->dimension() >= 1)
-				cofaces_[s_it->first_vertex()]->add_simplex(*s_it);
-		}
-	}
-
-	~Tries(){
-		for(STrie* t : cofaces_)
-			delete t;
-	}
-
-	//return a simplex that consists in all u such uv is an edge and u>v
-	Simplex_handle positive_neighbors(Vertex_handle v) const{
-		Simplex_handle res;
-		for(auto child : cofaces_[v]->childs)
-			res.add_vertex(child->v);
-		return res;
-	}
-
-	bool contains(const Simplex_handle& s) const{
-		auto first_v = s.first_vertex();
-		return cofaces_[first_v]->contains(s);
-	}
-
-	friend std::ostream& operator<<(std::ostream& stream, const Tries& tries){
-		for(auto trie : tries.cofaces_)
-			stream<<*trie<<std::endl;
-		return stream;
-	}
-
-	//init_next_dimension must be called first
-	std::vector<Simplex_handle> next_dimension_simplices() const{
-		std::vector<Simplex_handle> res;
-		while(!to_see_.empty() && to_see_.front()->simplex().dimension()==current_dimension_){
-			res.emplace_back(to_see_.front()->simplex());
-			for(auto child : to_see_.front()->childs)
-				to_see_.push_back(child.get());
-			to_see_.pop_front();
-		}
-		++current_dimension_;
-		return res;
-	}
-
-	void init_next_dimension() const{
-		for(auto trie : cofaces_)
-			to_see_.push_back(trie);
-	}
-
-private:
-	mutable std::deque<STrie*> to_see_;
-	mutable unsigned current_dimension_=0;
-
-
-	std::vector<STrie*> cofaces_;
-
+struct Tries {
+  typedef typename SimplexHandle::Vertex_handle Vertex_handle;
+  typedef SimplexHandle Simplex_handle;
+
+  typedef Trie<Simplex_handle> STrie;
+
+  template<typename SimpleHandleOutputIterator>
+  Tries(unsigned num_vertices, SimpleHandleOutputIterator simplex_begin, SimpleHandleOutputIterator simplex_end) :
+      cofaces_(num_vertices, 0) {
+    for (auto i = 0u; i < num_vertices; ++i)
+      cofaces_[i] = new STrie(Vertex_handle(i));
+    for (auto s_it = simplex_begin; s_it != simplex_end; ++s_it) {
+      if (s_it->dimension() >= 1)
+        cofaces_[s_it->first_vertex()]->add_simplex(*s_it);
+    }
+  }
+
+  ~Tries() {
+    for (STrie* t : cofaces_)
+      delete t;
+  }
+
+  // return a simplex that consists in all u such uv is an edge and u>v
+
+  Simplex_handle positive_neighbors(Vertex_handle v) const {
+    Simplex_handle res;
+    for (auto child : cofaces_[v]->childs)
+      res.add_vertex(child->v);
+    return res;
+  }
+
+  bool contains(const Simplex_handle& s) const {
+    auto first_v = s.first_vertex();
+    return cofaces_[first_v]->contains(s);
+  }
+
+  friend std::ostream& operator<<(std::ostream& stream, const Tries& tries) {
+    for (auto trie : tries.cofaces_)
+      stream << *trie << std::endl;
+    return stream;
+  }
+
+  // init_next_dimension must be called first
+
+  std::vector<Simplex_handle> next_dimension_simplices() const {
+    std::vector<Simplex_handle> res;
+    while (!to_see_.empty() && to_see_.front()->simplex().dimension() == current_dimension_) {
+      res.emplace_back(to_see_.front()->simplex());
+      for (auto child : to_see_.front()->childs)
+        to_see_.push_back(child.get());
+      to_see_.pop_front();
+    }
+    ++current_dimension_;
+    return res;
+  }
+
+  void init_next_dimension() const {
+    for (auto trie : cofaces_)
+      to_see_.push_back(trie);
+  }
+
+ private:
+  mutable std::deque<STrie*> to_see_;
+  mutable unsigned current_dimension_ = 0;
+  std::vector<STrie*> cofaces_;
 };
 
+}  // namespace skbl
 
+}  // namespace Gudhi
 
-}
-
-}
-
-#endif /* TRIE_H_ */
+#endif  // SKELETON_BLOCKER_INTERNAL_TRIE_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h
index f6f2c955..56a20a24 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h
@@ -1,134 +1,131 @@
- /*    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-Mediterranee (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 GUDHI_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_
-#define GUDHI_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_
-
-#include "boost/iterator/iterator_facade.hpp"
-
-namespace Gudhi{
+/*    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-Mediterranee (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 SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_
+#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_
+
+#include <boost/iterator/iterator_facade.hpp>
+
+namespace Gudhi {
 
 namespace skbl {
 
 /**
  * @brief Iterator through the blockers of a vertex.
-  */
+ */
 // ReturnType = const Simplex_handle* or Simplex_handle*
 // MapIteratorType = BlockerMapConstIterator or BlockerMapIterator
+
 template<typename MapIteratorType, typename ReturnType>
 class Blocker_iterator_internal : public boost::iterator_facade<
-  Blocker_iterator_internal<MapIteratorType,ReturnType>,
-  ReturnType,
-  boost::forward_traversal_tag,
-  ReturnType
-  >{
-private:
-	MapIteratorType current_position;
-	MapIteratorType end_of_map;
-public:
-
-	Blocker_iterator_internal():current_position(){}
-
-	Blocker_iterator_internal(MapIteratorType position,MapIteratorType end_of_map_ ):
-		current_position(position), end_of_map(end_of_map_)
-	{	}
-
-	bool equal(const Blocker_iterator_internal& other) const{
-		return current_position == other.current_position;
-	}
-
-	void increment(){
-		goto_next_blocker();
-	}
-
-	ReturnType dereference() const	{
-		return(current_position->second);
-	}
-
-private:
-	/**
-	 * Let the current pair be (v,sigma) where v is a vertex and sigma is a blocker.
-	 * If v is not the first vertex of sigma then we already have seen sigma as a blocker
-	 * and we look for the next one.
-	 */
-	void goto_next_blocker(){
-		do {
-			++current_position;
-		} while (!(current_position == end_of_map) && !first_time_blocker_is_seen());
-	}
-
-	bool first_time_blocker_is_seen() const{
-		return current_position->first  == current_position->second->first_vertex();
-	}
+Blocker_iterator_internal<MapIteratorType, ReturnType>,
+ReturnType,
+boost::forward_traversal_tag,
+ReturnType
+> {
+ private:
+  MapIteratorType current_position;
+  MapIteratorType end_of_map;
+
+ public:
+  Blocker_iterator_internal() : current_position() { }
+
+  Blocker_iterator_internal(MapIteratorType position, MapIteratorType end_of_map_) :
+      current_position(position), end_of_map(end_of_map_) { }
+
+  bool equal(const Blocker_iterator_internal& other) const {
+    return current_position == other.current_position;
+  }
+
+  void increment() {
+    goto_next_blocker();
+  }
+
+  ReturnType dereference() const {
+    return (current_position->second);
+  }
+
+ private:
+  /**
+   * Let the current pair be (v,sigma) where v is a vertex and sigma is a blocker.
+   * If v is not the first vertex of sigma then we already have seen sigma as a blocker
+   * and we look for the next one.
+   */
+  void goto_next_blocker() {
+    do {
+      ++current_position;
+    } while (!(current_position == end_of_map) && !first_time_blocker_is_seen());
+  }
+
+  bool first_time_blocker_is_seen() const {
+    return current_position->first == current_position->second->first_vertex();
+  }
 };
 
-
-
 /**
  * @brief Iterator through the blockers of a vertex
  */
 // ReturnType = const Simplex_handle* or Simplex_handle*
 // MapIteratorType = BlockerMapConstIterator or BlockerMapIterator
+
 template<typename MapIteratorType, typename ReturnType>
 class Blocker_iterator_around_vertex_internal : public boost::iterator_facade<
-	Blocker_iterator_around_vertex_internal<MapIteratorType,ReturnType>,
-	ReturnType,
-	boost::forward_traversal_tag,
-	ReturnType
->{
-private:
-	MapIteratorType current_position_;
-public:
-
-	Blocker_iterator_around_vertex_internal():current_position_(){}
-
-	Blocker_iterator_around_vertex_internal(MapIteratorType position):
-		current_position_(position)
-	{}
-
-	Blocker_iterator_around_vertex_internal& operator=(Blocker_iterator_around_vertex_internal other){
-		this->current_position_ = other.current_position_;
-		return *this;
-	}
-
-	bool equal(const Blocker_iterator_around_vertex_internal& other) const{
-		return current_position_ == other.current_position_;
-	}
-
-	void increment(){
-		current_position_++;
-	}
-
-	ReturnType dereference() const{
-		return(current_position_->second);
-	}
-
-
-	MapIteratorType current_position(){
-		return this->current_position_;
-	}
+Blocker_iterator_around_vertex_internal<MapIteratorType, ReturnType>,
+ReturnType,
+boost::forward_traversal_tag,
+ReturnType
+> {
+ private:
+  MapIteratorType current_position_;
+
+ public:
+  Blocker_iterator_around_vertex_internal() : current_position_() { }
+
+  Blocker_iterator_around_vertex_internal(MapIteratorType position) :
+      current_position_(position) { }
+
+  Blocker_iterator_around_vertex_internal& operator=(Blocker_iterator_around_vertex_internal other) {
+    this->current_position_ = other.current_position_;
+    return *this;
+  }
+
+  bool equal(const Blocker_iterator_around_vertex_internal& other) const {
+    return current_position_ == other.current_position_;
+  }
+
+  void increment() {
+    current_position_++;
+  }
+
+  ReturnType dereference() const {
+    return (current_position_->second);
+  }
+
+  MapIteratorType current_position() {
+    return this->current_position_;
+  }
 };
 
-}
+}  // namespace skbl
 
-} // namespace GUDHI
+}  // namespace Gudhi
 
-#endif /* GUDHI_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_ */
+#endif  // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_BLOCKERS_ITERATORS_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h
index 0be6c74d..ef4c7970 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h
@@ -1,167 +1,144 @@
- /*    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-Mediterranee (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 GUDHI_SKELETON_BLOCKERS_ITERATORS_EDGES_H_
-#define GUDHI_SKELETON_BLOCKERS_ITERATORS_EDGES_H_
-
-#include "boost/iterator/iterator_facade.hpp"
-
-
-namespace Gudhi{
+/*    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-Mediterranee (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 SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_EDGES_ITERATORS_H_
+#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_EDGES_ITERATORS_H_
+
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/graph/adjacency_list.hpp>
+
+#include <utility>  // for pair<>
+
+namespace Gudhi {
 
 namespace skbl {
 
 template<typename SkeletonBlockerComplex>
-class Edge_around_vertex_iterator :
- public boost::iterator_facade < Edge_around_vertex_iterator<SkeletonBlockerComplex>
-		, typename SkeletonBlockerComplex::Edge_handle const
-		, boost::forward_traversal_tag
-		, typename SkeletonBlockerComplex::Edge_handle const
-		>
-{
-	friend class boost::iterator_core_access;
-
-	typedef SkeletonBlockerComplex Complex;
-	typedef typename Complex::boost_adjacency_iterator boost_adjacency_iterator;
-	typedef typename Complex::Vertex_handle Vertex_handle;
-	typedef typename Complex::Edge_handle Edge_handle;
-
-private:
-
-	const Complex* complex;
-	Vertex_handle v;
-
-	boost_adjacency_iterator current_;
-	boost_adjacency_iterator end_;
-
-public:
-
-	Edge_around_vertex_iterator():complex(NULL){
-	}
-
-	Edge_around_vertex_iterator(const Complex* complex_,Vertex_handle v_):
-		complex(complex_),
-		v(v_)
-	{
-		tie(current_,end_) = adjacent_vertices(v.vertex, complex->skeleton);
-	}
-
-	/**
-	 * returns an iterator to the end
-	 */
-	Edge_around_vertex_iterator(const Complex* complex_,Vertex_handle v_,int end):
-		complex(complex_),
-		v(v_)
-	{
-		tie(current_,end_) = adjacent_vertices(v.vertex, complex->skeleton);
-		set_end();
-	}
-
-	bool equal(const Edge_around_vertex_iterator& other) const{
-		return (complex== other.complex) && (v == other.v) && (current_ == other.current_) && (end_ == other.end_);
-	}
-
-	void increment(){
-		if(current_ != end_)
-			++current_;
-	}
-
-	Edge_handle dereference() const{
-		return *(*complex)[std::make_pair(v,static_cast<Vertex_handle>(*current_))];
-	}
-
-private:
-	//remove this ugly hack
-	void set_end(){
-		current_ = end_;
-	}
+class Edge_around_vertex_iterator : public boost::iterator_facade <Edge_around_vertex_iterator<SkeletonBlockerComplex>
+, typename SkeletonBlockerComplex::Edge_handle const, boost::forward_traversal_tag
+, typename SkeletonBlockerComplex::Edge_handle const> {
+  friend class boost::iterator_core_access;
+
+  typedef SkeletonBlockerComplex Complex;
+  typedef typename Complex::boost_adjacency_iterator boost_adjacency_iterator;
+  typedef typename Complex::Vertex_handle Vertex_handle;
+  typedef typename Complex::Edge_handle Edge_handle;
+
+ private:
+  const Complex* complex;
+  Vertex_handle v;
+
+  boost_adjacency_iterator current_;
+  boost_adjacency_iterator end_;
+
+ public:
+  Edge_around_vertex_iterator() : complex(NULL) { }
+
+  Edge_around_vertex_iterator(const Complex* complex_, Vertex_handle v_) :
+      complex(complex_),
+      v(v_) {
+    tie(current_, end_) = adjacent_vertices(v.vertex, complex->skeleton);
+  }
+
+  /**
+   * returns an iterator to the end
+   */
+  Edge_around_vertex_iterator(const Complex* complex_, Vertex_handle v_, int end) :
+      complex(complex_),
+      v(v_) {
+    tie(current_, end_) = adjacent_vertices(v.vertex, complex->skeleton);
+    set_end();
+  }
+
+  bool equal(const Edge_around_vertex_iterator& other) const {
+    return (complex == other.complex) && (v == other.v) && (current_ == other.current_) && (end_ == other.end_);
+  }
+
+  void increment() {
+    if (current_ != end_)
+      ++current_;
+  }
+
+  Edge_handle dereference() const {
+    return *(*complex)[std::make_pair(v, static_cast<Vertex_handle> (*current_))];
+  }
+
+ private:
+  // remove this ugly hack
+  void set_end() {
+    current_ = end_;
+  }
 };
 
-
-
 /**
  *@brief Iterator on the edges of a simplicial complex.
  *
  */
 template<typename SkeletonBlockerComplex>
-class Edge_iterator :
-public boost::iterator_facade < Edge_iterator<SkeletonBlockerComplex>
+class Edge_iterator : public boost::iterator_facade <Edge_iterator<SkeletonBlockerComplex>
 , typename SkeletonBlockerComplex::Edge_handle const
 , boost::forward_traversal_tag
-, typename SkeletonBlockerComplex::Edge_handle const
->
-
-{
-	friend class boost::iterator_core_access;
-public:
-	typedef SkeletonBlockerComplex Complex;
-	typedef typename Complex::boost_edge_iterator boost_edge_iterator;
-	typedef typename Complex::Edge_handle Edge_handle;
-
-
-	const Complex* complex;
-	std::pair<boost_edge_iterator,boost_edge_iterator> edge_iterator ;
-
-	Edge_iterator():complex(NULL){
-	}
-
-	Edge_iterator(const SkeletonBlockerComplex* complex_):
-		complex(complex_),
-		edge_iterator(boost::edges(complex_->skeleton))
-	{
-	}
-
-	/**
-	 * return an iterator to the end
-	 */
-	Edge_iterator(const SkeletonBlockerComplex* complex_,int end):
-		complex(complex_),
-		edge_iterator(boost::edges(complex_->skeleton))
-	{
-		edge_iterator.first = edge_iterator.second;
-	}
-
-
-	bool equal(const Edge_iterator& other) const{
-		return (complex == other.complex) && (edge_iterator == other.edge_iterator);
-	}
-
-	void increment(){
-		if(edge_iterator.first != edge_iterator.second){
-			++(edge_iterator.first);
-		}
-	}
-
-	Edge_handle dereference() const{
-		return(*(edge_iterator.first));
-	}
+, typename SkeletonBlockerComplex::Edge_handle const> {
+  friend class boost::iterator_core_access;
+
+ public:
+  typedef SkeletonBlockerComplex Complex;
+  typedef typename Complex::boost_edge_iterator boost_edge_iterator;
+  typedef typename Complex::Edge_handle Edge_handle;
+
+  const Complex* complex;
+  std::pair<boost_edge_iterator, boost_edge_iterator> edge_iterator;
+
+  Edge_iterator() : complex(NULL) { }
+
+  Edge_iterator(const SkeletonBlockerComplex* complex_) :
+      complex(complex_),
+      edge_iterator(boost::edges(complex_->skeleton)) { }
+
+  /**
+   * return an iterator to the end
+   */
+  Edge_iterator(const SkeletonBlockerComplex* complex_, int end) :
+      complex(complex_),
+      edge_iterator(boost::edges(complex_->skeleton)) {
+    edge_iterator.first = edge_iterator.second;
+  }
+
+  bool equal(const Edge_iterator& other) const {
+    return (complex == other.complex) && (edge_iterator == other.edge_iterator);
+  }
+
+  void increment() {
+    if (edge_iterator.first != edge_iterator.second) {
+      ++(edge_iterator.first);
+    }
+  }
+
+  Edge_handle dereference() const {
+    return (*(edge_iterator.first));
+  }
 };
 
+}  // namespace skbl
 
+}  // namespace Gudhi
 
-}
-
-} // namespace GUDHI
-
-
-#endif /* GUDHI_SKELETON_BLOCKERS_ITERATORS_EDGES_H_ */
-
-
+#endif  // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_EDGES_ITERATORS_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h
index 20a94734..cc3ed276 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h
@@ -19,17 +19,14 @@
   *    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 GUDHI_SKELETON_BLOCKERS_ITERATORS_H_
-#define GUDHI_SKELETON_BLOCKERS_ITERATORS_H_
 
+#ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_ITERATORS_H_
+#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_ITERATORS_H_
 
-#include "Skeleton_blockers_vertices_iterators.h"
-#include "Skeleton_blockers_edges_iterators.h"
-#include "Skeleton_blockers_blockers_iterators.h"
-#include "Skeleton_blockers_triangles_iterators.h"
-#include "Skeleton_blockers_simplices_iterators.h"
+#include <gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h>
+#include <gudhi/Skeleton_blocker/iterators/Skeleton_blockers_edges_iterators.h>
+#include <gudhi/Skeleton_blocker/iterators/Skeleton_blockers_blockers_iterators.h>
+#include <gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h>
+#include <gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h>
 
-
-
-
-#endif /* GUDHI_SKELETON_BLOCKERS_ITERATORS_H_ */
+#endif  // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_ITERATORS_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h
index f9d4d072..4d71b3f5 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_simplices_iterators.h
@@ -19,20 +19,20 @@
  *    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 GUDHI_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_
-#define GUDHI_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_
+#ifndef SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_
+#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_
 
-#include "boost/iterator/iterator_facade.hpp"
+#include <gudhi/Skeleton_blocker_link_complex.h>
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h>
+#include <gudhi/Skeleton_blocker/internal/Trie.h>
+#include <gudhi/Utils.h>
+
+#include <boost/iterator/iterator_facade.hpp>
 
 #include <memory>
 #include <list>
 #include <iostream>
 
-#include "gudhi/Skeleton_blocker_link_complex.h"
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h"
-#include "gudhi/Skeleton_blocker/internal/Trie.h"
-#include "gudhi/Utils.h"
-
 namespace Gudhi {
 
 namespace skbl {
@@ -68,7 +68,7 @@ public boost::iterator_facade < Simplex_around_vertex_iterator<SkeletonBlockerCo
   Vertex_handle v;
   std::shared_ptr<Link> link_v;
   std::shared_ptr<Trie> trie;
-  std::list<Trie*> nodes_to_be_seen; // todo deque
+  std::list<Trie*> nodes_to_be_seen;  // todo deque
 
  public:
   Simplex_around_vertex_iterator() : complex(0) {}
@@ -159,7 +159,7 @@ public boost::iterator_facade < Simplex_around_vertex_iterator<SkeletonBlockerCo
 
     bool both_non_empty = !nodes_to_be_seen.empty() && !other.nodes_to_be_seen.empty();
 
-    if (!both_non_empty) return false; //one is empty the other is not
+    if (!both_non_empty) return false;  // one is empty the other is not
 
     bool same_node = (**(nodes_to_be_seen.begin()) == **(other.nodes_to_be_seen.begin()));
     return same_node;
@@ -174,7 +174,6 @@ public boost::iterator_facade < Simplex_around_vertex_iterator<SkeletonBlockerCo
     for (auto childs : first_node->childs) {
       nodes_to_be_seen.push_back(childs.get());
     }
-
   }
 
   Simplex_handle dereference() const {
@@ -309,4 +308,4 @@ public boost::iterator_facade < Simplex_iterator<SkeletonBlockerComplex>
 
 }  // namespace Gudhi
 
-#endif  // GUDHI_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_
+#endif  // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_SIMPLICES_ITERATORS_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h
index e137d1ea..28f5805d 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_triangles_iterators.h
@@ -1,117 +1,108 @@
- /*    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-Mediterranee (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 GUDHI_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_
-#define GUDHI_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_
-
-#include "boost/iterator/iterator_facade.hpp"
+/*    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-Mediterranee (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 SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_
+#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_
+
+#include <boost/iterator/iterator_facade.hpp>
 #include <memory>
 
-namespace Gudhi{
+namespace Gudhi {
 
 namespace skbl {
 
-//////////////////////////////////////////////////////////////////////
 /**
  * \brief Iterator over the triangles that are
  * adjacent to a vertex of the simplicial complex.
  * \remark Will be removed soon -> dont look
  */
-template<typename Complex,typename LinkType>
+template<typename Complex, typename LinkType>
 class Triangle_around_vertex_iterator : public boost::iterator_facade
-< Triangle_around_vertex_iterator <Complex,LinkType>
+< Triangle_around_vertex_iterator <Complex, LinkType>
 , typename Complex::Simplex_handle const
 , boost::forward_traversal_tag
-, typename Complex::Simplex_handle const
->
-{
-	friend class boost::iterator_core_access;
-	template<typename T> friend class Triangle_iterator;
-private:
-	typedef typename LinkType::Vertex_handle Vertex_handle;
-	typedef typename LinkType::Root_vertex_handle Root_vertex_handle;
-	typedef typename LinkType::Simplex_handle Simplex_handle;
-	typedef typename Complex::Complex_edge_iterator Complex_edge_iterator_;
-
-	const Complex* complex_;
-	Vertex_handle v_;
-	std::shared_ptr<LinkType> link_;
-	Complex_edge_iterator_ current_edge_;
-	bool is_end_;
-public:
-	Triangle_around_vertex_iterator(const Complex* complex,Vertex_handle v):
-		complex_(complex),v_(v),link_(new LinkType(*complex,v_)),
-		current_edge_(link_->edge_range().begin()),
-		is_end_(current_edge_ == link_->edge_range().end()){
-	}
-
-	/**
-	 * @brief ugly hack to get an iterator to the end
-	 */
-	Triangle_around_vertex_iterator(const Complex* complex,Vertex_handle v,bool is_end):
-		complex_(complex),v_(v),link_(0),is_end_(true){
-	}
-
-	/**
-	 * @brief ugly hack to get an iterator to the end
-	 */
-	Triangle_around_vertex_iterator():
-		complex_(0),v_(-1),link_(0),is_end_(true){
-	}
-
-
-	Triangle_around_vertex_iterator(const Triangle_around_vertex_iterator& other){
-		v_ = other.v_;
-		complex_ = other.complex_;
-		is_end_ = other.is_end_;
-
-		if(!is_end_){
-			link_ = other.link_;
-			current_edge_= other.current_edge_;
-		}
-	}
-
-	bool equal(const Triangle_around_vertex_iterator& other) const{
-		return (complex_==other.complex_) && ((finished() &&other.finished()) || current_edge_ == other.current_edge_);
-	}
-
-	Simplex_handle dereference() const{
-		Root_vertex_handle v1 = (*link_)[*current_edge_].first();
-		Root_vertex_handle v2 = (*link_)[*current_edge_].second();
-		return Simplex_handle(v_,*(complex_->get_address(v1)),*(complex_->get_address(v2)));
-	}
-
-	void increment(){
-		++current_edge_;
-	}
-
-private:
-	bool finished() const{
-		return is_end_ || (current_edge_ == link_->edge_range().end());
-	}
-
+, typename Complex::Simplex_handle const> {
+  friend class boost::iterator_core_access;
+  template<typename T> friend class Triangle_iterator;
+ private:
+  typedef typename LinkType::Vertex_handle Vertex_handle;
+  typedef typename LinkType::Root_vertex_handle Root_vertex_handle;
+  typedef typename LinkType::Simplex_handle Simplex_handle;
+  typedef typename Complex::Complex_edge_iterator Complex_edge_iterator_;
+
+  const Complex* complex_;
+  Vertex_handle v_;
+  std::shared_ptr<LinkType> link_;
+  Complex_edge_iterator_ current_edge_;
+  bool is_end_;
+
+ public:
+  Triangle_around_vertex_iterator(const Complex* complex, Vertex_handle v) :
+      complex_(complex), v_(v), link_(new LinkType(*complex, v_)),
+      current_edge_(link_->edge_range().begin()),
+      is_end_(current_edge_ == link_->edge_range().end()) { }
+
+  /**
+   * @brief ugly hack to get an iterator to the end
+   */
+  Triangle_around_vertex_iterator(const Complex* complex, Vertex_handle v, bool is_end) :
+      complex_(complex), v_(v), link_(0), is_end_(true) { }
+
+  /**
+   * @brief ugly hack to get an iterator to the end
+   */
+  Triangle_around_vertex_iterator() :
+      complex_(0), v_(-1), link_(0), is_end_(true) { }
+
+  Triangle_around_vertex_iterator(const Triangle_around_vertex_iterator& other) {
+    v_ = other.v_;
+    complex_ = other.complex_;
+    is_end_ = other.is_end_;
+
+    if (!is_end_) {
+      link_ = other.link_;
+      current_edge_ = other.current_edge_;
+    }
+  }
+
+  bool equal(const Triangle_around_vertex_iterator& other) const {
+    return (complex_ == other.complex_) && ((finished() && other.finished()) || current_edge_ == other.current_edge_);
+  }
+
+  Simplex_handle dereference() const {
+    Root_vertex_handle v1 = (*link_)[*current_edge_].first();
+    Root_vertex_handle v2 = (*link_)[*current_edge_].second();
+    return Simplex_handle(v_, *(complex_->get_address(v1)), *(complex_->get_address(v2)));
+  }
+
+  void increment() {
+    ++current_edge_;
+  }
+
+ private:
+  bool finished() const {
+    return is_end_ || (current_edge_ == link_->edge_range().end());
+  }
 };
 
-
-
 /**
  * \brief Iterator over the triangles of the
  * simplicial complex.
@@ -119,121 +110,111 @@ private:
  *
  */
 template<typename SkeletonBlockerComplex>
-class Triangle_iterator :
-		public boost::iterator_facade<
-		Triangle_iterator <SkeletonBlockerComplex>,
-		typename SkeletonBlockerComplex::Simplex_handle const
-		, boost::forward_traversal_tag
-		, typename SkeletonBlockerComplex::Simplex_handle const
-		>
-{
-	friend class boost::iterator_core_access;
-private:
-	typedef typename SkeletonBlockerComplex::Vertex_handle Vertex_handle;
-	typedef typename SkeletonBlockerComplex::Root_vertex_handle Root_vertex_handle;
-	typedef typename SkeletonBlockerComplex::Simplex_handle Simplex_handle;
-	typedef typename SkeletonBlockerComplex::Superior_triangle_around_vertex_iterator STAVI;
-	typedef typename SkeletonBlockerComplex::Complex_vertex_iterator Complex_vertex_iterator;
-
-	const SkeletonBlockerComplex* complex_;
-	Complex_vertex_iterator current_vertex_;
-	STAVI current_triangle_;
-	bool is_end_;
-public:
-
-	/*
-	 * @remark  assume that the complex is non-empty
-	 */
-	Triangle_iterator(const SkeletonBlockerComplex* complex):
-		complex_(complex),
-		current_vertex_(complex->vertex_range().begin()),
-		current_triangle_(complex,*current_vertex_), // xxx this line is problematic is the complex is empty
-		is_end_(false){
-
-		assert(!complex->empty());
-		gotoFirstTriangle();
-	}
-
-private:
-	//goto to the first triangle or to the end if none
-	void gotoFirstTriangle(){
-		if(!is_finished() && current_triangle_.finished()){
-			goto_next_vertex();
-		}
-	}
-public:
-
-	/**
-	 * @brief ugly hack to get an iterator to the end
-	 * @remark  assume that the complex is non-empty
-	 */
-	Triangle_iterator(const SkeletonBlockerComplex* complex,bool is_end):
-		complex_(complex),
-		current_vertex_(complex->vertex_range().end()),
-		current_triangle_(), // xxx this line is problematic is the complex is empty
-		is_end_(true){
-	}
-
-
-	Triangle_iterator& operator=(const Triangle_iterator & other){
-		complex_ = other.complex_;
-		Complex_vertex_iterator current_vertex_;
-		STAVI current_triangle_;
-		return *this;
-	}
-
-
-	bool equal(const Triangle_iterator& other) const{
-		bool both_are_finished = is_finished() && other.is_finished();
-		bool both_arent_finished = !is_finished() && !other.is_finished();
-		// if the two iterators are not finished, they must have the same state
-		return (complex_==other.complex_) &&
-				(both_are_finished	||
-						( (both_arent_finished) && current_vertex_ == other.current_vertex_ && current_triangle_ == other.current_triangle_));
-
-	}
-
-	Simplex_handle dereference() const{
-		return *current_triangle_;
-	}
-
-private:
-
-	// goto the next vertex that has a triangle pending or the
-	// end vertex iterator if none exists
-	void goto_next_vertex(){
-		assert(current_triangle_.finished()); //we mush have consume all triangles passing through the vertex
-		assert(!is_finished()); // we must not be done
-
-		++current_vertex_;
-
-		if(!is_finished()){
-			current_triangle_ = STAVI(complex_, *current_vertex_);
-			if(current_triangle_.finished())
-				goto_next_vertex();
-		}
-	}
-public:
-	void increment(){
-		if(!current_triangle_.finished()){
-			++current_triangle_; // problem here
-			if(current_triangle_.finished())
-				goto_next_vertex();
-		}
-		else{
-			assert(!is_finished());
-			goto_next_vertex();
-		}
-	}
-
-private:
-	bool is_finished() const{
-		return is_end_ || current_vertex_ == complex_->vertex_range().end();
-	}
+class Triangle_iterator : public boost::iterator_facade<
+Triangle_iterator <SkeletonBlockerComplex>,
+typename SkeletonBlockerComplex::Simplex_handle const
+, boost::forward_traversal_tag
+, typename SkeletonBlockerComplex::Simplex_handle const> {
+  friend class boost::iterator_core_access;
+ private:
+  typedef typename SkeletonBlockerComplex::Vertex_handle Vertex_handle;
+  typedef typename SkeletonBlockerComplex::Root_vertex_handle Root_vertex_handle;
+  typedef typename SkeletonBlockerComplex::Simplex_handle Simplex_handle;
+  typedef typename SkeletonBlockerComplex::Superior_triangle_around_vertex_iterator STAVI;
+  typedef typename SkeletonBlockerComplex::Complex_vertex_iterator Complex_vertex_iterator;
+
+  const SkeletonBlockerComplex* complex_;
+  Complex_vertex_iterator current_vertex_;
+  STAVI current_triangle_;
+  bool is_end_;
+
+ public:
+  /*
+   * @remark  assume that the complex is non-empty
+   */
+  Triangle_iterator(const SkeletonBlockerComplex* complex) :
+      complex_(complex),
+      current_vertex_(complex->vertex_range().begin()),
+      current_triangle_(complex, *current_vertex_),  // xxx this line is problematic is the complex is empty
+      is_end_(false) {
+    assert(!complex->empty());
+    gotoFirstTriangle();
+  }
+
+ private:
+  // goto to the first triangle or to the end if none
+  void gotoFirstTriangle() {
+    if (!is_finished() && current_triangle_.finished()) {
+      goto_next_vertex();
+    }
+  }
+
+ public:
+  /**
+   * @brief ugly hack to get an iterator to the end
+   * @remark  assume that the complex is non-empty
+   */
+  Triangle_iterator(const SkeletonBlockerComplex* complex, bool is_end) :
+      complex_(complex),
+      current_vertex_(complex->vertex_range().end()),
+      current_triangle_(),  // xxx this line is problematic is the complex is empty
+      is_end_(true) { }
+
+  Triangle_iterator& operator=(const Triangle_iterator & other) {
+    complex_ = other.complex_;
+    Complex_vertex_iterator current_vertex_;
+    STAVI current_triangle_;
+    return *this;
+  }
+
+  bool equal(const Triangle_iterator& other) const {
+    bool both_are_finished = is_finished() && other.is_finished();
+    bool both_arent_finished = !is_finished() && !other.is_finished();
+    // if the two iterators are not finished, they must have the same state
+    return (complex_ == other.complex_) && (both_are_finished || ((both_arent_finished) &&
+        current_vertex_ == other.current_vertex_ && current_triangle_ == other.current_triangle_));
+  }
+
+  Simplex_handle dereference() const {
+    return *current_triangle_;
+  }
+
+ private:
+  // goto the next vertex that has a triangle pending or the
+  // end vertex iterator if none exists
+  void goto_next_vertex() {
+    assert(current_triangle_.finished());  // we mush have consume all triangles passing through the vertex
+    assert(!is_finished());  // we must not be done
+
+    ++current_vertex_;
+
+    if (!is_finished()) {
+      current_triangle_ = STAVI(complex_, *current_vertex_);
+      if (current_triangle_.finished())
+        goto_next_vertex();
+    }
+  }
+
+ public:
+  void increment() {
+    if (!current_triangle_.finished()) {
+      ++current_triangle_;  // problem here
+      if (current_triangle_.finished())
+        goto_next_vertex();
+    } else {
+      assert(!is_finished());
+      goto_next_vertex();
+    }
+  }
+
+ private:
+  bool is_finished() const {
+    return is_end_ || current_vertex_ == complex_->vertex_range().end();
+  }
 };
 
-}
+}  // namespace skbl
 
-} // namespace GUDHI
+}  // namespace Gudhi
 
-#endif /* GUDHI_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_ */
+#endif  // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_TRIANGLES_ITERATORS_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h
index a9d4e373..14ae136a 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker/iterators/Skeleton_blockers_vertices_iterators.h
@@ -1,31 +1,32 @@
- /*    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-Mediterranee (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 GUDHI_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_
-#define GUDHI_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_
-
-#include "boost/iterator/iterator_facade.hpp"
-
-
-namespace Gudhi{
+/*    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-Mediterranee (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 SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_
+#define SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_
+
+#include <boost/iterator/iterator_facade.hpp>
+
+#include <utility>  // for pair<>
+
+namespace Gudhi {
 
 namespace skbl {
 
@@ -35,148 +36,137 @@ namespace skbl {
  *@remark Incrementation increases Vertex_handle.
  */
 template<typename SkeletonBlockerComplex>
-class Vertex_iterator : public boost::iterator_facade
-< Vertex_iterator <SkeletonBlockerComplex>
-  , typename SkeletonBlockerComplex::Vertex_handle const
-  , boost::forward_traversal_tag
-  , typename SkeletonBlockerComplex::Vertex_handle const
-  >
-{
-	friend class boost::iterator_core_access;
-
-	typedef typename SkeletonBlockerComplex::boost_vertex_iterator boost_vertex_iterator;
-	typedef typename SkeletonBlockerComplex::Vertex_handle Vertex_handle;
-private:
-	const SkeletonBlockerComplex* complex;
-	std::pair<boost_vertex_iterator,boost_vertex_iterator> vertexIterator;
-
-
-public:
-	Vertex_iterator():complex(NULL){
-	}
-
-	Vertex_iterator(const SkeletonBlockerComplex* complex_):
-		complex(complex_),
-		vertexIterator(vertices(complex_->skeleton)){
-		if(!finished() && !is_active()) {
-			goto_next_valid();
-		}
-	}
-
-	/**
-	 * return an iterator to the end.
-	 */
-	Vertex_iterator(const SkeletonBlockerComplex* complex_,int end):
-		complex(complex_),vertexIterator(vertices(complex_->skeleton)){
-		vertexIterator.first = vertexIterator.second ;
-	}
-
-public:
-	void increment () {goto_next_valid();}
-	Vertex_handle  dereference() const	{
-		return(Vertex_handle(*(vertexIterator.first)));
-	}
-
-	bool equal(const Vertex_iterator& other) const{
-		return vertexIterator == other.vertexIterator &&  complex == other.complex;
-	}
-
-	bool operator<(const Vertex_iterator& other) const{
-		return dereference()<other.dereference();
-	}
-
-private:
-	bool finished() const{
-		return vertexIterator.first == vertexIterator.second;
-	}
-
-	void goto_next_valid(){
-		++vertexIterator.first;
-		if(!finished() && !is_active()){
-			goto_next_valid();
-		}
-	}
-
-	bool is_active() const{
-		return ((*complex)[Vertex_handle(*vertexIterator.first)]).is_active();
-	}
-
+class Vertex_iterator : public boost::iterator_facade< Vertex_iterator <SkeletonBlockerComplex>
+, typename SkeletonBlockerComplex::Vertex_handle const
+, boost::forward_traversal_tag
+, typename SkeletonBlockerComplex::Vertex_handle const> {
+  friend class boost::iterator_core_access;
+
+  typedef typename SkeletonBlockerComplex::boost_vertex_iterator boost_vertex_iterator;
+  typedef typename SkeletonBlockerComplex::Vertex_handle Vertex_handle;
+ private:
+  const SkeletonBlockerComplex* complex;
+  std::pair<boost_vertex_iterator, boost_vertex_iterator> vertexIterator;
+
+
+ public:
+  Vertex_iterator() : complex(NULL) { }
+
+  Vertex_iterator(const SkeletonBlockerComplex* complex_) :
+      complex(complex_),
+      vertexIterator(vertices(complex_->skeleton)) {
+    if (!finished() && !is_active()) {
+      goto_next_valid();
+    }
+  }
+
+  /**
+   * return an iterator to the end.
+   */
+  Vertex_iterator(const SkeletonBlockerComplex* complex_, int end) :
+      complex(complex_), vertexIterator(vertices(complex_->skeleton)) {
+    vertexIterator.first = vertexIterator.second;
+  }
+
+ public:
+  void increment() {
+    goto_next_valid();
+  }
+
+  Vertex_handle dereference() const {
+    return (Vertex_handle(*(vertexIterator.first)));
+  }
+
+  bool equal(const Vertex_iterator& other) const {
+    return vertexIterator == other.vertexIterator && complex == other.complex;
+  }
+
+  bool operator<(const Vertex_iterator& other) const {
+    return dereference() < other.dereference();
+  }
+
+ private:
+  bool finished() const {
+    return vertexIterator.first == vertexIterator.second;
+  }
+
+  void goto_next_valid() {
+    ++vertexIterator.first;
+    if (!finished() && !is_active()) {
+      goto_next_valid();
+    }
+  }
+
+  bool is_active() const {
+    return ((*complex)[Vertex_handle(*vertexIterator.first)]).is_active();
+  }
 };
 
-
-
-
 template<typename SkeletonBlockerComplex>
-class Neighbors_vertices_iterator
-: public boost::iterator_facade < Neighbors_vertices_iterator<SkeletonBlockerComplex>
-  , typename SkeletonBlockerComplex::Vertex_handle const
-  , boost::forward_traversal_tag
-  , typename SkeletonBlockerComplex::Vertex_handle const
-  >
-{
-	friend class boost::iterator_core_access;
-
-	typedef SkeletonBlockerComplex Complex;
-	typedef typename Complex::boost_adjacency_iterator boost_adjacency_iterator;
-	typedef typename Complex::Vertex_handle Vertex_handle;
-	typedef typename Complex::Edge_handle Edge_handle;
-
-private:
-
-	const Complex* complex;
-	Vertex_handle v;
-
-	boost_adjacency_iterator current_;
-	boost_adjacency_iterator end_;
-
-public:
-	//	boost_adjacency_iterator ai, ai_end;
-	//	for (tie(ai, ai_end) = adjacent_vertices(v.vertex, skeleton); ai != ai_end; ++ai){
-
-	Neighbors_vertices_iterator():complex(NULL){
-	}
-
-	Neighbors_vertices_iterator(const Complex* complex_,Vertex_handle v_):
-		complex(complex_),
-		v(v_){
-		tie(current_,end_) = adjacent_vertices(v.vertex, complex->skeleton);
-	}
-
-	/**
-	 * returns an iterator to the end
-	 */
-	Neighbors_vertices_iterator(const Complex* complex_,Vertex_handle v_,int end):
-		complex(complex_),
-		v(v_){
-		tie(current_,end_) = adjacent_vertices(v.vertex, complex->skeleton);
-		set_end();
-	}
-
-
-	void increment () {
-		if(current_ != end_)
-			++current_;
-	}
-
-	Vertex_handle  dereference() const	{
-		return(Vertex_handle(*current_));
-	}
-
-	bool equal(const Neighbors_vertices_iterator& other) const{
-		return (complex== other.complex) && (v == other.v) && (current_ == other.current_) && (end_ == other.end_);
-	}
-
-private:
-	//todo remove this ugly hack
-	void set_end(){
-		current_ = end_;
-	}
+class Neighbors_vertices_iterator: public boost::iterator_facade < Neighbors_vertices_iterator<SkeletonBlockerComplex>
+, typename SkeletonBlockerComplex::Vertex_handle const
+, boost::forward_traversal_tag
+, typename SkeletonBlockerComplex::Vertex_handle const> {
+  friend class boost::iterator_core_access;
+
+  typedef SkeletonBlockerComplex Complex;
+  typedef typename Complex::boost_adjacency_iterator boost_adjacency_iterator;
+  typedef typename Complex::Vertex_handle Vertex_handle;
+  typedef typename Complex::Edge_handle Edge_handle;
+
+ private:
+  const Complex* complex;
+  Vertex_handle v;
+
+  boost_adjacency_iterator current_;
+  boost_adjacency_iterator end_;
+
+ public:
+  // boost_adjacency_iterator ai, ai_end;
+  // for (tie(ai, ai_end) = adjacent_vertices(v.vertex, skeleton); ai != ai_end; ++ai) {
+
+  Neighbors_vertices_iterator() : complex(NULL) { }
+
+  Neighbors_vertices_iterator(const Complex* complex_, Vertex_handle v_) :
+      complex(complex_),
+      v(v_) {
+    tie(current_, end_) = adjacent_vertices(v.vertex, complex->skeleton);
+  }
+
+  /**
+   * returns an iterator to the end
+   */
+  Neighbors_vertices_iterator(const Complex* complex_, Vertex_handle v_, int end) :
+      complex(complex_),
+      v(v_) {
+    tie(current_, end_) = adjacent_vertices(v.vertex, complex->skeleton);
+    set_end();
+  }
+
+  void increment() {
+    if (current_ != end_)
+      ++current_;
+  }
+
+  Vertex_handle dereference() const {
+    return (Vertex_handle(*current_));
+  }
+
+  bool equal(const Neighbors_vertices_iterator& other) const {
+    return (complex == other.complex) && (v == other.v) && (current_ == other.current_) && (end_ == other.end_);
+  }
+
+ private:
+  // todo remove this ugly hack
+  void set_end() {
+    current_ = end_;
+  }
 };
 
-}
+}  // namespace skbl
 
-} // namespace GUDHI
+}  // namespace Gudhi
 
-#endif /* GUDHI_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_ */
+#endif  // SKELETON_BLOCKER_ITERATORS_SKELETON_BLOCKERS_VERTICES_ITERATORS_H_
 
 
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_complex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_complex.h
index 700830f2..07f371a2 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_complex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_complex.h
@@ -20,8 +20,20 @@
  *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_COMPLEX_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_COMPLEX_H_
+#ifndef SKELETON_BLOCKER_COMPLEX_H_
+#define SKELETON_BLOCKER_COMPLEX_H_
+
+#include <gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h>
+#include <gudhi/Skeleton_blocker_link_complex.h>
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h>
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h>
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h>
+
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h>
+#include <gudhi/Skeleton_blocker/internal/Top_faces.h>
+#include <gudhi/Skeleton_blocker/internal/Trie.h>
+
+#include <gudhi/Utils.h>
 
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/connected_components.hpp>
@@ -40,18 +52,6 @@
 #include <algorithm>
 #include <utility>
 
-#include "gudhi/Skeleton_blocker/iterators/Skeleton_blockers_iterators.h"
-#include "gudhi/Skeleton_blocker_link_complex.h"
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_link_superior.h"
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h"
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_simplex.h"
-
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_complex_visitor.h"
-#include "gudhi/Skeleton_blocker/internal/Top_faces.h"
-#include "gudhi/Skeleton_blocker/internal/Trie.h"
-
-#include "gudhi/Utils.h"
-
 namespace Gudhi {
 
 namespace skbl {
@@ -1406,7 +1406,8 @@ class Skeleton_blocker_complex {
   Const_complex_blocker_around_vertex_iterator;
 
   typedef boost::iterator_range <Complex_blocker_around_vertex_iterator> Complex_blocker_around_vertex_range;
-  typedef boost::iterator_range <Const_complex_blocker_around_vertex_iterator> Const_complex_blocker_around_vertex_range;
+  typedef boost::iterator_range <Const_complex_blocker_around_vertex_iterator>
+  Const_complex_blocker_around_vertex_range;
 
  public:
   /**
@@ -1514,7 +1515,7 @@ class Skeleton_blocker_complex {
  * return the total number of simplices
  */
 template<typename Complex, typename SimplexHandleIterator>
-Complex make_complex_from_top_faces(SimplexHandleIterator simplex_begin, SimplexHandleIterator simplex_end, 
+Complex make_complex_from_top_faces(SimplexHandleIterator simplex_begin, SimplexHandleIterator simplex_end,
                                     bool is_flag_complex = false) {
   typedef typename Complex::Simplex_handle Simplex_handle;
   std::vector<Simplex_handle> simplices;
@@ -1531,6 +1532,4 @@ Complex make_complex_from_top_faces(SimplexHandleIterator simplex_begin, Simplex
 
 #include "Skeleton_blocker_simplifiable_complex.h"
 
-
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_COMPLEX_H_
-
+#endif  // SKELETON_BLOCKER_COMPLEX_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_geometric_complex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_geometric_complex.h
index 3eff1ba3..b8395251 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_geometric_complex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_geometric_complex.h
@@ -19,12 +19,12 @@
  *    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 SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_GEOMETRIC_COMPLEX_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_GEOMETRIC_COMPLEX_H_
+#ifndef SKELETON_BLOCKER_GEOMETRIC_COMPLEX_H_
+#define SKELETON_BLOCKER_GEOMETRIC_COMPLEX_H_
 
-#include "gudhi/Utils.h"
-#include "gudhi/Skeleton_blocker_complex.h"
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h"
+#include <gudhi/Utils.h>
+#include <gudhi/Skeleton_blocker_complex.h>
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h>
 
 namespace Gudhi {
 
@@ -221,4 +221,4 @@ SkeletonBlockerGeometricComplex make_complex_from_top_faces(
 
 }  // namespace Gudhi
 
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_GEOMETRIC_COMPLEX_H_
+#endif  // SKELETON_BLOCKER_GEOMETRIC_COMPLEX_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_link_complex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_link_complex.h
index 725ecce5..95d8fa97 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_link_complex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_link_complex.h
@@ -19,11 +19,11 @@
  *    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 SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_LINK_COMPLEX_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_LINK_COMPLEX_H_
+#ifndef SKELETON_BLOCKER_LINK_COMPLEX_H_
+#define SKELETON_BLOCKER_LINK_COMPLEX_H_
 
-#include "gudhi/Utils.h"
-#include "gudhi/Skeleton_blocker_complex.h"
+#include <gudhi/Utils.h>
+#include <gudhi/Skeleton_blocker_complex.h>
 
 namespace Gudhi {
 
@@ -297,4 +297,4 @@ class Skeleton_blocker_link_complex : public Skeleton_blocker_sub_complex<
 
 }  // namespace Gudhi
 
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_LINK_COMPLEX_H_
+#endif  // SKELETON_BLOCKER_LINK_COMPLEX_H_
diff --git a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_simplifiable_complex.h b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_simplifiable_complex.h
index 57e1daf0..705c78bb 100644
--- a/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_simplifiable_complex.h
+++ b/src/Skeleton_blocker/include/gudhi/Skeleton_blocker_simplifiable_complex.h
@@ -19,14 +19,14 @@
  *    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 SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SIMPLIFIABLE_COMPLEX_H_
-#define SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SIMPLIFIABLE_COMPLEX_H_
+#ifndef SKELETON_BLOCKER_SIMPLIFIABLE_COMPLEX_H_
+#define SKELETON_BLOCKER_SIMPLIFIABLE_COMPLEX_H_
 
 #include <list>
 #include <vector>
 #include <set>
 
-#include "gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h"
+#include <gudhi/Skeleton_blocker/Skeleton_blocker_sub_complex.h>
 
 namespace Gudhi {
 
@@ -447,4 +447,4 @@ Skeleton_blocker_complex<SkeletonBlockerDS>::notify_changed_edges(Vertex_handle
 
 }  // namespace Gudhi
 
-#endif  // SRC_SKELETON_BLOCKER_INCLUDE_GUDHI_SKELETON_BLOCKER_SIMPLIFIABLE_COMPLEX_H_
+#endif  // SKELETON_BLOCKER_SIMPLIFIABLE_COMPLEX_H_