somes changes...

Apps/Examples/viewer.cpp

@@ -31,6 +31,7 @@ Viewer::Viewer() :
 	m_drawFaces(true),
 	m_drawNormals(false),
 	m_drawTopo(false),
+	m_drawBoundaryTopo(true),
 	m_render(NULL),
 	m_phongShader(NULL),
 	m_flatShader(NULL),
@@ -231,7 +232,7 @@ void Viewer::importMesh(std::string& filename)
 	m_render->initPrimitives<PFP>(myMap, Algo::Render::GL2::LINES) ;
 	m_render->initPrimitives<PFP>(myMap, Algo::Render::GL2::TRIANGLES) ;
 
-	m_topoRender->updateData<PFP>(myMap, position, 0.85f, 0.85f) ;
+	m_topoRender->updateData<PFP>(myMap, position, 0.85f, 0.85f, m_drawBoundaryTopo) ;
 
 	bb = Algo::Geometry::computeBoundingBox<PFP>(myMap, position) ;
 	normalBaseSize = bb.diagSize() / 100.0f ;

Apps/Examples/viewer.h

@@ -96,6 +96,7 @@ public:
 	bool m_drawFaces ;
 	bool m_drawNormals ;
 	bool m_drawTopo ;
+	bool m_drawBoundaryTopo;
 
 	VertexAttribute<VEC3> position ;
 	VertexAttribute<VEC3> normal ;

Apps/Tuto/tuto_oper2.cpp

@@ -357,8 +357,10 @@ void MyQT::cb_Open()
 
 void MyQT::cb_Save()
 {
-	std::string filename = selectFileSave("Export SVG file ",".","(*.off)");
-	Algo::Surface::Export::exportOFF<PFP>(myMap,position,filename.c_str());
+	std::string filename = selectFileSave("Export Map file ",".","(*.map)");
+	//Algo::Surface::Export::exportOFF<PFP>(myMap,position,filename.c_str());
+	if(!myMap.saveMapBin(filename))
+		std::cout << "could not save file : " << filename << std::endl;
 }
 
 void MyQT::importMesh(std::string& filename)

Apps/Tuto/tuto_oper3.cpp

@@ -259,9 +259,20 @@ void MyQT::createMap(int n)
 	position = myMap.getAttribute<VEC3, VERTEX>("position");
 	if (!position.isValid())
 		position = myMap.addAttribute<VEC3, VERTEX>("position");
-	Algo::Volume::Modelisation::Primitive3D<PFP> prim(myMap, position);
-	prim.hexaGrid_topo(n,n,n);
-	prim.embedHexaGrid(1.0f,1.0f,1.0f);
+//	Algo::Volume::Modelisation::Primitive3D<PFP> prim(myMap, position);
+//	prim.hexaGrid_topo(n,n,n);
+//	prim.embedHexaGrid(1.0f,1.0f,1.0f);
+
+//	Algo::Surface::Modelisation::Polyhedron<PFP> poly(myMap, position);
+//	poly.cylinder_topo(6,1,true,true);
+//	poly.embedCylinder(6.0,6.0,5.0);
+//	myMap.closeMap();
+
+	Dart d = Algo::Surface::Modelisation::embedPrism<PFP>(myMap, position, 5, true,6.0,6.0,5.0);
+	Dart d2 = Algo::Surface::Modelisation::embedPyramid<PFP>(myMap, position, 4, true,6.0,5.0);
+
+	myMap.sewVolumes(myMap.phi2(d),d2);
+	position[myMap.phi_1(myMap.phi2(d2))] += VEC3(9.0,-5.0,-2.5);
 
 	myMap.check();
 
@@ -565,8 +576,8 @@ void MyQT::cb_keyPress(int keycode)
 		updateGL();
 		break;
 	case 'W':
-		m_ex1 = 0.9f;
-		m_ex2 = 0.9f;
+		m_ex1 = 0.95f;
+		m_ex2 = 0.95f;
 		m_render_topo->updateData<PFP>(myMap, position, m_ex1,m_ex2,m_ex3/*, nb*/);
 		updateGL();
 		break;

SCHNApps/Plugins/renderTopoSurface/include/renderTopoSurface.h

@@ -64,7 +64,7 @@ public:
 
 	virtual void keyPress(View* view, QKeyEvent* event) {}
 	virtual void keyRelease(View* view, QKeyEvent* event) {}
