diff --git a/Apps/Examples/volumeExplorer.cpp b/Apps/Examples/volumeExplorer.cpp
index 7f40e623ea1383eceaa978838399850a1da87f70..77c62ff43ea974dccf5467f66f093049e4b5f91b 100644
--- a/Apps/Examples/volumeExplorer.cpp
+++ b/Apps/Examples/volumeExplorer.cpp
@@ -146,21 +146,21 @@ void MyQT::cb_Open()
 	size_t pos = filename.rfind(".");    // position of "." in filename
 	std::string extension = filename.substr(pos);
 
-	if(extension == std::string(".off"))
-	{
-		if(!Algo::Volume::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();
-		}
-	}
-	else
-	{
+//	if(extension == std::string(".off"))
+//	{
+//		if(!Algo::Volume::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();
+//		}
+//	}
+//	else
+//	{
 		if(!Algo::Volume::Import::importMesh<PFP>(myMap, filename, attrNames))
 		{
 			std::cerr << "could not import " << filename << std::endl ;
@@ -168,7 +168,7 @@ void MyQT::cb_Open()
 		}
 		else
 			position = myMap.getAttribute<PFP::VEC3,VERTEX>(attrNames[0]) ;
-	}
+//	}
 
 	color = myMap.addAttribute<PFP::VEC3, VOLUME>("color");
 
diff --git a/Apps/Tuto/tuto_oper2.cpp b/Apps/Tuto/tuto_oper2.cpp
index f63660947296bcb886a3dc17a66953bfd25f15f9..3b03e78c4d8ea6f2623c6529acd0d6dc88eb5afd 100644
--- a/Apps/Tuto/tuto_oper2.cpp
+++ b/Apps/Tuto/tuto_oper2.cpp
@@ -357,10 +357,9 @@ void MyQT::cb_Open()
 
 void MyQT::cb_Save()
 {
-	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;
+	std::string filename = selectFileSave("Export Off file ",".","(*.off)");
+	Algo::Surface::Export::exportOFF<PFP>(myMap,position,filename.c_str());
+	//std::cout << "could not save file : " << filename << std::endl;
 }
 
 void MyQT::importMesh(std::string& filename)
diff --git a/include/Algo/DecimationVolumes/approximator.h b/include/Algo/DecimationVolumes/approximator.h
index 1738fb698fc371c2ffe575b6fc906071290f1423..70f23a6aaab8f9b0db9536e2fdcca3e131ed849c 100644
--- a/include/Algo/DecimationVolumes/approximator.h
+++ b/include/Algo/DecimationVolumes/approximator.h
@@ -44,7 +44,10 @@ enum ApproximatorType
 {
 	A_QEM,
 	A_MidEdge,
-	A_hHalfCollapse
+	A_MidFace,
+	A_MidVolume,
+	A_hHalfEdgeCollapse,
+	A_QEM
 };
 
 template <typename PFP>
@@ -63,7 +66,7 @@ public:
 	{}
 	virtual ~ApproximatorGen()
 	{}
-	virtual const std::string& getApproximatedAttributeName() const = 0 ;
+	virtual const std::string& getApproximatedAttributeName(unsigned int index = 0) const = 0 ;
 	virtual ApproximatorType getType() const = 0 ;
 	virtual bool init() = 0 ;
 	virtual void approximate(Dart d) = 0 ;
@@ -73,67 +76,101 @@ public:
 } ;
 
 
