Merge branch 'develop' of cgogn:~kraemer/CGoGN into develop

include/Algo/Geometry/normal.hpp

@@ -115,11 +115,12 @@ typename V_ATT::DATA_TYPE vertexBorderNormal(typename PFP::MAP& map, Vertex v, c
 	typedef typename V_ATT::DATA_TYPE VEC3 ;
 
 	VEC3 N(0) ;
+
 	std::vector<Dart> faces;
-	CellMarker<typename PFP::MAP, FACE> f(map);
+	faces.reserve(16);
+	map.foreach_dart_of_vertex(v, [&] (Dart d) { faces.push_back(d); });
 
-	FunctorStore fs(faces);
-	map.foreach_dart_of_vertex(v, fs);
+	CellMarker<typename PFP::MAP, FACE> f(map);
 
 	for(std::vector<Dart>::iterator it = faces.begin() ; it != faces.end() ; ++it)
 	{

include/Algo/ImplicitHierarchicalMesh/ihm3.h

@@ -379,24 +379,23 @@ public:
 
 	virtual void next(Dart& d) const ;
 
-	virtual bool foreach_dart_of_vertex(Dart d, FunctorType& f, unsigned int thread = 0) const ;
+	void foreach_dart_of_vertex(Dart d, std::function<void (Dart)> f, unsigned int thread = 0) const ;
 
-	virtual bool foreach_dart_of_edge(Dart d, FunctorType& f, unsigned int thread = 0) const ;
+	void foreach_dart_of_edge(Dart d, std::function<void (Dart)> f, unsigned int thread = 0) const ;
 
-	bool foreach_dart_of_oriented_face(Dart d, FunctorType& f, unsigned int thread = 0) const;
-	virtual bool foreach_dart_of_face(Dart d, FunctorType& f, unsigned int thread = 0) const ;
+	void foreach_dart_of_oriented_face(Dart d, std::function<void (Dart)> f, unsigned int thread = 0) const;
+	void foreach_dart_of_face(Dart d, std::function<void (Dart)> f, unsigned int thread = 0) const ;
 
-	bool foreach_dart_of_oriented_volume(Dart d, FunctorType& f, unsigned int thread = 0) const;
-	virtual bool foreach_dart_of_volume(Dart d, FunctorType& f, unsigned int thread = 0) const ;
+	void foreach_dart_of_oriented_volume(Dart d, std::function<void (Dart)> f, unsigned int thread = 0) const;
+	void foreach_dart_of_volume(Dart d, std::function<void (Dart)> f, unsigned int thread = 0) const ;
 
-	virtual bool foreach_dart_of_cc(Dart d, FunctorType& f, unsigned int thread = 0) const ;
+	void foreach_dart_of_cc(Dart d, std::function<void (Dart)> f, unsigned int thread = 0) const ;
 
+	void foreach_dart_of_vertex2(Dart d, std::function<void (Dart)> f, unsigned int thread = 0) const;
 
-	virtual bool foreach_dart_of_vertex2(Dart d, FunctorType& f, unsigned int thread = 0) const;
+	void foreach_dart_of_edge2(Dart d, std::function<void (Dart)> f, unsigned int thread = 0) const;
 
-	virtual bool foreach_dart_of_edge2(Dart d, FunctorType& f, unsigned int thread = 0) const;
-
-	virtual bool foreach_dart_of_face2(Dart d, FunctorType& f, unsigned int thread = 0) const;
+	void foreach_dart_of_face2(Dart d, std::function<void (Dart)> f, unsigned int thread = 0) const;
 	//@}
 
     template <unsigned int ORBIT>

include/Algo/ImplicitHierarchicalMesh/ihm3.hpp

@@ -224,17 +224,16 @@ inline void ImplicitHierarchicalMap3::next(Dart& d) const
 	} while(d != Map3::end() && m_dartLevel[d] > m_curLevel) ;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_vertex(Dart d, FunctorType& f, unsigned int thread) const
+inline void ImplicitHierarchicalMap3::foreach_dart_of_vertex(Dart d, std::function<void (Dart)> f, unsigned int thread) const
 {
 	DartMarkerStore<Map3> mv(*this, thread);	// Lock a marker
-	bool found = false;					// Last functor return value
 
 	std::vector<Dart> darts;	// Darts that are traversed
 	darts.reserve(256);
 	darts.push_back(d);			// Start with the dart d
 	mv.mark(d);
 
-	for(unsigned int i = 0; !found && i < darts.size(); ++i)
+	for(unsigned int i = 0; i < darts.size(); ++i)
 	{
 		// add phi21 and phi23 successor if they are not marked yet
 		Dart d2 = phi2(darts[i]);
@@ -252,126 +251,110 @@ inline bool ImplicitHierarchicalMap3::foreach_dart_of_vertex(Dart d, FunctorType
 			mv.mark(d23);
 		}
 
-		found = f(darts[i]);
+		f(darts[i]);
 	}
-	return found;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_edge(Dart d, FunctorType& f, unsigned int thread) const
+inline void ImplicitHierarchicalMap3::foreach_dart_of_edge(Dart d, std::function<void (Dart)> f, unsigned int thread) const
 {
 	Dart dNext = d;
 	do {
-		if (foreach_dart_of_edge2(dNext, f, thread))
-			return true;
+		foreach_dart_of_edge2(dNext, f, thread);
 		dNext = alpha2(dNext);
 	} while (dNext != d);
-	return false;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_oriented_face(Dart d, FunctorType& f, unsigned int /*thread*/) const
+inline void ImplicitHierarchicalMap3::foreach_dart_of_oriented_face(Dart d, std::function<void (Dart)> f, unsigned int /*thread*/) const
 {
 	Dart dNext = d ;
 	do
 	{
-		if (f(dNext))
-			return true ;
+		f(dNext);
 		dNext = phi1(dNext) ;
 	} while (dNext != d) ;
-	return false ;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_face(Dart d, FunctorType& f, unsigned int thread) const
+inline void ImplicitHierarchicalMap3::foreach_dart_of_face(Dart d, std::function<void (Dart)> f, unsigned int thread) const
 {
-	return foreach_dart_of_oriented_face(d, f, thread) || foreach_dart_of_oriented_face(phi3(d), f, thread);
+	foreach_dart_of_oriented_face(d, f, thread);
+	foreach_dart_of_oriented_face(phi3(d), f, thread);
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_oriented_volume(Dart d, FunctorType& f, unsigned int thread) const
+inline void ImplicitHierarchicalMap3::foreach_dart_of_oriented_volume(Dart d, std::function<void (Dart)> f, unsigned int thread) const
 {
 	DartMarkerStore<Map3> mark(*this, thread);	// Lock a marker
-	bool found = false;				// Last functor return value
 
 	std::vector<Dart> visitedFaces;	// Faces that are traversed
 	visitedFaces.reserve(1024) ;
 	visitedFaces.push_back(d);		// Start with the face of d
 
 	// For every face added to the list
-	for(unsigned int i = 0; !found && i < visitedFaces.size(); ++i)
+	for(unsigned int i = 0; i < visitedFaces.size(); ++i)
 	{
 		if (!mark.isMarked(visitedFaces[i]))	// Face has not been visited yet
 		{
 			// Apply functor to the darts of the face
-			found = foreach_dart_of_oriented_face(visitedFaces[i], f);
+			foreach_dart_of_oriented_face(visitedFaces[i], f);
 
-			// If functor returns false then mark visited darts (current face)
+			// mark visited darts (current face)
 			// and add non visited adjacent faces to the list of face
-			if (!found)
+			Dart e = visitedFaces[i] ;
+			do
 			{
-				Dart e = visitedFaces[i] ;
-				do
-				{
-					mark.mark(e);				// Mark
-					Dart adj = phi2(e);			// Get adjacent face
-					if (!mark.isMarked(adj))
-						visitedFaces.push_back(adj);	// Add it
-					e = phi1(e);
-				} while(e != visitedFaces[i]);
-			}
+				mark.mark(e);				// Mark
+				Dart adj = phi2(e);			// Get adjacent face
+				if (!mark.isMarked(adj))
+					visitedFaces.push_back(adj);	// Add it
+				e = phi1(e);
+			} while(e != visitedFaces[i]);
 		}
 	}
-	return found;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_volume(Dart d, FunctorType& f, unsigned int thread) const
+inline void ImplicitHierarchicalMap3::foreach_dart_of_volume(Dart d, std::function<void (Dart)> f, unsigned int thread) const
 {
-	return foreach_dart_of_oriented_volume(d, f, thread) ;
+	foreach_dart_of_oriented_volume(d, f, thread) ;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_cc(Dart d, FunctorType& f, unsigned int thread) const
+inline void ImplicitHierarchicalMap3::foreach_dart_of_cc(Dart d, std::function<void (Dart)> f, unsigned int thread) const
 {
 	DartMarkerStore<Map3> mark(*this, thread);	// Lock a marker
-	bool found = false;				// Last functor return value
 
 	std::vector<Dart> visitedFaces;	// Faces that are traversed
 	visitedFaces.reserve(1024) ;
 	visitedFaces.push_back(d);		// Start with the face of d
 
 	// For every face added to the list
-	for(unsigned int i = 0; !found && i < visitedFaces.size(); ++i)
+	for(unsigned int i = 0; i < visitedFaces.size(); ++i)
 	{
 		if (!mark.isMarked(visitedFaces[i]))	// Face has not been visited yet
 		{
 			// Apply functor to the darts of the face
-			found = foreach_dart_of_face(visitedFaces[i], f);
+			foreach_dart_of_face(visitedFaces[i], f);
 
-			// If functor returns false then mark visited darts (current face)
+			// mark visited darts (current face)
 			// and add non visited adjacent faces to the list of face
-			if (!found)
+			Dart e = visitedFaces[i] ;
+			do
 			{
-				Dart e = visitedFaces[i] ;
-				do
-				{
-					mark.mark(e);				// Mark
-					Dart adj = phi2(e);			// Get adjacent face
-					if (!mark.isMarked(adj))
-						visitedFaces.push_back(adj);	// Add it
-					e = phi1(e);
-				} while(e != visitedFaces[i]);
-			}
+				mark.mark(e);				// Mark
+				Dart adj = phi2(e);			// Get adjacent face
+				if (!mark.isMarked(adj))
+					visitedFaces.push_back(adj);	// Add it
+				e = phi1(e);
+			} while(e != visitedFaces[i]);
 		}
 	}
-	return found;
-
 
-//	//return foreach_dart_of_oriented_volume(d, f) ;
+//	// foreach_dart_of_oriented_volume(d, f) ;
 //	DartMarkerStore mv(*this,thread);	// Lock a marker
-//	bool found = false;					// Last functor return value
 //
 //	std::vector<Dart> darts;	// Darts that are traversed
 //	darts.reserve(1024);
 //	darts.push_back(d);			// Start with the dart d
 //	mv.mark(d);
 //
-//	for(unsigned int i = 0; !found && i < darts.size(); ++i)
+//	for(unsigned int i = 0; i < darts.size(); ++i)
 //	{
 //		// add all successors if they are not marked yet
 //		Dart d2 = phi1(darts[i]); // turn in face
@@ -394,34 +377,29 @@ inline bool ImplicitHierarchicalMap3::foreach_dart_of_cc(Dart d, FunctorType& f,
 //			mv.mark(d4);
 //		}
 //
-//		found = f(darts[i]);
+//		f(darts[i]);
 //	}
-//	return found;
 }
 
-
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_vertex2(Dart d, FunctorType& f, unsigned int /*thread*/) const
+inline void ImplicitHierarchicalMap3::foreach_dart_of_vertex2(Dart d, std::function<void (Dart)> f, unsigned int /*thread*/) const
 {
 	Dart dNext = d;
 	do
 	{
-		if (f(dNext))
-			return true;
+		f(dNext);
 		dNext = phi2(phi_1(dNext));
- 	} while (dNext != d);
- 	return false;
+	} while (dNext != d);
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_edge2(Dart d, FunctorType& f, unsigned int /*thread*/) const
+inline void ImplicitHierarchicalMap3::foreach_dart_of_edge2(Dart d, std::function<void (Dart)> f, unsigned int /*thread*/) const
 {
-	if (f(d))
-		return true;
-	return f(phi2(d));
+	f(d);
+	f(phi2(d));
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_face2(Dart d, FunctorType& f, unsigned int thread) const
+inline void ImplicitHierarchicalMap3::foreach_dart_of_face2(Dart d, std::function<void (Dart)> f, unsigned int thread) const
 {
-	return foreach_dart_of_oriented_face(d,f,thread);
+	foreach_dart_of_oriented_face(d, f, thread);
 }
 
 /***************************************************

include/Algo/Import/importObjTex.hpp

@@ -1635,7 +1635,10 @@ bool OBJModel<PFP>::import( const std::string& filename, std::vector<std::string
 	
 	std::vector<unsigned int> localIndices;
 	localIndices.reserve(64*3);
-	FunctorInitEmb<typename PFP::MAP, VERTEX> fsetemb(m_map);
+
+	unsigned int vemb = EMBNULL;
+	auto fsetemb = [&] (Dart d) { m_map.template initDartEmbedding<VERTEX>(d, vemb); };
+//	FunctorInitEmb<typename PFP::MAP, VERTEX> fsetemb(m_map);
 
 	VertexAutoAttribute< NoTypeNameAttribute< std::vector<Dart> >, MAP_IMPL> vecDartsPerVertex(m_map, "incidents");
 	VertexAutoAttribute< NoTypeNameAttribute< std::vector<unsigned int> >, MAP_IMPL> vecNormIndPerVertex(m_map, "incidentsN");
@@ -1739,13 +1742,12 @@ bool OBJModel<PFP>::import( const std::string& filename, std::vector<std::string
 			
 			for (short j = 0; j < nbe; ++j)
 			{
-				unsigned int em = localIndices[3*j]-1;		// get embedding
-				fsetemb.changeEmb(em) ;
+				vemb = localIndices[3*j]-1;		// get embedding
 				m_map.template foreach_dart_of_orbit<PFP::MAP::VERTEX_OF_PARENT>(d, fsetemb);
 				mk.mark(d) ;								// mark on the fly to unmark on second loop
-				vecDartsPerVertex[em].push_back(d);		// store incident darts for fast adjacency reconstruction
-				vecTCIndPerVertex[em].push_back(localIndices[3*j+1]-1);
-				vecNormIndPerVertex[em].push_back(localIndices[3*j+2]-1);
+				vecDartsPerVertex[vemb].push_back(d);		// store incident darts for fast adjacency reconstruction
+				vecTCIndPerVertex[vemb].push_back(localIndices[3*j+1]-1);
+				vecNormIndPerVertex[vemb].push_back(localIndices[3*j+2]-1);
 				d = m_map.phi1(d);
 			}
 		}

include/Algo/MC/marchingcube.hpp

@@ -118,14 +118,17 @@ template< typename  DataType, template < typename D2 > class Windowing, typename
 Dart  MarchingCube<DataType, Windowing, PFP>::createTriEmb(unsigned int e1, unsigned int e2, unsigned int e3)
 {
 	L_DART d = m_map->newFace(3,false);
-		
-	FunctorSetEmb<typename PFP::MAP, VERTEX> fsetemb(*m_map, e1);
+
+	unsigned int vemb = e1;
+
+	auto fsetemb = [&] (Dart d) { m_map->template setDartEmbedding<VERTEX>(d, vemb); };
+
 	m_map->template foreach_dart_of_orbit<PFP::MAP::VERTEX_OF_PARENT>(d, fsetemb);
 	d = m_map->phi1(d);
-	fsetemb.changeEmb(e2);
+	vemb = e2;
 	m_map->template foreach_dart_of_orbit<PFP::MAP::VERTEX_OF_PARENT>(d, fsetemb);
 	d = m_map->phi1(d);
-	fsetemb.changeEmb(e3);
+	vemb = e3;
 	m_map->template foreach_dart_of_orbit<PFP::MAP::VERTEX_OF_PARENT>(d, fsetemb);
 	d = m_map->phi1(d);
 
@@ -136,7 +139,7 @@ template< typename  DataType, template < typename D2 > class Windowing, typename
 void MarchingCube<DataType, Windowing, PFP>::simpleMeshing()
 {
 	// create the mesh if needed
-	if (m_map==NULL)
+	if (m_map == NULL)
 	{
 		m_map = new L_MAP();
 	}

include/Topology/generic/functor.h

@@ -267,39 +267,39 @@ public:
 // Embedding Functors
 /********************************************************/
 
-template <typename MAP, unsigned int ORBIT>
-class FunctorSetEmb : public FunctorMap<MAP>
-{
-protected:
-	unsigned int emb;
-public:
-	FunctorSetEmb(MAP& map, unsigned int e) : FunctorMap<MAP>(map), emb(e)
-	{}
-	bool operator()(Dart d)
-	{
-		this->m_map.template setDartEmbedding<ORBIT>(d, emb);
-		return false;
-	}
-	void changeEmb(unsigned int e) { emb = e; }
-};
-
-template <typename MAP, unsigned int ORBIT>
-class FunctorInitEmb : public FunctorMap<MAP>
-{
-protected:
-	unsigned int emb;
-public:
-	FunctorInitEmb(MAP& map) : FunctorMap<MAP>(map), emb(EMBNULL)
-	{}
-	FunctorInitEmb(MAP& map, unsigned int e) : FunctorMap<MAP>(map), emb(e)
-	{}
-	bool operator()(Dart d)
-	{
-		this->m_map.template initDartEmbedding<ORBIT>(d, emb);
-		return false;
-	}
-	void changeEmb(unsigned int e) { emb = e; }
-};
+//template <typename MAP, unsigned int ORBIT>
+//class FunctorSetEmb : public FunctorMap<MAP>
+//{
+//protected:
+//	unsigned int emb;
+//public:
+//	FunctorSetEmb(MAP& map, unsigned int e) : FunctorMap<MAP>(map), emb(e)
+//	{}
+//	bool operator()(Dart d)
+//	{
+//		this->m_map.template setDartEmbedding<ORBIT>(d, emb);
+//		return false;
+//	}
+//	void changeEmb(unsigned int e) { emb = e; }
+//};
+
+//template <typename MAP, unsigned int ORBIT>
+//class FunctorInitEmb : public FunctorMap<MAP>
+//{
+//protected:
+//	unsigned int emb;
+//public:
+//	FunctorInitEmb(MAP& map) : FunctorMap<MAP>(map), emb(EMBNULL)
+//	{}
+//	FunctorInitEmb(MAP& map, unsigned int e) : FunctorMap<MAP>(map), emb(e)
+//	{}
+//	bool operator()(Dart d)
+//	{
+//		this->m_map.template initDartEmbedding<ORBIT>(d, emb);
+//		return false;
+//	}
+//	void changeEmb(unsigned int e) { emb = e; }
+//};
 
 // Search Functor: look for a given dart when applied
 /********************************************************/
@@ -332,18 +332,18 @@ public:
 // Functor Store: to store the traversed darts in a given vector
 /********************************************************/
 
-class FunctorStore : public FunctorType
-{
-protected:
-	std::vector<Dart>& m_vec;
-public:
-	FunctorStore(std::vector<Dart>& vec) : m_vec(vec) {}
-	bool operator()(Dart d)
-	{
-		m_vec.push_back(d);
-		return false;
-	}
-};
+//class FunctorStore : public FunctorType
+//{
+//protected:
+//	std::vector<Dart>& m_vec;
+//public:
+//	FunctorStore(std::vector<Dart>& vec) : m_vec(vec) {}
+//	bool operator()(Dart d)
+//	{
+//		m_vec.push_back(d);
+//		return false;
+//	}
+//};
 
 
 template <typename MAP>

include/Topology/generic/genericmap.h

@@ -174,20 +174,20 @@ public:
 	 *  @param f a functor obj
 	 */
 	template <unsigned int ORBIT>
-	bool foreach_dart_of_orbit(Dart d, FunctorType& f, unsigned int thread = 0) const ;
+	void foreach_dart_of_orbit(Dart d, std::function<void (Dart)> f, unsigned int thread = 0) const ;
 
-	virtual bool foreach_dart_of_vertex(Dart d, FunctorType& f, unsigned int thread = 0) const = 0 ;
-	virtual bool foreach_dart_of_edge(Dart d, FunctorType& f, unsigned int thread = 0) const = 0 ;
-	virtual bool foreach_dart_of_face(Dart /*d*/, FunctorType& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; return false; }
-	virtual bool foreach_dart_of_volume(Dart /*d*/, FunctorType& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; return false; }
-	virtual bool foreach_dart_of_cc(Dart /*d*/, FunctorType& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; return false; }
+	virtual void foreach_dart_of_vertex(Dart /*d*/, std::function<void (Dart)> /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
+	virtual void foreach_dart_of_edge(Dart /*d*/, std::function<void (Dart)> /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
+	virtual void foreach_dart_of_face(Dart /*d*/, std::function<void (Dart)> /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
+	virtual void foreach_dart_of_volume(Dart /*d*/, std::function<void (Dart)> /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
+	virtual void foreach_dart_of_cc(Dart /*d*/, std::function<void (Dart)> /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
 
-	virtual bool foreach_dart_of_vertex1(Dart /*d*/, FunctorType& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; return false; }
-	virtual bool foreach_dart_of_edge1(Dart /*d*/, FunctorType& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; return false; }
+	virtual void foreach_dart_of_vertex1(Dart /*d*/, std::function<void (Dart)> /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
+	virtual void foreach_dart_of_edge1(Dart /*d*/, std::function<void (Dart)> /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
 
-	virtual bool foreach_dart_of_vertex2(Dart /*d*/, FunctorType& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; return false; }
-	virtual bool foreach_dart_of_edge2(Dart /*d*/, FunctorType& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; return false; }
-	virtual bool foreach_dart_of_face2(Dart /*d*/, FunctorType& /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; return false; }
+	virtual void foreach_dart_of_vertex2(Dart /*d*/, std::function<void (Dart)> /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
+	virtual void foreach_dart_of_edge2(Dart /*d*/, std::function<void (Dart)> /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
+	virtual void foreach_dart_of_face2(Dart /*d*/, std::function<void (Dart)> /*f*/, unsigned int /*thread = 0*/) const { std::cerr << "Not implemented" << std::endl; }
 
 	/****************************************
 	 *         EMBEDDING MANAGEMENT         *

include/Topology/generic/genericmap.hpp

@@ -218,23 +218,22 @@ void GenericMap::addEmbedding()
  ****************************************/
 
 template <unsigned int ORBIT>
-bool GenericMap::foreach_dart_of_orbit(Dart d, FunctorType& f, unsigned int thread) const
+void GenericMap::foreach_dart_of_orbit(Dart d, std::function<void (Dart)> f, unsigned int thread) const
 {
 	switch(ORBIT)
 	{
-		case DART:		return f(d);
-		case VERTEX: 	return foreach_dart_of_vertex(d, f, thread);
-		case EDGE: 		return foreach_dart_of_edge(d, f, thread);
-		case FACE: 		return foreach_dart_of_face(d, f, thread);
-		case VOLUME: 	return foreach_dart_of_volume(d, f, thread);
-		case VERTEX1: 	return foreach_dart_of_vertex1(d, f, thread);
-		case EDGE1: 	return foreach_dart_of_edge1(d, f, thread);
-		case VERTEX2: 	return foreach_dart_of_vertex2(d, f, thread);
-		case EDGE2:		return foreach_dart_of_edge2(d, f, thread);
-		case FACE2:		return foreach_dart_of_face2(d, f, thread);
+		case DART:		f(d); break;
+		case VERTEX: 	foreach_dart_of_vertex(d, f, thread); break;
+		case EDGE: 		foreach_dart_of_edge(d, f, thread); break;
+		case FACE: 		foreach_dart_of_face(d, f, thread); break;
+		case VOLUME: 	foreach_dart_of_volume(d, f, thread); break;
+		case VERTEX1: 	foreach_dart_of_vertex1(d, f, thread); break;
+		case EDGE1: 	foreach_dart_of_edge1(d, f, thread); break;
+		case VERTEX2: 	foreach_dart_of_vertex2(d, f, thread); break;
+		case EDGE2:		foreach_dart_of_edge2(d, f, thread); break;
+		case FACE2:		foreach_dart_of_face2(d, f, thread); break;
 		default: 		assert(!"Cells of this dimension are not handled"); break;
 	}
-	return false;
 }
 
 /****************************************

include/Topology/generic/mapCommon.h

@@ -141,16 +141,16 @@ protected:
 	void boundaryUnmark(Dart d) ;
 
 	/**
-	 * mark an orbit of dart as belonging to boundary
+	 * mark an orbit as belonging to boundary
 	 */
-	template <unsigned int ORBIT, unsigned int DIM>
-	void boundaryMarkOrbit(Dart d) ;
+	template <unsigned int DIM, unsigned int ORBIT>
+	void boundaryMarkOrbit(Cell<ORBIT> c) ;
 
 	/**
-	 * unmark an orbit of dart from the boundary
+	 * unmark an orbit from the boundary
 	 */
-	template <unsigned int ORBIT, unsigned int DIM>
-	void boundaryUnmarkOrbit(Dart d) ;
+	template <unsigned int DIM, unsigned int ORBIT>
+	void boundaryUnmarkOrbit(Cell<ORBIT> c) ;
 
 	/**
 	 * clear all boundary markers

include/Topology/generic/mapCommon.hpp

@@ -41,21 +41,19 @@ unsigned int MapCommon<MAP_IMPL>::degree(Dart d) const
 	return fcount.getNb() ;
 }
 
-
 template <typename MAP_IMPL>
 template <unsigned int ORBIT>
 bool MapCommon<MAP_IMPL>::sameOrbit(Cell<ORBIT> c1, Cell<ORBIT> c2, unsigned int thread) const
 {
-	TraversorDartsOfOrbit< MapCommon<MAP_IMPL>, ORBIT> tradoo(*this,c1.dart,thread);
-	for (Dart x= tradoo.begin(); x!=tradoo.end();x=tradoo.next())
+	TraversorDartsOfOrbit<MapCommon<MAP_IMPL>, ORBIT> tradoo(*this, c1.dart, thread);
+	for (Dart x = tradoo.begin(); x != tradoo.end(); x = tradoo.next())
 	{
-		if (x==c2.dart)
+		if (x == c2.dart)
 			return true;
 	}