Merge cgogn:~cgogn/CGoGN

Apps/Examples/volumeExplorer.cpp

@@ -31,6 +31,8 @@
 #include "Algo/Import/import.h"
 #include "Algo/Geometry/volume.h"
 
+#include "Utils/chrono.h"
+
 
 PFP::MAP myMap;
 VertexAttribute<PFP::VEC3> position ;
@@ -128,6 +130,82 @@ void MyQT::slider_released()
 }
 
 
+void MyQT::cb_Open()
+{
+	std::string filters("all (*.*);; trian (*.trian);; ctm (*.ctm);; off (*.off);; ply (*.ply)") ;
+	std::string filename = selectFile("Open Mesh", "", filters) ;
+	if (filename.empty())
+		return ;
+
+	myMap.clear(true);
+
+	std::vector<std::string> attrNames ;
+
+	size_t pos = filename.rfind(".");    // position of "." in filename
+	std::string extension = filename.substr(pos);
+
+	if(extension == std::string(".tet"))
+	{
+		if(!Algo::Import::importTet<PFP>(myMap,filename,attrNames))
+		{
+			CGoGNerr << "could not import " << filename << CGoGNendl ;
+			return;
+		}
+		else
+			position = myMap.getAttribute<PFP::VEC3, VERTEX>(attrNames[0]) ;
+	}
+
+	if(extension == std::string(".node"))
+	{
+		if(!Algo::Import::importMeshV<PFP>(myMap, filename, attrNames, Algo::Import::ImportVolumique::NODE))
+		{
+			std::cerr << "could not import " << filename << std::endl ;
+			return ;
+		}
+		else
+			position = myMap.getAttribute<PFP::VEC3,VERTEX>(attrNames[0]) ;
+	}
+
+
+	if(extension == std::string(".off"))
+	{
+		if(!Algo::Import::importMeshToExtrude<PFP>(myMap, filename, attrNames))
+		{
+			std::cerr << "could not import " << filename << std::endl ;
+			return ;
+		}
+		else
+		{
+			position = myMap.getAttribute<PFP::VEC3, VERTEX>(attrNames[0]) ;
+			myMap.closeMap();
+		}
+	}
+
+	color = myMap.addAttribute<PFP::VEC3, VOLUME>("color");
+
+	TraversorCell<PFP::MAP, VOLUME> tra(myMap);
+	float maxV = 0.0f;
+	for (Dart d = tra.begin(); d != tra.end(); d = tra.next())
+	{
+		float v = Algo::Geometry::tetrahedronVolume<PFP>(myMap, d, position);
+		color[d] = PFP::VEC3(v,0,0);
+		if (v>maxV)
+			maxV=v;
+	}
+	for (unsigned int i = color.begin(); i != color.end(); color.next(i))
+	{
+		color[i][0] /= maxV;
+		color[i][2] = 1.0f - color[i][0];
+	}
+
+	SelectorDartNoBoundary<PFP::MAP> nb(myMap);
+	m_topo_render->updateData<PFP>(myMap, position,  0.8f, 0.8f, 0.8f, nb);
+	m_explode_render->updateData<PFP>(myMap, position, color);
+
+	updateGL() ;
+}
+
+
 void MyQT::cb_initGL()
 {
 	// choose to use GL version 2
@@ -415,6 +493,24 @@ int main(int argc, char **argv)
 	dock.slider_explode_face->setValue(80);
 	sqt.clipping_onoff(true);
 
+	Utils::Chrono ch;
+
+	std::cout << "Compute Volume ->"<< std::endl;
+	ch.start();
+	float vol = Algo::Geometry::totalVolume<PFP>(myMap, position);
+	vol += Algo::Geometry::totalVolume<PFP>(myMap, position);
+	vol += Algo::Geometry::totalVolume<PFP>(myMap, position);
+	vol += Algo::Geometry::totalVolume<PFP>(myMap, position);
+	std::cout << ch.elapsed()<< " ms  val="<<vol<< std::endl;
+
+	ch.start();
+	vol = Algo::Geometry::Parallel::totalVolume<PFP>(myMap, position);
+	vol += Algo::Geometry::Parallel::totalVolume<PFP>(myMap, position);
+	vol += Algo::Geometry::Parallel::totalVolume<PFP>(myMap, position);
+	vol += Algo::Geometry::Parallel::totalVolume<PFP>(myMap, position);
+	std::cout << ch.elapsed()<< " ms //  val="<<vol<< std::endl;
+
+
 	// et on attend la fin.
 	return app.exec();
 }