-	virtual void mousePress(View* view, QMouseEvent* event) {}
+	virtual void mousePress(View* view, QMouseEvent* event);
 	virtual void mouseRelease(View* view, QMouseEvent* event) {}
 	virtual void mouseMove(View* view, QMouseEvent* event) {}
 	virtual void wheelEvent(View* view, QWheelEvent* event) {}
@@ -100,6 +100,9 @@ public slots:
 
 	void attributeModified(unsigned int orbit, QString nameAttr);
 	void connectivityModified();
+
+signals:
+	void dartSelected(Dart d);
 };
 
 } // namespace SCHNApps

SCHNApps/Plugins/renderTopoSurface/src/renderTopoSurface.cpp

@@ -86,6 +86,22 @@ void RenderTopoSurfacePlugin::redraw(View* view)
 	}
 }
 
+void RenderTopoSurfacePlugin::mousePress(View* view, QMouseEvent* event)
+{
+//  if (Shift())
+//  {
+//    ParameterSet* params = h_viewParams[view];
+
+//    m_renderTopo->updateData<PFP>(myMap, position, m_coeff_topo_explod[0], m_coeff_topo_explod[1], m_coeff_topo_explod[2], *m_selNoBoundary)	;
+
+//    Dart d = m_renderTopo->picking<PFP>(myMap, x,  y, *m_selNoBoundary);
+//    if (d != Dart::nil())
+//    {
+//      emit(dartSelected(d);
+//    }
+//  }
+}
+
 void RenderTopoSurfacePlugin::viewLinked(View* view, Plugin* plugin)
 {
 	if(plugin == this)

include/Algo/ImplicitHierarchicalMesh/ihm.h

@@ -60,7 +60,21 @@ public:
 
 	static const unsigned int DIMENSION = 2 ;
 
-	void init() ;
+	//!
+	/*!
+	 *
+	 */
+	void update_topo_shortcuts();
+
+
+	void initImplicitProperties() ;
+
+	/**
+	 * clear the map
+	 * @param remove attrib remove attribute (not only clear the content)
+	 */
+	void clear(bool removeAttrib);
+
 
 	/***************************************************
 	 *             ATTRIBUTES MANAGEMENT               *

include/Algo/ImplicitHierarchicalMesh/ihm.hpp

@@ -66,6 +66,17 @@ AttributeHandler_IHM<T, ORBIT> ImplicitHierarchicalMap::getAttribute(const std::
 	return AttributeHandler_IHM<T, ORBIT>(this, h.getDataVector()) ;
 }
 
+inline void ImplicitHierarchicalMap::update_topo_shortcuts()
+{
+	Map2::update_topo_shortcuts();
+	m_dartLevel = Map2::getAttribute<unsigned int, DART>("dartLevel") ;
+	m_edgeId = Map2::getAttribute<unsigned int, DART>("edgeId") ;
+
+	//AttributeContainer& cont = m_attribs[DART] ;
+	//m_nextLevelCell = cont.getDataVector<unsigned int>(cont.getAttributeIndex("nextLevelCell")) ;
+}
+
+
 /***************************************************
  *                 MAP TRAVERSAL                   *
  ***************************************************/

include/Algo/ImplicitHierarchicalMesh/ihm3.hpp

@@ -80,7 +80,7 @@ inline void ImplicitHierarchicalMap3::update_topo_shortcuts()
 
 
 /***************************************************
- *          			 	    MAP TRAVERSAL         		  		         *
+ *     		 	    MAP TRAVERSAL         		   *
  ***************************************************/
 
 inline Dart ImplicitHierarchicalMap3::newDart()

include/Algo/Modelisation/polyhedron.h

@@ -137,7 +137,12 @@ template <typename PFP>
 bool isPrism(typename PFP::MAP& map, Dart d, unsigned int thread = 0);
 
 
+template <typename PFP>
+Dart embedPrism(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3>& position, unsigned int n, bool withBoundary, float bottom_radius, float top_radius, float height);
+
 
+template <typename PFP>
+Dart embedPyramid(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3>& position, unsigned int n, bool withBoundary, float radius, float height);
 
 
 

include/Algo/Modelisation/polyhedron.hpp

@@ -234,7 +234,135 @@ Dart createOctahedron(typename PFP::MAP& map, bool withBoundary)
 	return createDiamond<PFP>(map,4, withBoundary);
 }
 