-template <typename PFP, typename T>
+template <typename PFP, typename T, unsigned int ORBIT>
 class Approximator :  public ApproximatorGen<PFP>
 {
 public:
 	typedef typename PFP::MAP MAP ;
+	typedef typename PFP::VEC3 VEC3 ;
 	typedef typename PFP::REAL REAL;
 
 protected:
 	Predictor<PFP, T>* m_predictor ;
 
-	//Vertex attribute to be approximated
-	VertexAttribute<T>& m_attrV;
-	//Attribute to store approximation result
-	EdgeAttribute<T> m_approx;
-	// attribute to store detail information for reconstruction
-	EdgeAttribute<T> m_detail ;
-
-	T m_app;
+	std::vector<VertexAttribute<T>* > m_attrV ;	// vertex attributes to be approximated
+	std::vector<AttributeHandler<T,ORBIT> > m_approx ;	// attributes to store approximation result
+	std::vector<AttributeHandler<T,ORBIT> > m_detail ;	// attributes to store detail information for reconstruction
+	std::vector<T> m_app ;
 
 public:
-	Approximator(MAP& m, VertexAttribute<T>& a, Predictor<PFP, T>* predictor) :
-		ApproximatorGen<PFP>(m), m_predictor(predictor), m_attrV(a)
+	Approximator(MAP& m, std::vector<VertexAttribute<T>* > va, Predictor<PFP, T> * predictor) :
+		ApproximatorGen<PFP>(m), m_predictor(predictor), m_attrV(va)
 	{
-		std::stringstream aname ;
-		aname << "approx_" << m_attrV.name() ;
-		m_approx = this->m_map.template addAttribute<T, EDGE>(aname.str()) ;
-
-		if(m_predictor)	// if a predictor is associated to the approximator
-		{				// create an attribute to store the detail needed for reconstruction
-			std::stringstream dname ;
-			dname << "detail_" << m_attrV.name() ;
-			m_detail = this->m_map.template addAttribute<T, EDGE>(dname.str()) ;
+		const unsigned int& size = m_attrV.size() ;
+		assert(size > 0 || !"Approximator: no attributes provided") ;
+
+		m_approx.resize(size) ;
+		m_detail.resize(size) ;
+		m_app.resize(size) ;
+
+		for (unsigned int i = 0 ; i < size ; ++i)
+		{
+			if (!m_attrV[i]->isValid())
+				std::cerr << "Approximator Warning: attribute number " << i << " is not valid" << std::endl ;
+
+			std::stringstream aname ;
+			aname << "approx_" << m_attrV[i]->name() ;
+			m_approx[i] = this->m_map.template addAttribute<T, ORBIT>(aname.str()) ;
+
+			if(m_predictor)	// if predictors are associated to the approximator
+			{				// create attributes to store the details needed for reconstruction
+				std::stringstream dname ;
+				dname << "detail_" << m_attrV[i]->name() ;
+				m_detail[i] = this->m_map.template addAttribute<T, ORBIT>(dname.str()) ;
+			}
 		}
 	}
 
 	virtual ~Approximator()
 	{
-		this->m_map.template removeAttribute(m_approx) ;
-
-		if(m_predictor)
-			this->m_map.template removeAttribute(m_detail) ;
+		for (unsigned int i = 0 ; i < m_attrV.size() ; ++i)
+		{
+			this->m_map.template removeAttribute(m_approx[i]) ;
+			if(m_predictor)
+				this->m_map.template removeAttribute(m_detail[i]) ;
+		}
 	}
 
-	const std::string& getApproximatedAttributeName() const
+	const std::string& getApproximatedAttributeName(unsigned int index = 0) const
 	{
-		return m_attrV.name() ;
+		return m_attrV[index]->name() ;
 	}
 
-	const T& getApprox(Dart d) const
+	unsigned int getNbApproximated() const
 	{
-		return m_approx[d] ;
+		return m_attrV.size() ;
 	}
 
 	void saveApprox(Dart d)
 	{
-		m_app = m_approx[d] ;
+		for (unsigned int i = 0 ; i < m_attrV.size() ; ++i)
+			m_app[i] = m_approx[i][d] ;
 	}
 
 	void affectApprox(Dart d)
 	{
-		m_attrV[d] = m_app ;
+		for (unsigned int i = 0 ; i < m_attrV.size() ; ++i)
+			m_attrV[i]->operator[](d) = m_app[i] ;
+	}
+
+	const T& getApprox(Dart d, unsigned int index = 0) const
+	{
+		return m_approx[index][d] ;
+	}
+
+	const VertexAttribute<T>& getAttr(unsigned int index = 0) const
+	{
+		return *(m_attrV[index]) ;
+	}
+
+	std::vector<T> getAllApprox(Dart d) const
+	{
+		std::vector<T> res ;
+		res.resize(m_attrV.size()) ;
+		for (unsigned int i = 0 ; i < m_attrV.size() ; ++i)
+			res[i] = m_approx[i][d] ;
+
+		return res ;
 	}
 
 	const Predictor<PFP, T>* getPredictor() const
diff --git a/include/Algo/DecimationVolumes/geometryApproximator.h b/include/Algo/DecimationVolumes/geometryApproximator.h
index c58e3ce4e4a392eeac4d40c12d2c5ff0db6dc06b..10fd7803cf261b04cf3444ce883d0ee539aa1ffa 100644
--- a/include/Algo/DecimationVolumes/geometryApproximator.h
+++ b/include/Algo/DecimationVolumes/geometryApproximator.h
@@ -40,16 +40,18 @@ namespace Decimation
 {
 
 template <typename PFP>
-class Approximator_MidEdge : public Approximator<PFP, typename PFP::VEC3>
+class Approximator_MidEdge : public Approximator<PFP, typename PFP::VEC3, EDGE>
 {
 public:
 	typedef typename PFP::MAP MAP ;
 	typedef typename PFP::VEC3 VEC3 ;
 	typedef typename PFP::REAL REAL ;
 
-	Approximator_MidEdge(MAP& m, VertexAttribute<VEC3>& pos, Predictor<PFP, VEC3>* pred = NULL) :
-		Approximator<PFP, VEC3>(m, pos, pred)
-	{}
+	Approximator_MidEdge(MAP& m, std::vector<VertexAttribute<VEC3>* > pos, Predictor<PFP, VEC3>* pred = NULL) :
+		Approximator<PFP, VEC3, EDGE>(m, pos, pred)
+	{
+		assert(pos.size() > 0 || !"Approximator_MidEdge: attribute vector is empty") ;
+	}
 	~Approximator_MidEdge()
 	{}
 	ApproximatorType getType() const { return A_MidEdge ; }
@@ -58,25 +60,90 @@ public:
 } ;
 
 template <typename PFP>
-class Approximator_HalfCollapse : public Approximator<PFP, typename PFP::VEC3>
+class Approximator_MidFace : public Approximator<PFP, typename PFP::VEC3, FACE>
+{
+public:
+	typedef typename PFP::MAP MAP ;
+	typedef typename PFP::VEC3 VEC3 ;
+	typedef typename PFP::REAL REAL ;
+
+	Approximator_MidFace(MAP& m, std::vector<VertexAttribute<VEC3>* > pos, Predictor<PFP, VEC3>* pred = NULL) :
+		Approximator<PFP, VEC3, FACE>(m, pos, pred)
+	{
+		assert(pos.size() > 0 || !"Approximator_MidFace: attribute vector is empty") ;
+	}
+	~Approximator_MidFace()
+	{}
+	ApproximatorType getType() const { return A_MidFace ; }
+	bool init() ;
+	void approximate(Dart d) ;
+} ;
+
+template <typename PFP>
+class Approximator_MidVolume : public Approximator<PFP, typename PFP::VEC3, VOLUME>
 {
 public:
 	typedef typename PFP::MAP MAP ;
 	typedef typename PFP::VEC3 VEC3 ;
 	typedef typename PFP::REAL REAL ;
 
-	Approximator_HalfCollapse(MAP& m, VertexAttribute<VEC3>& pos, Predictor<PFP, VEC3>* pred = NULL) :
-		Approximator<PFP, VEC3>(m, pos, pred)
+	Approximator_MidVolume(MAP& m, std::vector<VertexAttribute<VEC3>* > pos, Predictor<PFP, VEC3>* pred = NULL) :
+		Approximator<PFP, VEC3, VOLUME>(m, pos, pred)
 	{
-		assert(pos.size() > 0 || !"Approximator_HalfCollapse: attribute vector is empty") ;
+		assert(pos.size() > 0 || !"Approximator_MidVolume: attribute vector is empty") ;
 	}
-	~Approximator_HalfCollapse()
+	~Approximator_MidVolume()
 	{}
-	ApproximatorType getType() const { return A_hHalfCollapse ; }
+	ApproximatorType getType() const { return A_MidVolume ; }
 	bool init() ;
 	void approximate(Dart d) ;
 } ;
 
+template <typename PFP>
+class Approximator_HalfEdgeCollapse : public Approximator<PFP, typename PFP::VEC3, DART>
+{
+public:
+	typedef typename PFP::MAP MAP ;
+	typedef typename PFP::VEC3 VEC3 ;
+	typedef typename PFP::REAL REAL ;
+
+	Approximator_HalfEdgeCollapse(MAP& m, std::vector<VertexAttribute<VEC3>* > pos, Predictor<PFP, VEC3>* pred = NULL) :
+		Approximator<PFP, VEC3, DART>(m, pos, pred)
+	{
+		assert(pos.size() > 0 || !"Approximator_HalfEdgeCollapse: attribute vector is empty") ;
+	}
+	~Approximator_HalfEdgeCollapse()
+	{}
+	ApproximatorType getType() const { return A_hHalfEdgeCollapse ; }
+	bool init() ;
+	void approximate(Dart d) ;
+} ;
+
+//template <typename PFP>
+//class Approximator_QEM : public Approximator<PFP, typename PFP::VEC3, EDGE>
+//{
+//public:
+//	typedef typename PFP::MAP MAP ;
+//	typedef typename PFP::VEC3 VEC3 ;
+//	typedef typename PFP::REAL REAL ;
+//
+//protected:
+//	VertexAttribute<Utils::Quadric<REAL> > m_quadric ;
+//
+//public:
+//	Approximator_QEM(MAP& m, std::vector<VertexAttribute<VEC3>* > pos, Predictor<PFP, VEC3>* pred = NULL) :
+//		Approximator<PFP, VEC3, EDGE>(m, pos, pred)
+//	{
+//		assert(pos.size() > 0 || !"Approximator_QEM: attribute vector is empty") ;
+//	}
+//	~Approximator_QEM()
+//	{}
+//	ApproximatorType getType() const { return A_QEM ; }
+//	bool init() ;
+//	void approximate(Dart d) ;
+//} ;
+
+
 
 } //namespace Decimation
 
diff --git a/include/Algo/DecimationVolumes/geometryApproximator.hpp b/include/Algo/DecimationVolumes/geometryApproximator.hpp
index 2c7fcb1b20ad770f4728ce021b87038c8b6e3cbf..eed66afb3ea2778ebf9be642a936125757ddec10 100644
--- a/include/Algo/DecimationVolumes/geometryApproximator.hpp
+++ b/include/Algo/DecimationVolumes/geometryApproximator.hpp
@@ -53,19 +53,78 @@ void Approximator_MidEdge<PFP>::approximate(Dart d)
 	MAP& m = this->m_map ;
 
 	// get some darts
-	Dart dd = m.phi2(d) ;
+	Dart d1 = m.phi1(d) ;
 
 	// get the contracted edge vertices positions
-	VEC3 v1 = this->m_attrV[d] ;
-	VEC3 v2 = this->m_attrV[dd] ;
+	VEC3 v1 = this->m_attrV[0]->operator[](d) ;
+	VEC3 v2 = this->m_attrV[0]->operator[](d1) ;
 
 	// Compute the approximated position
-	this->m_approx[d] = (v1 + v2) / REAL(2) ;
+	this->m_approx[0][d] = (v1 + v2) / REAL(2) ;
 
-//	if(this->m_predictor)
-//	{
-//
-//	}
+	//TODO predictor part
+}
+
+/************************************************************************************
+ *							         MID FACE                                       *
+ ************************************************************************************/
+
+template <typename PFP>
+bool Approximator_MidFace<PFP>::init()
+{
+	return true ;
+}
+
+template <typename PFP>
+void Approximator_MidFace<PFP>::approximate(Dart d)
+{
+	MAP& m = this->m_map ;
+
+	// get some darts
+	Dart d1 = m.phi1(d) ;
+	Dart d_1 = m.phi_1(d) ;
+
+	// get the contracted edge vertices positions
+	VEC3 v1 = this->m_attrV[0]->operator[](d) ;
+	VEC3 v2 = this->m_attrV[0]->operator[](d1) ;
+	VEC3 v3 = this->m_attrV[0]->operator[](d_1) ;
+
+	// Compute the approximated position
+	this->m_approx[0][d] = (v1 + v2 + v3) / REAL(3) ;
+
+	//TODO predictor part
+}
+
+/************************************************************************************
+ *							       	MID VOLUME                                      *
+ ************************************************************************************/
+
+template <typename PFP>
+bool Approximator_MidVolume<PFP>::init()
+{
+	return true ;
+}
+
+template <typename PFP>
+void Approximator_MidVolume<PFP>::approximate(Dart d)
+{
+	MAP& m = this->m_map ;
+
+	// get some darts
+	Dart d1 = m.phi1(d) ;
+	Dart d_1 = m.phi_1(d) ;
+	Dart d2_1 = m.phi_1(m.phi2(d)) ;
+
+	// get the contracted edge vertices positions
+	VEC3 v1 = this->m_attrV[0]->operator[](d) ;
+	VEC3 v2 = this->m_attrV[0]->operator[](d1) ;
+	VEC3 v3 = this->m_attrV[0]->operator[](d_1) ;
+	VEC3 v4 = this->m_attrV[0]->operator[](d2_1) ;
+
+	// Compute the approximated position
+	this->m_approx[0][d] = (v1 + v2 + v3 + v4) / REAL(4) ;
+
+	//TODO predictor part
 }
 
 /************************************************************************************
@@ -73,54 +132,37 @@ void Approximator_MidEdge<PFP>::approximate(Dart d)
  ************************************************************************************/
 
 template <typename PFP>
-bool Approximator_HalfCollapse<PFP>::init()
+bool Approximator_HalfEdgeCollapse<PFP>::init()
 {
-//	if(this->m_predictor)
-//	{
-//		if(! ( this->m_predictor->getType() == P_HalfCollapse ) )
-//		{
-//			return false ;
-//		}
-//	}
 	return true ;
 }
 
 template <typename PFP>
-void Approximator_HalfCollapse<PFP>::approximate(Dart d)
+void Approximator_HalfEdgeCollapse<PFP>::approximate(Dart d)
 {
 	MAP& m = this->m_map ;
 
-	this->m_approx[d] = this->m_attrV[d];
+	for (unsigned int i = 0 ; i < this->m_attrV.size() ; ++i)
+		this->m_approx[i][d] = this->m_attrV[i]->operator[](d) ;
+
+	//TODO predictor part
+}
 
+///************************************************************************************
+// *                            QUADRIC ERROR METRIC                                  *
+// ************************************************************************************/
+//template <typename PFP>
+//bool Approximator_QEM<PFP>::init()
+//{
+//	m_quadric = this->m_map.template getAttribute<Utils::Quadric<REAL>, VERTEX>("QEMquadric") ;
+//	// Does not require to be valid (if it is not, altenatives will be used).
+//
 //	if(this->m_predictor)
 //	{
-//		Dart dd = m.phi2(d) ;
-//		Dart d2 = m.phi2(m.phi_1(d)) ;
-//		Dart dd2 = m.phi2(m.phi_1(dd)) ;
-//
-//		VEC3 v2 = this->m_attrV[0]->operator[](dd) ;
-//
-//		// temporary edge collapse
-//		m.extractTrianglePair(d) ;
-//		unsigned int newV = m.template embedNewCell<VERTEX>(d2) ;
-//		for (unsigned int i = 0 ; i < this->m_attrV.size() ; ++i)
-//		{
-//			this->m_attrV[i]->operator[](newV) = this->m_approx[i][d] ;
-//		}
-//
-//		// compute the detail vector
-//		this->m_predictor->predict(d2, dd2) ;
-//		for (unsigned int i = 0 ; i < this->m_attrV.size() ; ++i)
-//		{
-//			this->m_detail[i][d] = v2 - this->m_predictor->getPredict(1) ;
-//		}
-//
-//		// vertex split to reset the initial connectivity and embeddings
-//		m.insertTrianglePair(d, d2, dd2) ;
-//		m.template embedOrbit<VERTEX>(d, m.template getEmbedding<VERTEX>(d)) ;
-//		m.template embedOrbit<VERTEX>(dd, m.template getEmbedding<VERTEX>(dd)) ;
+//		return false ;
 //	}
-}
+//	return true ;
+//}
 
 } //end namespace Decimation
 