Apps/Examples/volumeExplorer.h

@@ -118,9 +118,10 @@ public:
 protected:
 	void cb_redraw();
 	void cb_initGL();
-	void  cb_mouseMove(int buttons, int x, int y);
-	void  cb_mousePress(int button, int x, int y);
-	void  cb_mouseRelease(int button, int x, int y);
+	void cb_mouseMove(int buttons, int x, int y);
+	void cb_mousePress(int button, int x, int y);
+	void cb_mouseRelease(int button, int x, int y);
+	void cb_Open();
 
 
 // slots locaux

Apps/Tuto/CMakeLists.txt

@@ -98,8 +98,8 @@ target_link_libraries( tuto_histo
 # exemple: BOOST_LIBS(boost_lib_lists "boost_thread-mt;boost_iostreams-mt")
 #BOOST_LIBS(boost_lib_lists "boost_thread-mt")
 
-#QT4_WRAP_CPP(tuto_mt_moc tuto_mt.h)
-#add_executable( tuto_mt tuto_mt.cpp  ${tuto_mt_moc})
-#target_link_libraries( tuto_mt
-#	${CGoGN_LIBS_D} ${CGoGN_EXT_LIBS} ${Boost_THREAD_LIBRARY})
+QT4_WRAP_CPP(tuto_mt_moc tuto_mt.h)
+add_executable( tuto_mt tuto_mt.cpp  ${tuto_mt_moc})
+target_link_libraries( tuto_mt
+	${CGoGN_LIBS_D} ${CGoGN_EXT_LIBS} ${Boost_THREAD_LIBRARY})
 

Apps/Tuto/show_traversors.cpp

@@ -32,9 +32,7 @@
 #include "Algo/Render/GL2/topo3Render.h"
 #include "Algo/Render/SVG/mapSVGRender.h"
 
-//#include "Topology/generic/traversor3.h"
-//#include "Topology/generic/traversor3.h"
-#include "Topology/generic/traversorGen.h"
+#include "Topology/generic/traversorFactory.h"
 
 #include "Algo/Render/GL2/drawerCells.h"
 
@@ -214,7 +212,7 @@ void MyQT::traverse2()
 	{
 		Algo::Render::drawerCell<PFP>(VERTEX+m_second2, m_drawer, myMap, m_selected, position, m_expl);
 		m_drawer.color3f(1.0f,0.0f,0.0f);
-		Traversor<PFP::MAP>* tra = Traversor<PFP::MAP>::createIncident(myMap, m_selected, 2, VERTEX+m_second2, VERTEX+m_first2);
+		Traversor<PFP::MAP>* tra = TraversorFactory<PFP::MAP>::createIncident(myMap, m_selected, 2, VERTEX+m_second2, VERTEX+m_first2);
 		for (Dart d=tra->begin(); d != tra->end(); d= tra->next())
 				m_affDarts.push_back(d);
 		Algo::Render::drawerCells<PFP>(VERTEX+m_first2, m_drawer, myMap, m_affDarts, position, m_expl);
@@ -223,7 +221,7 @@ void MyQT::traverse2()
 	{
 		Algo::Render::drawerCell<PFP>(VERTEX+m_first2, m_drawer, myMap, m_selected, position, m_expl);
 		m_drawer.color3f(1.0f,0.0f,0.0f);
-		Traversor<PFP::MAP>* tra = Traversor<PFP::MAP>::createAdjacent(myMap, m_selected, 2, VERTEX+m_first2, VERTEX+m_second2);
+		Traversor<PFP::MAP>* tra = TraversorFactory<PFP::MAP>::createAdjacent(myMap, m_selected, 2, VERTEX+m_first2, VERTEX+m_second2);
 		for (Dart d = tra->begin(); d != tra->end(); d = tra->next())
 			m_affDarts.push_back(d);
 		Algo::Render::drawerCells<PFP>(VERTEX+m_first2, m_drawer, myMap, m_affDarts, position, m_expl);
@@ -286,7 +284,7 @@ void MyQT::traverse3()
 		dynamicMarkOrbit(VERTEX+m_second3);
 		m_drawer.color3f(1.0f,0.0f,0.0f);
 
-		Traversor<PFP::MAP>* tra = Traversor<PFP::MAP>::createIncident(myMap,m_selected, 3, VERTEX+m_second3, VERTEX+m_first3);
+		Traversor<PFP::MAP>* tra = TraversorFactory<PFP::MAP>::createIncident(myMap,m_selected, 3, VERTEX+m_second3, VERTEX+m_first3);
 		for (Dart d = tra->begin(); d != tra->end(); d = tra->next())
 		{
 			m_affDarts.push_back(d);
@@ -306,7 +304,7 @@ void MyQT::traverse3()
 		dynamicMarkOrbit(VERTEX+m_first3);
 		m_drawer.color3f(1.0f,0.0f,0.0f);
 
-		Traversor<PFP::MAP>* tra = Traversor<PFP::MAP>::createAdjacent(myMap,m_selected, 3, VERTEX+m_first3, VERTEX+m_second3);
+		Traversor<PFP::MAP>* tra = TraversorFactory<PFP::MAP>::createAdjacent(myMap,m_selected, 3, VERTEX+m_first3, VERTEX+m_second3);
 		for (Dart d = tra->begin(); d != tra->end(); d = tra->next())
 		{
 			m_affDarts.push_back(d);

Apps/Tuto/tuto_mt.h

@@ -27,8 +27,20 @@
 
 #include <iostream>
 
-#include "Utils/Qt/qtSimple.h"
+
+#include "Topology/generic/parameters.h"
+#include "Topology/map/embeddedMap3.h"
+
+#include "Geometry/vector_gen.h"
+#include "Algo/Geometry/boundingbox.h"
+#include "Algo/Render/GL2/mapRender.h"
+
+#include "Utils/Shaders/shaderSimpleColor.h"
+#include "Utils/Shaders/shaderVectorPerVertex.h"
 #include "Utils/cgognStream.h"
+#include "Utils/Qt/qtSimple.h"
+
+
 
 // forward definitions (minimize includes)
 namespace CGoGN { namespace Algo { namespace Render { namespace GL1 { class MapRender; } } } }
@@ -45,21 +57,67 @@ class MyQT: public Utils::QT::SimpleQT
 	Q_OBJECT
 
 public:
-	MyQT()
+	Algo::Render::GL2::MapRender* m_render;
+
+	Utils::VBO* m_positionVBO;
+	Utils::VBO* m_normalVBO;
+
+	Utils::ShaderSimpleColor* m_shader;
+	Utils::ShaderVectorPerVertex* m_lines;
+
+
+
+	MyQT():
+		m_render(NULL),
+		m_positionVBO(NULL),
+		m_normalVBO(NULL),
+		m_shader(NULL),
+		m_lines(NULL)
 	{}
 
-	// callbacks of simpleQT to overdefine:
+protected:
+
 	void cb_redraw();
 
 	void cb_initGL();
 
-	void cb_Open();
+	void threadSimple();
+
+	void threadAttrib();
+
+	void threadStorage();
 
-	void cb_New();
+	void cb_keyPress(int code);
 
-// callbacks (slots) locally defined
-public slots:
-	void menu_slot1();
 };
 
+
+
+
+
+
+
+
+//class MyQT: public Utils::QT::SimpleQT
+//{
+//	Q_OBJECT
+//
+//public:
+//	MyQT()
+//	{}
+//
+//	// callbacks of simpleQT to overdefine:
+//	void cb_redraw();
+//
+//	void cb_initGL();
+//
+//	void cb_Open();
+//
+//	void cb_New();
+//
+//// callbacks (slots) locally defined
+//public slots:
+//	void menu_slot1();
+//};
+
 #endif

Apps/Tuto/tuto_orbits.cpp

@@ -35,6 +35,7 @@
 #include "Algo/Render/SVG/mapSVGRender.h"
 
 #include "Algo/Import/import.h"
+#include "Topology/generic/traversorFactory.h"
 
 MAP myMap;
 VertexAttribute<VEC3> position ;
@@ -66,7 +67,7 @@ void MyQT::orbit_list(int x)
 		m_selected.clear();
 
 		// easy way to traverse darts of orbit
-		Traversor<MAP>* tra = Traversor<MAP>::createDartsOfOrbits(myMap,m_clicked,orbs[current_orbit]);
+		Traversor<MAP>* tra = TraversorFactory<MAP>::createDartsOfOrbits(myMap,m_clicked,orbs[current_orbit]);
 		for (Dart e = tra->begin(); e != tra->end(); e = tra->next())
 			m_selected.push_back(e);
 	}
@@ -174,7 +175,7 @@ void MyQT::cb_mousePress(int button, int x, int y)
 			m_selected.clear();
 
 			// easy way to traverse darts of orbit
-			Traversor<MAP>* tra = Traversor<MAP>::createDartsOfOrbits(myMap,m_clicked,orbs[current_orbit]);
+			Traversor<MAP>* tra = TraversorFactory<MAP>::createDartsOfOrbits(myMap,m_clicked,orbs[current_orbit]);
 			for (Dart e = tra->begin(); e != tra->end(); e = tra->next())
 				m_selected.push_back(e);
 		}

include/Algo/Geometry/area.hpp

@@ -158,6 +158,90 @@ void computeVoronoiAreaVertices(typename PFP::MAP& map, const VertexAttribute<ty
 		vertex_area[d] = vertexVoronoiArea<PFP>(map, d, position) ;
 }
 
+
+namespace Parallel
+{
+template <typename PFP>
+class FunctorConvexFaceArea: public FunctorMapThreaded<typename PFP::MAP >
+{
+	 const VertexAttribute<typename PFP::VEC3>& m_position;
+	 FaceAttribute<typename PFP::REAL>& m_area;
+public:
+	 FunctorConvexFaceArea<PFP>( typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, FaceAttribute<typename PFP::REAL>& area):
+	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_area(area)
+	 { }
+
+	void run(Dart d, unsigned int threadID)
+	{
+		m_area[d] = convexFaceArea<PFP>(this->m_map, d, m_position) ;
+	}
+};
+
+template <typename PFP>
+void computeAreaFaces(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, FaceAttribute<typename PFP::REAL>& area, const FunctorSelect& select, unsigned int nbth, unsigned int current_thread)
+{
+	FunctorConvexFaceArea<PFP> funct(map,position,area);
+	Algo::Parallel::foreach_cell<typename PFP::MAP,FACE>(map, funct, nbth, false, select, current_thread);
+}
+
+
+template <typename PFP>
+class FunctorVertexOneRingArea: public FunctorMapThreaded<typename PFP::MAP >
+{
+	 const VertexAttribute<typename PFP::VEC3>& m_position;
+	 VertexAttribute<typename PFP::REAL>& m_area;
+public:
+	 FunctorVertexOneRingArea<PFP>( typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VertexAttribute<typename PFP::REAL>& area):
+	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_area(area)
+	 { }
+
+	void run(Dart d, unsigned int threadID)
+	{
+		m_area[d] = vertexOneRingArea<PFP>(this->m_map, d, m_position) ;
+	}
+};
+
+template <typename PFP>
+void computeOneRingAreaVertices(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VertexAttribute<typename PFP::REAL>& area, const FunctorSelect& select, unsigned int nbth, unsigned int current_thread)
+{
+	FunctorConvexFaceArea<PFP> funct(map,position,area);
+	Algo::Parallel::foreach_cell<typename PFP::MAP,VERTEX>(map, funct, nbth, false, select, current_thread);
+}
+
+
+
+template <typename PFP>
+class FunctorVertexVoronoiArea: public FunctorMapThreaded<typename PFP::MAP >
+{
+	 const VertexAttribute<typename PFP::VEC3>& m_position;
+	 VertexAttribute<typename PFP::REAL>& m_area;
+public:
+	 FunctorVertexVoronoiArea<PFP>( typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VertexAttribute<typename PFP::REAL>& area):
+	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_area(area)
+	 { }
+
+	void run(Dart d, unsigned int threadID)
+	{
+		m_area[d] = vertexVoronoiArea<PFP>(this->m_map, d, m_position) ;
+	}
+};
+
+template <typename PFP>
+void computeVoronoiAreaVertices(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VertexAttribute<typename PFP::REAL>& area, const FunctorSelect& select, unsigned int nbth, unsigned int current_thread)
+{
+	FunctorConvexFaceArea<PFP> funct(map,position,area);
+	Algo::Parallel::foreach_cell<typename PFP::MAP,VERTEX>(map, funct, nbth, false, select, current_thread);
+}
+
+
+}
+
+
+
+
+
+
+
 } // namespace Geometry
 
 } // namespace Algo