+template <typename PFP>
+Dart embedPrism(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3>& position, unsigned int n, bool withBoundary, float bottom_radius, float top_radius, float height)
+{
+	typedef typename PFP::VEC3 VEC3 ;
+
+	unsigned int m_nz = 1;
+
+	Dart dres = Dart::nil();
+	unsigned int nb = n*2;
+	std::vector<Dart> m_tableVertDarts;
+	m_tableVertDarts.reserve(nb);
+
+	// creation of quads around circunference and storing vertices
+	for (unsigned int i = 0; i < n; ++i)
+	{
+		Dart d = map.newFace(4, false);
+		m_tableVertDarts.push_back(d);
+	}
+
+	// storing a dart from the vertex pointed by phi1(phi1(d))
+	for (unsigned int i = 0; i < n; ++i)
+	{
+		//m_tableVertDarts.push_back(map.phi1(map.phi1(m_tableVertDarts[i])));
+		m_tableVertDarts.push_back(map.phi_1(m_tableVertDarts[i]));
+	}
+
+	// sewing the quads
+	for (unsigned int i = 0; i < n-1; ++i)
+	{
+		Dart d = m_tableVertDarts[i];
+		d = map.phi_1(d);
+		Dart e = m_tableVertDarts[i+1];
+		e = map.phi1(e);
+		map.sewFaces(d, e, false);
+	}
+	//sewing the last with the first
+	map.sewFaces(map.phi1(m_tableVertDarts[0]), map.phi_1(m_tableVertDarts[n-1]), false);
+
+	//sewing the top & bottom faces
+	Dart top = map.newFace(n, false);
+	Dart bottom = map.newFace(n, false);
+	dres = top;
+	for(unsigned int i = 0; i < n ; ++i)
+	{
+		map.sewFaces(m_tableVertDarts[i], top, false);
+		map.sewFaces(map.phi_1(m_tableVertDarts[n+i]), bottom, false);
+		top = map.phi1(top);
+		bottom = map.phi_1(bottom);
+	}
+
+	if(map.dimension() == 3 && withBoundary)
+		map.closeMap();
+
+	float alpha = float(2.0*M_PI/n);
+	float dz = height/float(m_nz);
+
+	for(unsigned int i = 0; i <= m_nz; ++i)
+	{
+		float a = float(i)/float(m_nz);
+		float radius = a*top_radius + (1.0f-a)*bottom_radius;
+		for(unsigned int j = 0; j < n; ++j)
+		{
 
+			float x = radius*cos(alpha*float(j));
+			float y = radius*sin(alpha*float(j));
+			position[ m_tableVertDarts[i*n+j] ] = VEC3(x, y, -height/2 + dz*float(i));
+		}
+	}
+
+	return dres;
+}
+template <typename PFP>
+Dart embedPyramid(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3>& position, unsigned int n, bool withBoundary, float radius, float height)
+{
+	typedef typename PFP::VEC3 VEC3 ;
+
+	Dart dres = Dart::nil();
+	std::vector<Dart> m_tableVertDarts;
+	m_tableVertDarts.reserve(n);
+
+	// creation of triangles around circunference and storing vertices
+	for (unsigned int i = 0; i < n; ++i)
+	{
+		Dart d = map.newFace(3, false);
+		m_tableVertDarts.push_back(d);
+	}
+
+	// sewing the triangles
+	for (unsigned int i = 0; i < n-1; ++i)
+	{
+		Dart d = m_tableVertDarts[i];
+		d = map.phi_1(d);
+		Dart e = m_tableVertDarts[i+1];
+		e = map.phi1(e);
+		map.sewFaces(d, e, false);
+	}
+	//sewing the last with the first
+	map.sewFaces(map.phi1(m_tableVertDarts[0]), map.phi_1(m_tableVertDarts[n-1]), false);
+
+	//sewing the bottom face
+	Dart base = map.newFace(n, false);
+	dres = base;
+	for(unsigned int i = 0; i < n ; ++i)
+	{
+		map.sewFaces(m_tableVertDarts[i], base, false);
+		base = map.phi1(base);
+	}
+
+	if(map.dimension() == 3 && withBoundary)
+		map.closeMap();
+
+	float alpha = float(2.0*M_PI/n);
+
+	for(unsigned int j = 0; j < n; ++j)
+	{
+		float rad = radius;
+		float h = -height/2;
+		float x = rad*cos(alpha*float(j));
+		float y = rad*sin(alpha*float(j));
+
+		position[ m_tableVertDarts[j] ] = VEC3(x, y, h);
+	}
+
+	//  top always closed in cone
+	position[ map.phi_1(m_tableVertDarts[0]) ] = VEC3(0.0f, 0.0f, height/2 );
+
+	//return a dart from the base
+	return dres;
+}
 
 
 