diff --git a/include/Algo/DecimationVolumes/selector.h b/include/Algo/DecimationVolumes/selector.h
index 3fb5b8dd9924382b4157d56c615644066cf9b9dc..2a92202e6b04972a44c2c9dcafe7f64a7326aea5 100644
--- a/include/Algo/DecimationVolumes/selector.h
+++ b/include/Algo/DecimationVolumes/selector.h
@@ -26,7 +26,7 @@ enum SelectorType
 } ;
 
 template <typename PFP> class ApproximatorGen ;
-template <typename PFP, typename T> class Approximator ;
+template <typename PFP, typename T, unsigned int ORBIT> class Approximator ;
 
 /********************************************************************************
  *				 				Parent Selector									*
@@ -62,13 +62,13 @@ public:
 	virtual void updateWithoutCollapse() = 0;
 };
 
-} //end namespace Decimation
+} // namespace Decimation
 
-} //namespace Volume
+} // namespace Volume
 
-} //end namespace Algo
+} // namespace Algo
 
-} //end namespace CGoGN
+} // namespace CGoGN
 
 
 #endif
diff --git a/include/Algo/ImplicitHierarchicalMesh/ihm.h b/include/Algo/ImplicitHierarchicalMesh/ihm.h
index 9fd92a6d8e810f984a0167057ef3a0e9fa25541f..7d7974bdcdd834f319778a5f98d5d09ae8ad30dc 100644
--- a/include/Algo/ImplicitHierarchicalMesh/ihm.h
+++ b/include/Algo/ImplicitHierarchicalMesh/ihm.h
@@ -142,6 +142,7 @@ public:
 
 	void setDartLevel(Dart d, unsigned int i) ;
 
+
 	/***************************************************
 	 *             EDGE ID MANAGEMENT                  *
 	 ***************************************************/