include/Algo/Geometry/centroid.h

@@ -49,7 +49,7 @@ namespace Geometry
 * @param attributs the vector of attribute or cell
 */
 template <typename PFP, typename EMBV, typename EMB>
-EMB volumeCentroidGen(typename PFP::MAP& map, Dart d, const EMBV& attributs);
+EMB volumeCentroidGen(typename PFP::MAP& map, Dart d, const EMBV& attributs, unsigned int thread = 0);
 
 /**
 * Compute volume centroid
@@ -59,9 +59,9 @@ EMB volumeCentroidGen(typename PFP::MAP& map, Dart d, const EMBV& attributs);
  * @param position the vector of attribute
  */
 template <typename PFP>
-typename PFP::VEC3 volumeCentroid(typename PFP::MAP& map, Dart d, const VertexAttribute<typename PFP::VEC3>& position)
+typename PFP::VEC3 volumeCentroid(typename PFP::MAP& map, Dart d, const VertexAttribute<typename PFP::VEC3>& position, unsigned int thread = 0)
 {
-	return volumeCentroidGen<PFP, VertexAttribute<typename PFP::VEC3>, typename PFP::VEC3>(map, d, position);
+	return volumeCentroidGen<PFP, VertexAttribute<typename PFP::VEC3>, typename PFP::VEC3>(map, d, position, thread);
 }
 
 /**
@@ -116,13 +116,38 @@ typename PFP::VEC3 vertexNeighborhoodCentroid(typename PFP::MAP& map, Dart d, co
 }
 
 template <typename PFP>
-void computeCentroidVolumes(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VolumeAttribute<typename PFP::VEC3>& vol_centroid, const FunctorSelect& select = allDarts) ;
+void computeCentroidVolumes(typename PFP::MAP& map,
+		const VertexAttribute<typename PFP::VEC3>& position, VolumeAttribute<typename PFP::VEC3>& vol_centroid,
+		const FunctorSelect& select = allDarts, unsigned int thread = 0) ;
 
 template <typename PFP>
-void computeCentroidFaces(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, FaceAttribute<typename PFP::VEC3>& face_centroid, const FunctorSelect& select = allDarts) ;
+void computeCentroidFaces(typename PFP::MAP& map,
+		const VertexAttribute<typename PFP::VEC3>& position, FaceAttribute<typename PFP::VEC3>& face_centroid,
+		const FunctorSelect& select = allDarts, unsigned int thread = 0) ;
 
 template <typename PFP>
-void computeNeighborhoodCentroidVertices(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VertexAttribute<typename PFP::VEC3>& vertex_centroid, const FunctorSelect& select = allDarts) ;
+void computeNeighborhoodCentroidVertices(typename PFP::MAP& map,
+		const VertexAttribute<typename PFP::VEC3>& position, VertexAttribute<typename PFP::VEC3>& vertex_centroid,
+		const FunctorSelect& select = allDarts, unsigned int thread = 0) ;
+
+
+namespace Parallel
+{
+template <typename PFP>
+void computeCentroidVolumes(typename PFP::MAP& map,
+		const VertexAttribute<typename PFP::VEC3>& position, VolumeAttribute<typename PFP::VEC3>& vol_centroid,
+		const FunctorSelect& select = allDarts, unsigned int nbth = 0, unsigned int current_thread = 0) ;
+
+template <typename PFP>
+void computeCentroidFaces(typename PFP::MAP& map,
+		const VertexAttribute<typename PFP::VEC3>& position, FaceAttribute<typename PFP::VEC3>& face_centroid,
+		const FunctorSelect& select = allDarts, unsigned int nbth = 0, unsigned int current_thread = 0) ;
+
+template <typename PFP>
+void computeNeighborhoodCentroidVertices(typename PFP::MAP& map,
+		const VertexAttribute<typename PFP::VEC3>& position, VertexAttribute<typename PFP::VEC3>& vertex_centroid,
+		const FunctorSelect& select = allDarts, unsigned int nbth = 0, unsigned int current_thread = 0) ;
+}
 
 } // namespace Geometry
 

include/Algo/Geometry/centroid.hpp

@@ -27,6 +27,7 @@
 #include "Topology/generic/cellmarker.h"
 #include "Topology/generic/traversorCell.h"
 #include "Topology/generic/traversor3.h"
+#include "Algo/Parallel/parallel_foreach.h"
 
 
 namespace CGoGN
@@ -39,12 +40,12 @@ namespace Geometry
 {
 
 template <typename PFP, typename EMBV, typename EMB>
-EMB volumeCentroidGen(typename PFP::MAP& map, Dart d, const EMBV& attributs)
+EMB volumeCentroidGen(typename PFP::MAP& map, Dart d, const EMBV& attributs, unsigned int thread)
 {
 	EMB center = AttribOps::zero<EMB,PFP>() ;
 	unsigned int count = 0 ;
 
-	Traversor3WV<typename PFP::MAP> tra(map,d);
+	Traversor3WV<typename PFP::MAP> tra(map,d,false,thread);
 	for (Dart d = tra.begin(); d != tra.end(); d = tra.next())
 	{
 		center += attributs[d];
@@ -86,29 +87,126 @@ EMB vertexNeighborhoodCentroidGen(typename PFP::MAP& map, Dart d, const EMBV& at
 }
 
 template <typename PFP>
-void computeCentroidVolumes(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VolumeAttribute<typename PFP::VEC3>& vol_centroid, const FunctorSelect& select)
+void computeCentroidVolumes(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VolumeAttribute<typename PFP::VEC3>& vol_centroid, const FunctorSelect& select, unsigned int thread)
 {
-	TraversorW<typename PFP::MAP> t(map, select) ;
+	TraversorW<typename PFP::MAP> t(map, select,thread) ;
 	for(Dart d = t.begin(); d != t.end(); d = t.next())
-		vol_centroid[d] = volumeCentroid<PFP>(map, d, position) ;
+		vol_centroid[d] = volumeCentroid<PFP>(map, d, position,thread) ;
 }
 
 template <typename PFP>
-void computeCentroidFaces(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, FaceAttribute<typename PFP::VEC3>& face_centroid, const FunctorSelect& select)
+void computeCentroidFaces(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, FaceAttribute<typename PFP::VEC3>& face_centroid, const FunctorSelect& select, unsigned int thread)
 {
-	TraversorF<typename PFP::MAP> t(map, select) ;
+	TraversorF<typename PFP::MAP> t(map, select,thread) ;
 	for(Dart d = t.begin(); d != t.end(); d = t.next())
 		face_centroid[d] = faceCentroid<PFP>(map, d, position) ;
 }
 
 template <typename PFP>
-void computeNeighborhoodCentroidVertices(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VertexAttribute<typename PFP::VEC3>& vertex_centroid, const FunctorSelect& select)
+void computeNeighborhoodCentroidVertices(typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VertexAttribute<typename PFP::VEC3>& vertex_centroid, const FunctorSelect& select, unsigned int thread)
 {
-	TraversorV<typename PFP::MAP> t(map, select) ;
+	TraversorV<typename PFP::MAP> t(map, select, thread) ;
 	for(Dart d = t.begin(); d != t.end(); d = t.next())
 		vertex_centroid[d] = vertexNeighborhoodCentroid<PFP>(map, d, position) ;
 }
 
+
+
+namespace Parallel
+{
+template <typename PFP>
+class FunctorComputeCentroidVolumes: public FunctorMapThreaded<typename PFP::MAP >
+{
+	 const VertexAttribute<typename PFP::VEC3>& m_position;
+	 VolumeAttribute<typename PFP::VEC3>& m_vol_centroid;
+public:
+	 FunctorComputeCentroidVolumes<PFP>( typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VolumeAttribute<typename PFP::VEC3>& vol_centroid):
+	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_vol_centroid(vol_centroid)
+	 { }
+
+	void run(Dart d, unsigned int threadID)
+	{
+		m_vol_centroid[d] = volumeCentroid<PFP>(this->m_map, d, m_position,threadID) ;
+	}
+};
+
+
+template <typename PFP>
+void computeCentroidVolumes(typename PFP::MAP& map,
+		const VertexAttribute<typename PFP::VEC3>& position, VolumeAttribute<typename PFP::VEC3>& vol_centroid,
+		const FunctorSelect& select, unsigned int nbth, unsigned int current_thread)
+{
+	FunctorComputeCentroidVolumes<PFP> funct(map,position,vol_centroid);
+	Algo::Parallel::foreach_cell<typename PFP::MAP,VOLUME>(map, funct, nbth, true, select, current_thread);
+}
+
+
+template <typename PFP>
+class FunctorComputeCentroidFaces: public FunctorMapThreaded<typename PFP::MAP >
+{
+	 const VertexAttribute<typename PFP::VEC3>& m_position;
+	 FaceAttribute<typename PFP::VEC3>& m_fcentroid;
+public:
+	 FunctorComputeCentroidFaces<PFP>( typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, FaceAttribute<typename PFP::VEC3>& fcentroid):
+	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_fcentroid(fcentroid)
+	 { }
+
+	void run(Dart d, unsigned int threadID)
+	{
+		m_fcentroid[d] = faceCentroid<PFP>(this->m_map, d, m_position) ;
+	}
+};
+
+
+template <typename PFP>
+void computeCentroidFaces(typename PFP::MAP& map,
+		const VertexAttribute<typename PFP::VEC3>& position, FaceAttribute<typename PFP::VEC3>& face_centroid,
+		const FunctorSelect& select, unsigned int nbth, unsigned int current_thread)
+{
+	FunctorComputeCentroidFaces<PFP> funct(map,position,face_centroid);
+	Algo::Parallel::foreach_cell<typename PFP::MAP,FACE>(map, funct, nbth, false, select, current_thread);
+}
+
+
+template <typename PFP>
+class FunctorComputeNeighborhoodCentroidVertices: public FunctorMapThreaded<typename PFP::MAP >
+{
+	 const VertexAttribute<typename PFP::VEC3>& m_position;
+	 VertexAttribute<typename PFP::VEC3>& m_vcentroid;
+public:
+	 FunctorComputeNeighborhoodCentroidVertices<PFP>( typename PFP::MAP& map, const VertexAttribute<typename PFP::VEC3>& position, VertexAttribute<typename PFP::VEC3>& vcentroid):
+	 	 FunctorMapThreaded<typename PFP::MAP>(map), m_position(position), m_vcentroid(vcentroid)
+	 { }
+
+	void run(Dart d, unsigned int threadID)
+	{
+		m_vcentroid[d] = vertexNeighborhoodCentroid<PFP>(this->m_map, d, m_position) ;
+	}
+};
+
+template <typename PFP>
+void computeNeighborhoodCentroidVertices(typename PFP::MAP& map,
+		const VertexAttribute<typename PFP::VEC3>& position, VertexAttribute<typename PFP::VEC3>& vertex_centroid,
+		const FunctorSelect& select, unsigned int nbth, unsigned int current_thread)
+{
+	FunctorComputeNeighborhoodCentroidVertices<PFP> funct(map,position,vertex_centroid);
+	Algo::Parallel::foreach_cell<typename PFP::MAP,VERTEX>(map, funct, nbth, false, select, current_thread);
+}
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
 } // namespace Geometry