include/Algo/Multiresolution/Map3MR/Filters/lerp.h

@@ -103,12 +103,7 @@ public:
 
 			m_map.incCurrentLevel() ;
 			Dart midV = m_map.phi_1(m_map.phi2(m_map.phi1(d)));
-			if(m_position[midV] != typename PFP::VEC3(0.0f,0.0f,0.0f))
-			{
-				std::cout << "position[midV] = " << m_position[midV] << std::endl;
-			}
-			else
-				m_position[midV] += vc + ec + fc;
+			m_position[midV] += vc + ec + fc;
 			m_map.decCurrentLevel() ;
 		}
 
@@ -135,13 +130,7 @@ public:
 
 			m_map.incCurrentLevel() ;
 			Dart midF = m_map.phi1(m_map.phi1(d));
-			if(m_position[midF] != typename PFP::VEC3(0.0f,0.0f,0.0f))
-			{
-				std::cout << "position[midF] = " << m_position[midF] << std::endl;
-				//m_position[midF] = vf + ef ;
-			}
-			else
-				m_position[midF] += vf + ef ;
+			m_position[midF] += vf + ef ;
 			m_map.decCurrentLevel() ;
 		}
 
@@ -152,13 +141,7 @@ public:
 
 			m_map.incCurrentLevel() ;
 			Dart midE = m_map.phi1(d) ;
-			if(m_position[midE] != typename PFP::VEC3(0.0f,0.0f,0.0f))
-			{
-				std::cout << "position[midE] = " << m_position[midE] << std::endl;
-				//m_position[midE] = ve;
-			}
-			else
-				m_position[midE] += ve;
+			m_position[midE] += ve;
 			m_map.decCurrentLevel() ;
 		}
 	}

include/Algo/Multiresolution/Map3MR/Filters/schaefer.h

@@ -430,6 +430,196 @@ public:
 	}
 } ;
 