@@ -160,6 +161,8 @@ public:
 
 	void setEdgeId(Dart d, unsigned int i) ;
 
+	unsigned int getMaxEdgeId();
+
 	/***************************************************
 	 *               CELLS INFORMATION                 *
 	 ***************************************************/
diff --git a/include/Algo/ImplicitHierarchicalMesh/ihm.hpp b/include/Algo/ImplicitHierarchicalMesh/ihm.hpp
index 477f15d9a0ff5b72098d33fc84ed1d0b8619fe96..eb468c156295055f51baa2e6c477b28e576a2855 100644
--- a/include/Algo/ImplicitHierarchicalMesh/ihm.hpp
+++ b/include/Algo/ImplicitHierarchicalMesh/ihm.hpp
@@ -326,6 +326,11 @@ inline void ImplicitHierarchicalMap::setEdgeId(Dart d, unsigned int i)
 	m_edgeId[d] = i ;
 }
 
+inline unsigned int ImplicitHierarchicalMap::getMaxEdgeId()
+{
+        return m_idCount;
+}
+
 /***************************************************
  *               CELLS INFORMATION                 *
  ***************************************************/
diff --git a/include/Algo/ImplicitHierarchicalMesh/ihm3.hpp b/include/Algo/ImplicitHierarchicalMesh/ihm3.hpp
index 64339aaa7e73a25c35cbbdf6dc9756b2d34e229e..74f80fcc95f56a07b705ba3782d66ea8a41d8866 100644
--- a/include/Algo/ImplicitHierarchicalMesh/ihm3.hpp
+++ b/include/Algo/ImplicitHierarchicalMesh/ihm3.hpp
@@ -146,6 +146,7 @@ inline Dart ImplicitHierarchicalMap3::phi2bis(Dart d)
 
 	it = Map3::phi2(it) ;
 
+	/* du cote des volumes non subdivise (subdiv adapt) */
 	if(m_faceId[it] == faceId)
 		return it;
 	else
diff --git a/include/Algo/ImplicitHierarchicalMesh/subdivision.hpp b/include/Algo/ImplicitHierarchicalMesh/subdivision.hpp
index c0b35f0158e6d918559343dc00b2dc5955ef5cba..77a26d99384bb1a912b6b4c421b8b687d3061a00 100644
--- a/include/Algo/ImplicitHierarchicalMesh/subdivision.hpp
+++ b/include/Algo/ImplicitHierarchicalMesh/subdivision.hpp
@@ -72,6 +72,8 @@ void subdivideFace(typename PFP::MAP& map, Dart d, VertexAttribute<typename PFP:
 	unsigned int cur = map.getCurrentLevel() ;
 	map.setCurrentLevel(fLevel) ;		// go to the level of the face to subdivide its edges
 
+	std::cout << "subdiv" << std::endl;
+
 	unsigned int degree = 0 ;
 	typename PFP::VEC3 p ;
 	Dart it = old ;
@@ -92,38 +94,82 @@ void subdivideFace(typename PFP::MAP& map, Dart d, VertexAttribute<typename PFP:
 		Dart dd = map.phi1(old) ;
 		Dart e = map.phi1(map.phi1(dd)) ;
 		map.splitFace(dd, e) ;					// insert a new edge
-		unsigned int id = map.getNewEdgeId() ;
-		map.setEdgeId(map.phi_1(dd), id) ;		// set the edge id of the inserted
-		map.setEdgeId(map.phi_1(e), id) ;		// edge to the next available id
+		//unsigned int id = map.getNewEdgeId() ;
+		//map.setEdgeId(map.phi_1(dd), id) ;		// set the edge id of the inserted
+		//map.setEdgeId(map.phi_1(e), id) ;		// edge to the next available id
 
 		dd = e ;
 		e = map.phi1(map.phi1(dd)) ;
 		map.splitFace(dd, e) ;
-		id = map.getNewEdgeId() ;
-		map.setEdgeId(map.phi_1(dd), id) ;
-		map.setEdgeId(map.phi_1(e), id) ;
+		//id = map.getNewEdgeId() ;
+		//map.setEdgeId(map.phi_1(dd), id) ;
+		//map.setEdgeId(map.phi_1(e), id) ;
 
 		dd = e ;
 		e = map.phi1(map.phi1(dd)) ;
 		map.splitFace(dd, e) ;
-		id = map.getNewEdgeId() ;
-		map.setEdgeId(map.phi_1(dd), id) ;
-		map.setEdgeId(map.phi_1(e), id) ;
+		//id = map.getNewEdgeId() ;
+		//map.setEdgeId(map.phi_1(dd), id) ;
+		//map.setEdgeId(map.phi_1(e), id) ;
+
+
+		Dart stop = map.phi2(map.phi1(old));
+		Dart dit = stop;
+		do
+		{
+			unsigned int dId = map.getEdgeId(map.phi_1(map.phi2(dit)));
+			unsigned int eId = map.getEdgeId(map.phi1(map.phi2(dit)));
+
+			unsigned int t = dId + eId;
+
+			if(t == 0)
+			{
+				map.setEdgeId(dit, 1);
+				map.setEdgeId(map.phi2(dit), 1);
+			}
+			else if(t == 1)
+			{
+				map.setEdgeId(dit, 2);
+				map.setEdgeId(map.phi2(dit), 2);
+			}
+			else if(t == 2)
+			{
+			    if(dId == eId)
+			    {
+				std::cout << "plop" << std::endl;
+				map.setEdgeId(dit, 0);
+				map.setEdgeId(map.phi2(dit), 0);
+			    }
+			    else
+			    {
+				map.setEdgeId(dit, 1);
+				map.setEdgeId(map.phi2(dit), 1);
+			    }
+			}
+			else if(t == 3)
+			{
+				map.setEdgeId(dit, 0);
+				map.setEdgeId(map.phi2(dit), 0);
+			}
+
+			dit = map.phi1(dit);
+		}while(dit != stop);
+
 	}
 	else											// if subdividing a polygonal face
 	{
 		Dart dd = map.phi1(old) ;
 		map.splitFace(dd, map.phi1(map.phi1(dd))) ;	// insert a first edge
 		Dart ne = map.alpha1(dd) ;
-		Dart ne2 = map.phi2(ne) ;
+		//Dart ne2 = map.phi2(ne) ;
 
 		map.cutEdge(ne) ;							// cut the new edge to insert the central vertex
-		unsigned int id = map.getNewEdgeId() ;
-		map.setEdgeId(ne, id) ;
-		map.setEdgeId(map.phi2(ne), id) ;			// set the edge id of the inserted
-		id = map.getNewEdgeId() ;
-		map.setEdgeId(ne2, id) ;					// edges to the next available ids
-		map.setEdgeId(map.phi2(ne2), id) ;
+		//unsigned int id = map.getNewEdgeId() ;
+		//map.setEdgeId(ne, id) ;
+		//map.setEdgeId(map.phi2(ne), id) ;			// set the edge id of the inserted
+		//id = map.getNewEdgeId() ;
+		//map.setEdgeId(ne2, id) ;					// edges to the next available ids
+		//map.setEdgeId(map.phi2(ne2), id) ;
 
 		position[map.phi2(ne)] = p ;
 
@@ -132,12 +178,30 @@ void subdivideFace(typename PFP::MAP& map, Dart d, VertexAttribute<typename PFP:
 		{											// linked to the central vertex
 			Dart next = map.phi1(map.phi1(dd)) ;
 			map.splitFace(map.phi1(ne), dd) ;
-			Dart nne = map.alpha1(dd) ;
-			id = map.getNewEdgeId() ;
-			map.setEdgeId(nne, id) ;
-			map.setEdgeId(map.phi2(nne), id) ;
+			//Dart nne = map.alpha1(dd) ;
+			//id = map.getNewEdgeId() ;
+			//map.setEdgeId(nne, id) ;
+			//map.setEdgeId(map.phi2(nne), id) ;
 			dd = next ;
 		}
+
+		Dart dit = map.phi2(ne);
+		do
+		{
+			unsigned int eId = map.getEdgeId(map.phi1(dit));
+			if(eId == 0)
+			{
+				map.setEdgeId(dit, 1);
+				map.setEdgeId(map.phi2(dit), 1);
+			}
+			else if(eId == 1)
+			{
+				map.setEdgeId(dit, 0);
+				map.setEdgeId(map.phi2(dit), 0);
+			}
+			dit = map.phi2(map.phi_1(dit));
+		}
+		while(dit != map.phi2(ne));
 	}
 
 	map.setCurrentLevel(cur) ;
diff --git a/include/Algo/ImplicitHierarchicalMesh/subdivision3.hpp b/include/Algo/ImplicitHierarchicalMesh/subdivision3.hpp
index c7b802e9ceb6c75d6cff7c604bcf94ce061dab5b..23d9b6bce462d9cc746e8aae1d8b91e91968847f 100644
--- a/include/Algo/ImplicitHierarchicalMesh/subdivision3.hpp
+++ b/include/Algo/ImplicitHierarchicalMesh/subdivision3.hpp
@@ -538,7 +538,7 @@ Dart subdivideVolumeClassic2(typename PFP::MAP& map, Dart d, AttributeHandler<ty
 	/*
 	 * Compute volume centroid
 	 */
-	typename PFP::VEC3 volCenter =  Algo::Geometry::volumeCentroid<PFP>(map, old, position);
+	typename PFP::VEC3 volCenter =  Algo::Surface::Geometry::volumeCentroid<PFP>(map, old, position);
 
 	Traversor3WV<typename PFP::MAP> traV(map, old);
 
@@ -672,7 +672,7 @@ void subdivideLoop(typename PFP::MAP& map, Dart d, AttributeHandler<typename PFP
 	/*
 	 * Compute volume centroid
 	 */
-	typename PFP::VEC3 volCenter =  Algo::Geometry::volumeCentroid<PFP>(map, old, position);
+	typename PFP::VEC3 volCenter =  Algo::Surface::Geometry::volumeCentroid<PFP>(map, old, position);
 
 	/*
 	 * Subdivide Faces
diff --git a/include/Algo/Import/importObjEle.hpp b/include/Algo/Import/importObjEle.hpp
index eb64af7399046a44c51f364006663dda4f3a75c7..6f725edca2096dcf54eab437ba72307ea1d0171a 100644
--- a/include/Algo/Import/importObjEle.hpp
+++ b/include/Algo/Import/importObjEle.hpp
@@ -156,8 +156,14 @@ bool importOFFWithELERegions(typename PFP::MAP& map, const std::string& filename
 		oss >> pt[2];
 		oss >> pt[3];
 
+//		oss >> pt[1];
+//		oss >> pt[2];
+//		oss >> pt[3];
+//		oss >> pt[0];
+
+
 		//regions ?
-		oss >> nbe;
+		//oss >> nbe;
 
 		// Embed three vertices
 		for(unsigned int j = 0 ; j < 3 ; ++j)
@@ -198,44 +204,44 @@ bool importOFFWithELERegions(typename PFP::MAP& map, const std::string& filename
 	foff.close();
 	fele.close();
 
-	//Association des phi3
-	unsigned int nbBoundaryFaces = 0 ;
-	for (Dart d = map.begin(); d != map.end(); map.next(d))
-	{
-		if (m.isMarked(d))
-		{
-			std::vector<Dart>& vec = vecDartsPerVertex[map.phi1(d)];
-
-			Dart good_dart = NIL;
-			for(typename std::vector<Dart>::iterator it = vec.begin(); it != vec.end() && good_dart == NIL; ++it)
-			{
-				if(map.template getEmbedding<VERTEX>(map.phi1(*it)) == map.template getEmbedding<VERTEX>(d) &&
-				   map.template getEmbedding<VERTEX>(map.phi_1(*it)) == map.template getEmbedding<VERTEX>(map.phi_1(d)) /*&&
-				   map.template getEmbedding<VERTEX>(*it) == map.template getEmbedding<VERTEX>(map.phi1(d)) */)
-				{
-					good_dart = *it ;
-				}
-			}
-
-			if (good_dart != NIL)
-			{
-				map.sewVolumes(d, good_dart, false);
-				m.template unmarkOrbit<FACE>(d);
-			}
-			else
-			{
-				m.template unmarkOrbit<PFP::MAP::FACE_OF_PARENT>(d);
-				++nbBoundaryFaces;
-			}
-		}
-	}
-
-	if (nbBoundaryFaces > 0)
-	{
-		std::cout << "closing" << std::endl ;
-		map.closeMap();
-		CGoGNout << "Map closed (" << nbBoundaryFaces << " boundary faces)" << CGoGNendl;
-	}
+//	//Association des phi3
+//	unsigned int nbBoundaryFaces = 0 ;
+//	for (Dart d = map.begin(); d != map.end(); map.next(d))
+//	{
+//		if (m.isMarked(d))
+//		{
+//			std::vector<Dart>& vec = vecDartsPerVertex[map.phi1(d)];
+//
+//			Dart good_dart = NIL;
+//			for(typename std::vector<Dart>::iterator it = vec.begin(); it != vec.end() && good_dart == NIL; ++it)
+//			{
+//				if(map.template getEmbedding<VERTEX>(map.phi1(*it)) == map.template getEmbedding<VERTEX>(d) &&
+//				   map.template getEmbedding<VERTEX>(map.phi_1(*it)) == map.template getEmbedding<VERTEX>(map.phi_1(d)) /*&&
+//				   map.template getEmbedding<VERTEX>(*it) == map.template getEmbedding<VERTEX>(map.phi1(d)) */)
+//				{
+//					good_dart = *it ;
+//				}
+//			}
+//
+//			if (good_dart != NIL)
+//			{
+//				map.sewVolumes(d, good_dart, false);
+//				m.template unmarkOrbit<FACE>(d);
+//			}
+//			else
+//			{
+//				m.template unmarkOrbit<PFP::MAP::FACE_OF_PARENT>(d);
+//				++nbBoundaryFaces;
+//			}
+//		}
+//	}
+//
+//	if (nbBoundaryFaces > 0)
+//	{
+//		std::cout << "closing" << std::endl ;
+//		map.closeMap();
+//		CGoGNout << "Map closed (" << nbBoundaryFaces << " boundary faces)" << CGoGNendl;
+//	}
 
 	return true;
 }