+
+
+
+
+
+
+
+
+
+
+
+
+//template <typename PFP>
+//class SHW04OddSynthesisFilter : public Algo::MR::Filter
+//{
+//protected:
+//	typename PFP::MAP& m_map;
+//	VertexAttribute<typename PFP::VEC3>& m_position;
+//
+//public:
+//	SHW04OddSynthesisFilter(typename PFP::MAP& m, VertexAttribute<typename PFP::VEC3>& p) : m_map(m), m_position(p)
+//	{}
+//
+//	void operator() ()
+//	{
+//		TraversorW<typename PFP::MAP> travW(m_map) ;
+//		for (Dart d = travW.begin(); d != travW.end(); d = travW.next())
+//		{
+//			if(!Algo::Volume::Modelisation::Tetrahedralization::isTetrahedron<PFP>(m_map,d))
+//			{
+//				typename PFP::VEC3 vc = Algo::Surface::Geometry::volumeCentroid<PFP>(m_map, d, m_position);
+//
+//				unsigned int count = 0;
+//				typename PFP::VEC3 ec(0.0);
+//				Traversor3WE<typename PFP::MAP> travWE(m_map, d);
+//				for (Dart dit = travWE.begin(); dit != travWE.end(); dit = travWE.next())
+//				{
+//					m_map.incCurrentLevel();
+//					ec += m_position[m_map.phi1(dit)];
+//					m_map.decCurrentLevel();
+//					++count;
+//				}
+//				ec /= count;
+//				ec *= 3;
+//
+//				count = 0;
+//				typename PFP::VEC3 fc(0.0);
+//				Traversor3WF<typename PFP::MAP> travWF(m_map, d);
+//				for (Dart dit = travWF.begin(); dit != travWF.end(); dit = travWF.next())
+//				{
+//					m_map.incCurrentLevel();
+//					fc += m_position[m_map.phi1(m_map.phi1(dit))];
+//					m_map.decCurrentLevel();
+//					++count;
+//				}
+//				fc /= count;
+//				fc *= 3;
+//
+//				m_map.incCurrentLevel() ;
+//				Dart midV = m_map.phi_1(m_map.phi2(m_map.phi1(d)));
+//				m_position[midV] += vc + ec + fc;
+//				m_map.decCurrentLevel() ;
+//			}
+//		}
+//
+//		TraversorE<typename PFP::MAP> trav(m_map) ;
+//		for (Dart d = trav.begin(); d != trav.end(); d = trav.next())
+//		{
+//			if(m_map.isBoundaryEdge(d))
+//			{
+//				Dart db = m_map.findBoundaryFaceOfEdge(d);
+//				typename PFP::VEC3 p = loopOddVertex<PFP>(m_map, m_position, db) ;
+//
+//				m_map.incCurrentLevel() ;
+//
+//				Dart oddV = m_map.phi2(db) ;
+//				m_position[oddV] += p ;
+//
+//				m_map.decCurrentLevel() ;
+//			}
+//			else
+//			{
+//				typename PFP::VEC3 ve = (m_position[d] + m_position[m_map.phi1(d)]) * typename PFP::REAL(0.5);
+//
+//				m_map.incCurrentLevel() ;
+//				Dart midV = m_map.phi1(d) ;
+//				m_position[midV] += ve;
+//				m_map.decCurrentLevel() ;
+//			}
+//		}
+//	}
+//};
+//
+//template <typename PFP>
+//class LoopNormalisationSynthesisFilter : public Algo::MR::Filter
+//{
+//protected:
+//	typename PFP::MAP& m_map ;
+//	VertexAttribute<typename PFP::VEC3>& m_position ;
+//
+//public:
+//	LoopNormalisationSynthesisFilter(typename PFP::MAP& m, VertexAttribute<typename PFP::VEC3>& p) : m_map(m), m_position(p)
+//	{}
+//
+//	void operator() ()
+//	{
+//		TraversorV<typename PFP::MAP> trav(m_map) ;
+//		for (Dart d = trav.begin(); d != trav.end(); d = trav.next())
+//		{
+//			if(m_map.isBoundaryVertex(d))
+//			{
+//				Dart db = m_map.findBoundaryFaceOfVertex(d);
+//
+//				unsigned int degree = m_map.vertexDegreeOnBoundary(db) ;
+//				float n = 3.0/8.0 + 1.0/4.0 * cos(2.0 * M_PI / degree) ;
+//				n = 8.0/5.0 * (n * n) ;
+//
+//				m_position[db] *= n ;
+//			}
+//		}
+//	}
+//} ;
+//
+//template <typename PFP>
+//class LoopEvenSynthesisFilter : public Algo::MR::Filter
+//{
+//protected:
+//	typename PFP::MAP& m_map ;
+//	VertexAttribute<typename PFP::VEC3>& m_position ;
+//
+//public:
+//	LoopEvenSynthesisFilter(typename PFP::MAP& m, VertexAttribute<typename PFP::VEC3>& p) : m_map(m), m_position(p)
+//	{}
+//
+//	void operator() ()
+//	{
+//		TraversorV<typename PFP::MAP> trav(m_map) ;
+//		for (Dart d = trav.begin(); d != trav.end(); d = trav.next())
+//		{
+//			if(m_map.isBoundaryVertex(d))
+//			{
+//				Dart db = m_map.findBoundaryFaceOfVertex(d);
+//				typename PFP::VEC3 p = loopEvenVertex<PFP>(m_map, m_position, db) ;
+//				m_position[db] += p ;
+//			}
+//		}
+//	}
+//} ;
+//
+//
+//template <typename PFP>
+//class SHW04NormalisationSynthesisFilter : public Algo::MR::Filter
+//{
+//protected:
+//	typename PFP::MAP& m_map ;
+//	VertexAttribute<typename PFP::VEC3>& m_position ;
+//
+//public:
+//	SHW04NormalisationSynthesisFilter(typename PFP::MAP& m, VertexAttribute<typename PFP::VEC3>& p) : m_map(m), m_position(p)
+//	{}
+//
+//	void operator() ()
+//	{
+//		m_map.incCurrentLevel() ;
+//		TraversorV<typename PFP::MAP> trav(m_map) ;
+//		for (Dart d = trav.begin(); d != trav.end(); d = trav.next())
+//		{
+//			if(!m_map.isBoundaryVertex(d))
+//			{
+//				typename PFP::VEC3 p = typename PFP::VEC3(0);
+//				unsigned int degree = 0;
+//
+//				Traversor3VW<typename PFP::MAP> travVW(m_map, d);
+//				for(Dart dit = travVW.begin() ; dit != travVW.end() ; dit = travVW.next())
+//				{
+//					p += SHW04Vertex<PFP>(m_map, m_position, dit);
+//					++degree;
+//				}
+//
+//				p /= degree;
+//
+//				m_position[d] = p ;
+//			}
+//		}
+//		m_map.decCurrentLevel() ;
+//	}
+//} ;
+
+
+
 } // namespace Filters
 
 } // namespace Primal