diff --git a/include/Algo/Modelisation/subdivision3.h b/include/Algo/Modelisation/subdivision3.h
index 05d7a5a7ef70b85a2d13900bd0692a78308a3f22..2ac20c64dc3f4e24d0e73694687d655bcb915fd9 100644
--- a/include/Algo/Modelisation/subdivision3.h
+++ b/include/Algo/Modelisation/subdivision3.h
@@ -100,6 +100,9 @@ void catmullClarkVol(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3>
 template <typename PFP>
 void sqrt3Vol(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3>& position);
 
+template <typename PFP>
+void relaxation(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3>& position);
+
 template <typename PFP>
 void computeDual(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3>& position);
 
diff --git a/include/Algo/Modelisation/subdivision3.hpp b/include/Algo/Modelisation/subdivision3.hpp
index a8319b71a7ebc62576f5e032a0d9f3f6231de466..2fa39fc30b66b576a8fe4ffada0f3d63b980254e 100644
--- a/include/Algo/Modelisation/subdivision3.hpp
+++ b/include/Algo/Modelisation/subdivision3.hpp
@@ -853,6 +853,96 @@ void sqrt3Vol(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3>& posit
 //	nlDeleteContext(nlContext);
 }
 
+
+// solving Ax = b
+
+template <typename PFP>
+void relaxation(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3>& position)
+{
+	VertexAttribute<unsigned int> indexV = map.template getAttribute<unsigned int, VERTEX>("indexV");
+	if(!indexV.isValid())
+		indexV = map.template addAttribute<unsigned int, VERTEX>("indexV");
+
+	unsigned int nb_vertices = map.template computeIndexCells<VERTEX>(indexV);
+
+	//uniform weight
+	float weight = 1.0;
+
+	NLContext nlContext = nlNewContext();
+	nlSolverParameteri(NL_NB_VARIABLES, nb_vertices);
+	nlSolverParameteri(NL_LEAST_SQUARES, NL_TRUE);
+	nlSolverParameteri(NL_SOLVER, NL_CHOLMOD_EXT);
+
+//	nlMakeCurrent(nlContext);
+	if(nlGetCurrentState() == NL_STATE_INITIAL)
+		nlBegin(NL_SYSTEM) ;
+
+	for(unsigned int coord = 0; coord < 3; ++coord)
+	{
+		std::cout << "coord " << coord << std::flush;
+		//setup variables
+		TraversorV<typename PFP::MAP> tv(map);
+		for(Dart dit = tv.begin() ; dit != tv.end() ; dit = tv.next())
+		{
+			nlSetVariable(indexV[dit], (position[dit])[coord]);
+
+			if(map.isBoundaryVertex(dit))
+				nlLockVariable(indexV[dit]);
+		}
+
+		std::cout << "... variables set... " << std::flush;
+
+		nlBegin(NL_MATRIX) ;
+
+		nlEnable(NL_NORMALIZE_ROWS) ;
+
+		TraversorV<typename PFP::MAP> tv2(map);
+		for(Dart dit = tv2.begin() ; dit != tv2.end() ; dit = tv2.next())
+		{
+			if(!map.isBoundaryVertex(dit))
+			{
+				nlRowParameterd(NL_RIGHT_HAND_SIDE, 0) ; //b[i]
+				//nlRowParameterd(NL_ROW_SCALING, weight) ;
+
+				nlBegin(NL_ROW) ;
+
+				float sum = 0;
+				Traversor3VVaE<typename PFP::MAP> tvvae(map, dit);
+				for(Dart ditvvae = tvvae.begin() ; ditvvae != tvvae.end() ; ditvvae = tvvae.next())
+				{
+					nlCoefficient(indexV[ditvvae], weight);
+					sum += weight;
+				}
+
+				nlCoefficient(indexV[dit], -sum) ;
+				nlEnd(NL_ROW) ;
+			}
+		}
+
+		nlDisable(NL_NORMALIZE_ROWS) ;
+
+		nlEnd(NL_MATRIX) ;
+
+		nlEnd(NL_SYSTEM) ;
+		std::cout << "... system built... " << std::flush;
+
+		nlSolve();
+		std::cout << "... system solved... " << std::flush;
+
+		//results
+		TraversorV<typename PFP::MAP> tv3(map);
+		for(Dart dit = tv3.begin() ; dit != tv3.end() ; dit = tv3.next())
+		{
+			position[dit][coord] = nlGetVariable(indexV[dit]);
+		}
+
+		nlReset(NL_TRUE) ;
+		std::cout << "... done" << std::endl;
+	}
+
+	nlDeleteContext(nlContext);
+}
+
 template <typename PFP>
 void computeDual(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3>& position)
 {
diff --git a/include/Algo/Multiresolution/Map2MR/lerpAttributes.h b/include/Algo/Multiresolution/Map2MR/lerpAttributes.h
index b53fbdfb4804684941d1d7d8755f9a49378feb29..7f5251081c83719075a7c2dec4b24bf77a85d40e 100644
--- a/include/Algo/Multiresolution/Map2MR/lerpAttributes.h
+++ b/include/Algo/Multiresolution/Map2MR/lerpAttributes.h
@@ -46,7 +46,7 @@ namespace MR
  *********************************************************************************/
 
 template <typename PFP>
-class vertexFilter : public Filter
+class vertexFilter : public Algo::MR::Filter
 {
 protected:
 	typename PFP::MAP& m_map ;
@@ -76,7 +76,7 @@ public:
 
 			}while(!found && dit!=d);
 
-			m_map.template embedOrbit<VERTEX>(dres, m_map.template getEmbedding<VERTEX>(dres));
+			m_map.template setOrbitEmbedding<VERTEX>(dres, m_map.template getEmbedding<VERTEX>(dres));
 		}
 
 //		SelectorEdgeLevel<typename PFP::MAP> ml(m_map, m_map.getCurrentLevel());
@@ -90,7 +90,7 @@ public:
 };
 
 template <typename PFP>
-class LerpVertexSynthesisFilter : public Filter
+class LerpVertexSynthesisFilter : public Algo::MR::Filter
 {
 protected:
 	typename PFP::MAP& m_map ;
@@ -140,7 +140,7 @@ public:
 
 
 template <typename PFP>
-class LerpVertexAnalysisFilter : public Filter
+class LerpVertexAnalysisFilter : public Algo::MR::Filter
 {
 protected:
 	typename PFP::MAP& m_map ;
diff --git a/include/Algo/Multiresolution/Map2MR/map2MR_PM.hpp b/include/Algo/Multiresolution/Map2MR/map2MR_PM.hpp
index 7b45e52d421a356bb71dc8a3ccd08ff328c9a711..732ee49fa2ad9c4436ae58a1e69c0b8570682445 100644
--- a/include/Algo/Multiresolution/Map2MR/map2MR_PM.hpp
+++ b/include/Algo/Multiresolution/Map2MR/map2MR_PM.hpp
@@ -88,6 +88,12 @@ void Map2MR_PM<PFP>::createPM(Algo::Surface::Decimation::SelectorType s, Algo::S
 			m_predictors.push_back(pred) ;
 			m_approximators.push_back(new Algo::Surface::Decimation::Approximator_MidEdge<PFP>(m_map, pos_v, pred)) ;
 			break ; }
+		case Algo::Surface::Decimation::A_NormalArea :
+		case Algo::Surface::Decimation::A_ColorQEMext :
+		case Algo::Surface::Decimation::A_hQEM :
+		case Algo::Surface::Decimation::A_hLightfieldHalf :
+		case Algo::Surface::Decimation::A_Lightfield :
+		default: break;
 	}
 	CGoGNout << "..done" << CGoGNendl ;
 
@@ -109,9 +115,25 @@ void Map2MR_PM<PFP>::createPM(Algo::Surface::Decimation::SelectorType s, Algo::S
 	case Algo::Surface::Decimation::S_MinDetail : {
 		m_selector = new Algo::Surface::Decimation::EdgeSelector_MinDetail<PFP>(m_map, m_position, m_approximators) ;
 		break ; }
-	case Algo::Surface::Decimation::S_Curvature : {
+	case Algo::Surface::Decimation::S_CurvatureTensor : {
 		m_selector = new Algo::Surface::Decimation::EdgeSelector_Curvature<PFP>(m_map, m_position, m_approximators) ;
 		break ; }
+	case Algo::Surface::Decimation::S_QEMml :
+	case Algo::Surface::Decimation::S_Curvature :
+	case Algo::Surface::Decimation::S_NormalArea :
+	case Algo::Surface::Decimation::S_ColorNaive :
+	case Algo::Surface::Decimation::S_QEMextColor :
+	case Algo::Surface::Decimation::S_hQEMextColor :
+	case Algo::Surface::Decimation::S_hQEMml :
+	case Algo::Surface::Decimation::S_Lightfield :
+	case Algo::Surface::Decimation::S_hLightfield :
+	case Algo::Surface::Decimation::S_hLightfieldExp :
+	case Algo::Surface::Decimation::S_hLightfieldKCL :
+	case Algo::Surface::Decimation::S_hColorExperimental :
+	case Algo::Surface::Decimation::S_hLFexperimental :
+	case Algo::Surface::Decimation::S_hColorPerFace :
+	case Algo::Surface::Decimation::S_hLFperFace :
+	default: break;
 	}
 	CGoGNout << "..done" << CGoGNendl ;
 
@@ -291,6 +313,8 @@ Dart Map2MR_PM<PFP>::vertexOrigin(Dart d)
 //		dit = m_map.phi2(m_map.phi_1(dit));
 //	}
 //	while(dit != d);
+
+	return NIL;
 }
 
 //template <typename PFP>
diff --git a/src/Algo/ImplicitHierarchicalMesh/ihm.cpp b/src/Algo/ImplicitHierarchicalMesh/ihm.cpp
index e757d9f714e08377f597f73517d33c242084d54b..b67f157a624b580f8973a5cb09bcfd20c5658414 100644
--- a/src/Algo/ImplicitHierarchicalMesh/ihm.cpp
+++ b/src/Algo/ImplicitHierarchicalMesh/ihm.cpp
@@ -66,7 +66,14 @@ void ImplicitHierarchicalMap::clear(bool removeAttrib)
 
 void ImplicitHierarchicalMap::initImplicitProperties()
 {
-	initEdgeId() ;
+	//initEdgeId() ;
+
+	//init each edge Id at 0
+	TraversorE<ImplicitHierarchicalMap> te(*this);
+	for(Dart dit = te.begin() ; dit != te.next() ; dit = te.next())
+	{
+		m_edgeId[dit] = 0;
+	}
 
 	for(unsigned int orbit = 0; orbit < NB_ORBITS; ++orbit)
 	{
@@ -161,20 +168,21 @@ unsigned int ImplicitHierarchicalMap::faceLevel(Dart d)
 	unsigned int cur = m_curLevel ;
 	m_curLevel = fLevel ;
 
-	unsigned int nbSubd = 0 ;
-	it = old ;
-	unsigned int eId = m_edgeId[old] ;			// the particular case of a face
-	do											// with all neighboring faces regularly subdivided
-	{											// but not the face itself
-		++nbSubd ;								// is treated here
-		it = phi1(it) ;
-	} while(m_edgeId[it] == eId) ;
-
-	while(nbSubd > 1)
-	{
-		nbSubd /= 2 ;
-		--fLevel ;
-	}
+//	unsigned int nbSubd = 0 ;
+//	it = old ;
+//	unsigned int eId = m_edgeId[old] ;			// the particular case of a face
+//	do											// with all neighboring faces regularly subdivided
+//	{											// but not the face itself
+//		++nbSubd ;								// is treated here
+//		 std::cout << "plop" << std::endl;
+//		it = phi1(it) ;
+//	} while(m_edgeId[it] == eId) ;
+
+//	while(nbSubd > 1)
+//	{
+//		nbSubd /= 2 ;
+//		--fLevel ;
+//	}
 
 	m_curLevel = cur ;