include/Algo/Render/GL2/topoRender.hpp

@@ -86,33 +86,33 @@ void TopoRender::updateData(typename PFP::MAP& map, const VertexAttribute<typena
 template<typename PFP>
 void TopoRender::updateDataMap(typename PFP::MAP& mapx, const VertexAttribute<typename PFP::VEC3>& positions, float ke, float kf, bool withBoundary)
 {
-	Map2& map = reinterpret_cast<Map2&>(mapx);
+	//Map2& map = reinterpret_cast<Map2&>(mapx);
 
 	typedef typename PFP::VEC3 VEC3;
 	typedef typename PFP::REAL REAL;
 
 	std::vector<Dart> vecDarts;
-	vecDarts.reserve(map.getNbDarts());  // no problem dart is int: no problem of memory
+	vecDarts.reserve(mapx.getNbDarts());  // no problem dart is int: no problem of memory
 
-	m_attIndex = map.template getAttribute<unsigned int, DART>("dart_index");
+	m_attIndex = mapx.template getAttribute<unsigned int, DART>("dart_index");
 
 	if (!m_attIndex.isValid())
-		m_attIndex  = map.template addAttribute<unsigned int, DART>("dart_index");
+		m_attIndex  = mapx.template addAttribute<unsigned int, DART>("dart_index");
 
-	for(Dart d = map.begin(); d!= map.end(); map.next(d))
+	for(Dart d = mapx.begin(); d!= mapx.end(); mapx.next(d))
 	{
-		if (withBoundary || !map.isBoundaryMarked2(d))
+		if (withBoundary || !mapx.isBoundaryMarked2(d))
 			vecDarts.push_back(d);
 
 	}
 	m_nbDarts = vecDarts.size();
 
 	// debut phi1
-	DartAutoAttribute<VEC3> fv1(map);
+	DartAutoAttribute<VEC3> fv1(mapx);
 	// fin phi1
-	DartAutoAttribute<VEC3> fv11(map);
+	DartAutoAttribute<VEC3> fv11(mapx);
 	// phi2
-	DartAutoAttribute<VEC3> fv2(map);
+	DartAutoAttribute<VEC3> fv2(mapx);
 
 	m_vbo3->bind();
 	glBufferData(GL_ARRAY_BUFFER, 2*m_nbDarts*sizeof(VEC3), 0, GL_STREAM_DRAW);
@@ -134,22 +134,23 @@ void TopoRender::updateDataMap(typename PFP::MAP& mapx, const VertexAttribute<ty
 
 	unsigned int indexDC=0;
 
-	DartMarker mf(map);
+	DartMarker mf(mapx);
 	for(std::vector<Dart>::iterator id = vecDarts.begin(); id!= vecDarts.end(); id++)
 	{
 		Dart d = *id;
 		if (!mf.isMarked(d))
 		{
 			vecPos.clear();
-			if (!map.isBoundaryMarked2(d))
+			if (!mapx.isBoundaryMarked2(d))
 			{
-				VEC3 center = Algo::Surface::Geometry::faceCentroidELW<PFP>(mapx,d,positions);
+				//VEC3 center = Algo::Surface::Geometry::faceCentroidELW<PFP>(mapx,d,positions);
+				VEC3 center = Algo::Surface::Geometry::faceCentroid<PFP>(mapx,d,positions);
 				float k = 1.0f - kf;
 				Dart dd = d;