From 1538d00ef07c252e44c1761d0b37052ac98da9d7 Mon Sep 17 00:00:00 2001
From: untereiner <lionel.untereiner@unistra.fr>
Date: Wed, 18 May 2011 14:32:54 +0200
Subject: [PATCH] pas mal de modifications sur les IHM3 et l'import pour
 l'InESS

---
 include/Algo/Export/export.h                  |   7 +
 include/Algo/Export/export.hpp                |  17 +
 include/Algo/ImplicitHierarchicalMesh/ihm3.h  |  14 +-
 .../Algo/ImplicitHierarchicalMesh/ihm3.hpp    |  14 +-
 .../ImplicitHierarchicalMesh/subdivision3.hpp |   2 +-
 include/Algo/Import/import.h                  |   2 +-
 include/Algo/Import/importInESS.hpp           | 402 +++++++----------
 include/Algo/Modelisation/polyhedron.hpp      |   2 +-
 include/Algo/Modelisation/tetrahedron.h       |  23 +-
 include/Algo/Modelisation/tetrahedron.hpp     | 425 ++++++++++--------
 include/Geometry/bounding_box.hpp             |   2 +-
 include/Topology/generic/embeddedMap3.h       |  13 -
 include/Topology/generic/embeddedMap3.hpp     |  27 --
 13 files changed, 466 insertions(+), 484 deletions(-)

diff --git a/include/Algo/Export/export.h b/include/Algo/Export/export.h
index f86a2409d..5de946a53 100644
--- a/include/Algo/Export/export.h
+++ b/include/Algo/Export/export.h
@@ -84,6 +84,13 @@ bool exportCTM(typename PFP::MAP& the_map, const typename PFP::TVEC3& position,
 template <typename PFP>
 bool exportPLYPTM(typename PFP::MAP& map, const char* filename, const typename PFP::TVEC3& position, const typename PFP::TVEC3 frame[3], const typename PFP::TVEC3 colorPTM[6], const FunctorSelect& good = SelectorTrue()) ;
 
+
+/**
+ *  export pout l'InESS
+ */
+template <typename PFP>
+bool exportInESS(typename PFP::MAP& map, const char *filename, const typename PFP::TVEC3& position);
+
 } // namespace Export
 
 } // namespace Algo
diff --git a/include/Algo/Export/export.hpp b/include/Algo/Export/export.hpp
index 4ec2dede4..3307937f5 100644
--- a/include/Algo/Export/export.hpp
+++ b/include/Algo/Export/export.hpp
@@ -515,6 +515,23 @@ bool exportPLYPTM(typename PFP::MAP& map, const char* filename, const typename P
 	return true ;
 }*/
 
+
+template <typename PFP>
+bool exportInESS(typename PFP::MAP& map, const char *filename, const typename PFP::TVEC3& position)
+{
+	typedef typename PFP::MAP MAP;
+	typedef typename PFP::VEC3 VEC3;
+
+	std::ofstream out(filename, std::ios::out) ;
+	if (!out.good())
+	{
+		CGoGNerr << "Unable to open file " << CGoGNendl ;
+		return false ;
+	}
+
+
+}
+
 } // namespace Export
 
 } // namespace Algo
diff --git a/include/Algo/ImplicitHierarchicalMesh/ihm3.h b/include/Algo/ImplicitHierarchicalMesh/ihm3.h
index e82efae60..77a1f9cd6 100644
--- a/include/Algo/ImplicitHierarchicalMesh/ihm3.h
+++ b/include/Algo/ImplicitHierarchicalMesh/ihm3.h
@@ -106,17 +106,17 @@ public:
 
 	virtual void next(Dart& d) ;
 
-	virtual bool foreach_dart_of_vertex(Dart d, FunctorType& f) ;
+	virtual bool foreach_dart_of_vertex(Dart d, FunctorType& f, unsigned int thread = 0) ;
 
-	virtual bool foreach_dart_of_edge(Dart d, FunctorType& f) ;
+	virtual bool foreach_dart_of_edge(Dart d, FunctorType& f, unsigned int thread = 0) ;
 
-	bool foreach_dart_of_oriented_face(Dart d, FunctorType& f);
-	virtual bool foreach_dart_of_face(Dart d, FunctorType& f) ;
+	bool foreach_dart_of_oriented_face(Dart d, FunctorType& f, unsigned int thread = 0);
+	virtual bool foreach_dart_of_face(Dart d, FunctorType& f, unsigned int thread = 0) ;
 
-	bool foreach_dart_of_oriented_volume(Dart d, FunctorType& f);
-	virtual bool foreach_dart_of_volume(Dart d, FunctorType& f) ;
+	bool foreach_dart_of_oriented_volume(Dart d, FunctorType& f, unsigned int thread = 0);
+	virtual bool foreach_dart_of_volume(Dart d, FunctorType& f, unsigned int thread = 0) ;
 
-	virtual bool foreach_dart_of_cc(Dart d, FunctorType& f) ;
+	virtual bool foreach_dart_of_cc(Dart d, FunctorType& f, unsigned int thread = 0) ;
 
 
 	/****************************************************
diff --git a/include/Algo/ImplicitHierarchicalMesh/ihm3.hpp b/include/Algo/ImplicitHierarchicalMesh/ihm3.hpp
index b56192997..0696b4bc6 100644
--- a/include/Algo/ImplicitHierarchicalMesh/ihm3.hpp
+++ b/include/Algo/ImplicitHierarchicalMesh/ihm3.hpp
@@ -238,7 +238,7 @@ inline void ImplicitHierarchicalMap3::next(Dart& d)
 	} while(d != Map3::end() && m_dartLevel[d] > m_curLevel) ;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_vertex(Dart d, FunctorType& f)
+inline bool ImplicitHierarchicalMap3::foreach_dart_of_vertex(Dart d, FunctorType& f, unsigned int thread)
 {
 	DartMarkerStore mv(*this);			// Lock a marker
 	bool found = false;					// Last functor return value
@@ -276,7 +276,7 @@ inline bool ImplicitHierarchicalMap3::foreach_dart_of_vertex(Dart d, FunctorType
 	return found;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_edge(Dart d, FunctorType& f)
+inline bool ImplicitHierarchicalMap3::foreach_dart_of_edge(Dart d, FunctorType& f, unsigned int thread)
 {
 
 	Dart dNext = d;
@@ -296,7 +296,7 @@ inline bool ImplicitHierarchicalMap3::foreach_dart_of_edge(Dart d, FunctorType&
 	return false;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_oriented_face(Dart d, FunctorType& f)
+inline bool ImplicitHierarchicalMap3::foreach_dart_of_oriented_face(Dart d, FunctorType& f, unsigned int thread)
 {
 	Dart dNext = d ;
 	do
@@ -308,7 +308,7 @@ inline bool ImplicitHierarchicalMap3::foreach_dart_of_oriented_face(Dart d, Func
 	return false ;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_face(Dart d, FunctorType& f)
+inline bool ImplicitHierarchicalMap3::foreach_dart_of_face(Dart d, FunctorType& f, unsigned int thread)
 {
 	if (foreach_dart_of_oriented_face(d,f)) return true;
 
@@ -317,7 +317,7 @@ inline bool ImplicitHierarchicalMap3::foreach_dart_of_face(Dart d, FunctorType&
 	return false;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_oriented_volume(Dart d, FunctorType& f)
+inline bool ImplicitHierarchicalMap3::foreach_dart_of_oriented_volume(Dart d, FunctorType& f, unsigned int thread)
 {
 	DartMarkerStore mark(*this);	// Lock a marker
 	bool found = false;				// Last functor return value
@@ -353,12 +353,12 @@ inline bool ImplicitHierarchicalMap3::foreach_dart_of_oriented_volume(Dart d, Fu
 	return found;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_volume(Dart d, FunctorType& f)
+inline bool ImplicitHierarchicalMap3::foreach_dart_of_volume(Dart d, FunctorType& f, unsigned int thread)
 {
 	return foreach_dart_of_oriented_volume(d, f) ;
 }
 
-inline bool ImplicitHierarchicalMap3::foreach_dart_of_cc(Dart d, FunctorType& f)
+inline bool ImplicitHierarchicalMap3::foreach_dart_of_cc(Dart d, FunctorType& f, unsigned int thread)
 {
 	return foreach_dart_of_oriented_volume(d, f) ;
 }
diff --git a/include/Algo/ImplicitHierarchicalMesh/subdivision3.hpp b/include/Algo/ImplicitHierarchicalMesh/subdivision3.hpp
index 66a934cd9..008fecfa6 100644
--- a/include/Algo/ImplicitHierarchicalMesh/subdivision3.hpp
+++ b/include/Algo/ImplicitHierarchicalMesh/subdivision3.hpp
@@ -286,7 +286,7 @@ void subdivideVolume(typename PFP::MAP& map, Dart d, typename PFP::TVEC3& positi
 			map.unsewFaces(map.phi1(map.phi1(e)));
 
 			//TODO utile ?
-			if(map.phi2(map.phi1(e)) != map.phi1(e))
+			//if(map.phi2(map.phi1(e)) != map.phi1(e))
 				map.unsewFaces(map.phi1(e));
 
 			e = map.phi2(map.phi_1(e));
diff --git a/include/Algo/Import/import.h b/include/Algo/Import/import.h
index 4fc2c7fa7..fc3f260bf 100644
--- a/include/Algo/Import/import.h
+++ b/include/Algo/Import/import.h
@@ -72,7 +72,7 @@ template <typename PFP>
 bool importTs(typename PFP::MAP& the_map, const std::string& filename, std::vector<std::string>& attrNames, float scaleFactor = 1.0f);
 
 template <typename PFP>
-bool importInESSSurfacique(typename PFP::MAP& the_map, const std::string& filename, std::vector<std::string>& attrNames);
+bool importInESSSurfacique(typename PFP::MAP& the_map, const std::string& filename, std::vector<std::string>& attrNames, std::vector<std::pair<typename PFP::VEC3, typename PFP::VEC3> >& influences);
 
 template <typename PFP>
 bool importInESSVolumique(typename PFP::MAP& the_map, const std::string& filename, std::vector<std::string>& attrNames);
diff --git a/include/Algo/Import/importInESS.hpp b/include/Algo/Import/importInESS.hpp
index 8536fe267..763aa7d16 100644
--- a/include/Algo/Import/importInESS.hpp
+++ b/include/Algo/Import/importInESS.hpp
@@ -23,6 +23,7 @@
 *******************************************************************************/
 
 #include "Algo/Modelisation/polyhedron.h"
+#include "Algo/Modelisation/primitives3d.h"
 #include <vector>
 #include "Geometry/bounding_box.h"
 #include <set>
@@ -51,7 +52,7 @@ typename PFP::VEC3 stringToEmb(std::string s)
 
 	typename PFP::VEC3 coord(x,y,z);
 
-	CGoGNout << coord << CGoGNendl;
+	//CGoGNout << coord << CGoGNendl;
 
 	return coord;
 }
@@ -72,7 +73,7 @@ inline unsigned int gcd(unsigned int a, unsigned int b)
 }
 
 template <typename PFP>
-bool importInESSSurfacique(typename PFP::MAP& map, const std::string& filename, std::vector<std::string>& attrNames)
+bool importInESSSurfacique(typename PFP::MAP& map, const std::string& filename, std::vector<std::string>& attrNames, std::vector<std::pair<typename PFP::VEC3, typename  PFP::VEC3> > &influences)
 {
 	typedef typename PFP::VEC3 VEC3;
 
@@ -134,6 +135,11 @@ bool importInESSSurfacique(typename PFP::MAP& map, const std::string& filename,
 
 	sy.insert(c1[1]);
 	sy.insert(c2[1]);
+
+	// Second Column (nil)
+	bg = line.substr(posData);
+	//std::cout << bg << std::endl;
+
 	size++;
 
 	while ( std::getline( fp, line ) )
@@ -147,11 +153,9 @@ bool importInESSSurfacique(typename PFP::MAP& map, const std::string& filename,
 
 		VEC3 c1 = stringToEmb<PFP>(bg.substr(0, posCoord));
 		VEC3 c2 = stringToEmb<PFP>(bg.substr(posCoord+3));
-		std::cout << std::endl;
+		//std::cout << std::endl;
 
 		coordonnees.push_back(std::pair<VEC3,VEC3>(c1,c2));
-//		coordonneesX.insert(std::pair<int, unsigned int >(c1[0],size));
-//		coordonneesY.insert(std::pair<int, unsigned int >(c1[1],size));
 
 		sx.insert(c1[0]);
 		sx.insert(c2[0]);
@@ -159,22 +163,25 @@ bool importInESSSurfacique(typename PFP::MAP& map, const std::string& filename,
 		sy.insert(c1[1]);
 		sy.insert(c2[1]);
 
+
+		//Second Column
+		bg = line.substr(posData);
+		posCoord = bg.find(") (");
+		//std::cout << bg << std::endl;
+		c1 = stringToEmb<PFP>(bg.substr(1, posCoord+1));
+		//CGoGNout << c1 << CGoGNendl;
+		c2 = stringToEmb<PFP>(bg.substr(posCoord+3));
+		//CGoGNout << c2 << CGoGNendl;
+		influences.push_back(std::pair<VEC3,VEC3>(c1,c2));
+
+
+
 		size++;
 	}
 
 	fp.close();
 
 
-//	std::cout << "setx" << std::endl;
-//	 for (std::set<int>::iterator it = sx.begin() ; it != sx.end(); ++it)
-//	    std::cout << " " << *it;
-//	 std::cout << std::endl;
-//
-//	 std::cout << "sety" << std::endl;
-//	 for (std::set<int>::iterator it = sy.begin() ; it != sy.end(); ++it)
-//	 	    std::cout << " " << *it;
-//	 std::cout << std::endl;
-
 	//
 	// Creation de la grille
 	//
@@ -186,11 +193,10 @@ bool importInESSSurfacique(typename PFP::MAP& map, const std::string& filename,
 	int cy = sy.size();
 	prim.grid_topo(cx-1,cy-1);
 
+	//tableau des brins (un par sommet)
 	std::vector<Dart> tableVertDarts = prim.getVertexDarts();
 
 
-	std::pair<std::multimap<int, unsigned int>::iterator,std::multimap<int, unsigned int>::iterator > retX;
-
 	for(int i=0; i<cy; ++i)
 	{
 		//std::cout << "cood y =" << *sity << std::endl;
@@ -201,7 +207,7 @@ bool importInESSSurfacique(typename PFP::MAP& map, const std::string& filename,
 			Dart d = tableVertDarts[i*(cx)+j];
 			position[d] = VEC3(*sitx, *sity, 0);
 
-			objects[d] = -1;
+			objects[d] = 0;
 
 			++sitx;
 		}
@@ -213,7 +219,6 @@ bool importInESSSurfacique(typename PFP::MAP& map, const std::string& filename,
 	//
 	// Coloriage
 	//
-
 	for(int i=0; i<cy; ++i)
 	{
 		//std::cout << "cood y =" << *sity << std::endl;
@@ -223,232 +228,36 @@ bool importInESSSurfacique(typename PFP::MAP& map, const std::string& filename,
 		{
 			Dart d = tableVertDarts[i*(cx)+j];
 
-			//Calcul du centre de ce quad
-			VEC3 c = Algo::Geometry::faceCentroid<PFP>(map, d, position);
+			if(objects[d] == 0)
+			{
 
-			//std::cout << "center=" << c << std::endl;
-			int place = 0;
+				//Calcul du centre de ce quad
+				VEC3 c = Algo::Geometry::faceCentroid<PFP>(map, d, position);
 
-			//Comparaison avec toutes les coordonnees si le point se trouve dedans
-			for(typename std::vector<std::pair<VEC3,VEC3> >::iterator it  = coordonnees.begin(); it != coordonnees.end() ; ++it)
-			{
-				//comparaison si la coord du centre se situe dans l'intervalle de la boite anglobante
-				//std::cout << "c1=" << (*it).first << " c2=" << (*it).second  << std::endl;
+				//std::cout << "center=" << c << std::endl;
 
-				if((*it).first[0] < c[0] && c[0] < (*it).second[0] && (*it).first[1] < c[1] && c[1] < (*it).second[1])
+				int i = 1;
+				//Comparaison avec toutes les coordonnees si le point se trouve dedans
+				for(typename std::vector<std::pair<VEC3,VEC3> >::iterator it  = coordonnees.begin(); it != coordonnees.end() ; ++it)
 				{
-					objects[d] = place;
-					//std::cout << "i=" << place << std::endl;
-					std::cout << "place=" << place << std::endl;
+					//comparaison si la coord du centre se situe dans l'intervalle de la boite anglobante
+					//std::cout << "c1=" << (*it).first << " c2=" << (*it).second  << std::endl;
+
+					if((*it).first[0] <= c[0] && c[0] < (*it).second[0] &&
+							(*it).first[1] <= c[1] && c[1] < (*it).second[1])
+					{
+						objects[d] = i ;
+					}
+					++i;
 				}
-				++place;
-			}
 
+			}
 			++sitx;
 		}
 		++sity;
 	}
 
-
-
-//	for(int i=0; i<cy; ++i)
-//	{
-//		std::cout << "cood y =" << *sity << std::endl;
-//		std::set<int>::iterator sitx = sx.begin();
-//
-//		for(int j=0; j<cx;++j)
-//		{
-//			Dart d = tableVertDarts[i*(cx)+j];
-//
-//			//Amelioration : tester si le brin est marque d'abord
-//			if(!fm.isMarked(d))
-//			{
-//				//chercher dans la multimap X le début des sommets dont la cle vaut *sitx
-////				retX = coordonneesX.lower_bound(*sitx);
-//				bool end = false;
-//
-//				std::cout << "sitx=" << *sitx << std::endl;
-//				std::cout << "sity=" << *sity << std::endl;
-//				//chercher dans ce sous ensemble avec une indirection vers les coordonnnes le couple de coordonnees dans le first a une valeur Y qui vaut *sitY
-//				for(std::multimap<int, unsigned int>::iterator retX = coordonneesX.lower_bound(*sitx) ; !end && retX != coordonneesX.end() ; ++retX)
-//				{
-//					std::cout << (*retX).second << std::endl;
-//					std::cout << coordonnees[(*retX).second].first << std::endl;
-//
-//					//si ce plongement est le debut d'une boite englobante
-//					if(coordonnees[(*retX).second].first[1] == *sity)
-//					{
-//						std::cout << "plop" << std::endl;
-//						//on plonge un brin de cette face
-//						//objects[d] = (*retX).second;
-//
-//						//on marque les brins de la face
-//						//fm.markOrbit(FACE_ORBIT, d);
-//
-//
-////						Dart e = d;
-////						do
-////						{
-////							//se balader dans la carte vers l'autre extremite de la boite englobante tout en marquant les faces
-////
-////							//Tout en incrementant les y
-////
-////							Dart f = e;
-////							do
-////							{
-////								//on plonge un brin de cette face
-////								objects[f] = (*retX).second;
-////
-////								//on marque les brins de la face
-////								fm.markOrbit(FACE_ORBIT, f);
-////
-////								//d'abord sur les x tant que le x de la fin de la boite englobante n'a pas ete atteint
-////
-////								f = map.phi1(map.phi2(map.phi1(f)));
-////							}
-////							while(position[f][1] <= coordonnees[(*retX).second].second[1]);
-////
-////							e = map.phi2(map.phi_1(map.phi_1(e)));
-////						}
-////						while(position[e][0] <= coordonnees[(*retX).second].second[0]);
-//
-//					}
-//				}
-//
-//				std::cout << std::endl << std::endl;
-//			}
-//
-//			++sitx;
-//		}
-//		++sity;
-//	}
-
-
-//	std::pair<std::multimap<int, unsigned int>::iterator,std::multimap<int, unsigned int>::iterator > retX;
-//	std::pair<std::multimap<int, unsigned int>::iterator,std::multimap<int, unsigned int>::iterator > retY;
-//
-//	for(int i=0; i<cy; ++i)
-//	{
-//		std::cout << "cood y =" << *sity << std::endl;
-//		std::set<int>::iterator sitx = sx.begin();
-//
-//		for(int j=0; j<cx;++j)
-//		{
-//			Dart d = tableVertDarts[i*(cx)+j];
-//
-//			std::cout << "sitx=" << *sitx << std::endl;
-//			std::cout << "sity=" << *sity << std::endl;
-//
-//			//chercher dans la multimap X le sous ensemble de sommets dont la cle vaut *sitx
-//			retX = coordonneesX.equal_range(*sitx);
-//
-//			//chercher dans ce sous ensemble avec une indirection vers les coordonnnes le couple de coordonnees dans le first a une valeur Y qui vaut *sitY
-//			typename std::multimap<int, unsigned int>::iterator it;
-//			for (it=retX.first; it!=retX.second; ++it)
-//			{
-//				std::cout << (*it).second << std::endl;
-//				std::cout << coordonnees[(*it).second].first << std::endl << std::endl;
-//
-//				//plonger le brin de cette face avec la valeur de l'indirection
-//				if(coordonnees[(*it).second].first[1] == *sity)
-//					objects[d] = (*it).second;
-//			}
-//			std::cout << std::endl;
-//			++sitx;
-//		}
-//		++sity;
-//	}
-
-	//						Dart e = d;
-	//						do
-	//						{
-	//							//se balader dans la carte vers l'autre extremite de la boite englobante tout en marquant les faces
-	//
-	//							//Tout en incrementant les y
-	//
-	//							Dart f = e;
-	//							do
-	//							{
-	//								//on plonge un brin de cette face
-	//								objects[f] = (*retX).second;
-	//
-	//								//on marque les brins de la face
-	//								fm.mark(FACE_ORBIT, f);
-	//
-	//								//d'abord sur les x tant que le x de la fin de la boite englobante n'a pas ete atteint
-	//
-	//								f = map.phi1(map.phi2(map.phi1(f)));
-	//							}
-	//							while(position[f][1] < coordonnees[(*retX).second].second[1]);
-	//
-	//							e = map.phi2(map.phi_1(map.phi_1(e)));
-	//
-	//						}
-	//						while(position[e][0] < coordonnees[(*retX).second].second[0]);
-
-
-//	unsigned int em;
-//	AttributeContainer& container = map.getAttributeContainer(VERTEX_CELL) ;
-//	typename std::vector<std::pair<VEC3,VEC3> >::iterator it  = coordonnees.begin();
-//	//	++it;
-//
-//    while( it != coordonnees.end())
-//    {
-//            std::cout << "x=" << (*it).first << "y=" << (*it).second << std::endl;
-//
-//
-//            Dart d = map.newFace(4);
-//
-//            std::pair<VEC3,VEC3> c = *it;
-//            VEC3 c1 = c.first;
-//            VEC3 c2 = c.second;
-//
-//              em = container.insertLine();
-//              position[em] = c1;
-//              map.setDartEmbedding(VERTEX_ORBIT, d, em);
-//              d = map.phi1(d);
-//
-//              em = container.insertLine();
-//              position[em] = VEC3(c2[0],c1[1],c2[2]);
-//              map.setDartEmbedding(VERTEX_ORBIT, d, em);
-//              d = map.phi1(d);
-//
-//              em = container.insertLine();
-//              position[em] = c2;
-//              map.setDartEmbedding(VERTEX_ORBIT, d, em);
-//              d = map.phi1(d);
-//
-//              em = container.insertLine();
-//              position[em] = VEC3(c1[0],c2[1],c1[2]);
-//              map.setDartEmbedding(VERTEX_ORBIT, d, em);
-//              d = map.phi1(d);
-//
-//              ++it;
-//    }
-
-
-
-	//
-	// Coloriage des cases de la grille en fonction des boites englobantes
-	//
-//	Dart d = map.begin();
-//	Dart e = d;
-//	do
-//	{
-//
-//
-//	}while(e != d);
-
-//	DartMarkerStore mark(map);
-//
-//	for(Dart d = map.begin() ; d != map.end() ; map.next(d))
-//	{
-//		VEC3 a = map.getEmbedding(VERTEX_ORBIT);
-//
-//
-//	}
-
-	//IDEE : marquage des brins lors du plongement en fonction
+	std::cout << "coord size : " << coordonnees.size() << std::endl;
 
 
 	return true;
@@ -482,10 +291,11 @@ bool importInESSVolumique(typename PFP::MAP& map, const std::string& filename, s
 	std::ifstream fp(filename.c_str(), std::ios::in);
 	if (!fp.good())
 	{
-		std::cerr << "Unable to open file " << filename << std::endl;
+		CGoGNerr << "Unable to open file " << filename << CGoGNendl;
 		return false;
 	}
 
+
 	//
 	// Lecture du fichier
 	//
@@ -508,6 +318,10 @@ bool importInESSVolumique(typename PFP::MAP& map, const std::string& filename, s
 	VEC3 c2 = stringToEmb<PFP>(bg.substr(posCoord+3));
 	std::cout << std::endl;
 
+	float x = c1[0];
+	float y = c1[1];
+	float z = c1[2];
+
 	//coordonnees.push_back(std::pair<VEC3,VEC3>(c1,c2));
 //	coordonneesX.insert(std::pair<int, unsigned int >(c1[0],size));
 //	coordonneesY.insert(std::pair<int, unsigned int >(c1[1],size));
@@ -546,6 +360,124 @@ bool importInESSVolumique(typename PFP::MAP& map, const std::string& filename, s
 
 	fp.close();
 
+
+//	std::cout << "setx" << std::endl;
+//	 for (std::set<int>::iterator it = sx.begin() ; it != sx.end(); ++it)
+//	    std::cout << " " << *it;
+//	 std::cout << std::endl;
+//
+//	 std::cout << "sety" << std::endl;
+//	 for (std::set<int>::iterator it = sy.begin() ; it != sy.end(); ++it)
+//	 	    std::cout << " " << *it;
+//	 std::cout << std::endl;
+
+	//
+	// Creation de la grille
+	//
+	Algo::Modelisation::Primitive3D<PFP> prim(map, position);
+
+	std::set<int>::iterator sity = sy.begin();
+
+	int cx = sx.size();
+	int cy = sy.size();
+	prim.hexaGrid_topo(cx-1,cy-1, cx);
+
+	std::vector<Dart> tableVertDarts = prim.getVertexDarts();
+
+
+	prim.embedHexaGrid(x,y,z);
+
+//	std::pair<std::multimap<int, unsigned int>::iterator,std::multimap<int, unsigned int>::iterator > retX;
+//	int nbs = (cx+1)*(cy+1);
+//
+//	for(int i=0; i<= 1; ++i) //z
+//	{
+//		for(int j=0; j<= cy; ++j) //y
+//		{
+//			std::set<int>::iterator sitx = sx.begin();
+//
+//			for(int k=0; k<=cx;++k)	//x
+//			{
+//				Dart d = tableVertDarts[ i*nbs+j*(cx+1)+k ];
+//
+//				map.embedNewCell(VERTEX_ORBIT,d);
+//
+//				position[d] = VEC3(float(k), float(j), float(i));
+//
+////				if(i == 0)
+////					position[d] = VEC3(*sitx, *sity, 0);
+////				else
+////					position[d] = VEC3(*sitx,*sity, 0);
+//
+//				++sitx;
+//			}
+//
+//			++sity;
+//		}
+//	}
+
+//	for(int i=0; i<cy; ++i)
+//	{
+//		//std::cout << "cood y =" << *sity << std::endl;
+//		std::set<int>::iterator sitx = sx.begin();
+//
+//		for(int j=0; j<cx;++j)
+//		{
+//			Dart d = tableVertDarts[i*(cx)+j];
+//
+//			position[d] = VEC3(*sitx, *sity, 0);
+//
+//			position[map.phi1(map.phi1(map.phi2(d)))] = VEC3(*sitx, *sity, 14000);
+//
+//
+//			objects[d] = -1;
+//
+//			++sitx;
+//		}
+//		++sity;
+//	}
+
+	sity = sy.begin();
+
+	//
+	// Coloriage
+	//
+
+//	for(int i=0; i<cy; ++i)
+//	{
+//		//std::cout << "cood y =" << *sity << std::endl;
+//		std::set<int>::iterator sitx = sx.begin();
+//
+//		for(int j=0; j<cx;++j)
+//		{
+//			Dart d = tableVertDarts[i*(cx)+j];
+//
+//			//Calcul du centre de ce quad
+//			VEC3 c = Algo::Geometry::faceCentroid<PFP>(map, d, position);
+//
+//			//std::cout << "center=" << c << std::endl;
+//			int place = 0;
+//
+//			//Comparaison avec toutes les coordonnees si le point se trouve dedans
+//			for(typename std::vector<std::pair<VEC3,VEC3> >::iterator it  = coordonnees.begin(); it != coordonnees.end() ; ++it)
+//			{
+//				//comparaison si la coord du centre se situe dans l'intervalle de la boite anglobante
+//				//std::cout << "c1=" << (*it).first << " c2=" << (*it).second  << std::endl;
+//
+//				if((*it).first[0] < c[0] && c[0] < (*it).second[0] && (*it).first[1] < c[1] && c[1] < (*it).second[1])
+//				{
+//					objects[d] = place;
+//					//std::cout << "i=" << place << std::endl;
+//					std::cout << "place=" << place << std::endl;
+//				}
+//				++place;
+//			}
+//
+//			++sitx;
+//		}
+//		++sity;
+//	}
+
 	return true;
 }
 
diff --git a/include/Algo/Modelisation/polyhedron.hpp b/include/Algo/Modelisation/polyhedron.hpp
index d428a89a9..a0635b52d 100644
--- a/include/Algo/Modelisation/polyhedron.hpp
+++ b/include/Algo/Modelisation/polyhedron.hpp
@@ -178,7 +178,7 @@ Dart  Polyhedron<PFP>::createOrientedPrism(typename PFP::MAP& the_map)
 	Dart top = the_map.newOrientedFace(3);
 	the_map.sewFaces(top,the_map.phi1(the_map.phi1(side1)));
 	the_map.sewFaces(the_map.phi_1(top),the_map.phi1(the_map.phi1(side2)));
-	the_map.sewFaces(the_map.phi1(the_map.phi1(top)),the_map.phi1(the_map.phi1(side3)));
+	the_map.sewFaces(the_map.phi1(top),the_map.phi1(the_map.phi1(side3)));
 
 	return base;
 }
diff --git a/include/Algo/Modelisation/tetrahedron.h b/include/Algo/Modelisation/tetrahedron.h
index 778dc8b58..d78bf5acb 100644
--- a/include/Algo/Modelisation/tetrahedron.h
+++ b/include/Algo/Modelisation/tetrahedron.h
@@ -37,9 +37,9 @@ namespace Modelisation
 namespace Tetrahedron
 {
 
-/***********************************************************************************************
- * 									Tetrahedron functions									   *
- ***********************************************************************************************/
+/************************************************************************************************
+ * 																Tetrahedron functions																	   *
+ ************************************************************************************************/
 
 
 /**
@@ -51,25 +51,25 @@ template <typename PFP>
 bool isTetrahedron(typename PFP::MAP& the_map, Dart d);
 
 
-/***********************************************************************************************
- *										Swap Functions 										   *
- ***********************************************************************************************/
+/************************************************************************************************
+ *																		Swap Functions 																	   *
+ ************************************************************************************************/
 
 /**
  * Swap a configuration of 2 Tetrahedron to another one
  * @param map
- * @param d
+ * @param d a dart from the face between the two tetahedron to swap
  *
  * TODO ajouter image
  */
 template <typename PFP>
-void swap2To2(typename PFP::MAP& the_map, Dart d, typename PFP::TVEC3& positions);
+void swap2To2(typename PFP::MAP& map, Dart d);
 
 /**
  *
  */
 template <typename PFP>
-void swap4To4(typename PFP::MAP& the_map, Dart d, typename PFP::TVEC3& positions);
+void swap4To4(typename PFP::MAP& map, Dart d);
 
 /**
  * Swap a configuration of 3 tetrahedron to another one with 2 tetrahedron
@@ -80,14 +80,13 @@ void swap4To4(typename PFP::MAP& the_map, Dart d, typename PFP::TVEC3& positions
  *
  */
 template <typename PFP>
-void swap3To2(typename PFP::MAP& the_map, Dart d, typename PFP::TVEC3& positions);
-
+void swap3To2(typename PFP::MAP& map, Dart d);
 
 /**
  *
  */
 template <typename PFP>
-void swap2To3(typename PFP::MAP& the_map, Dart d, typename PFP::TVEC3& positions);
+void swap2To3(typename PFP::MAP& map, Dart d);
 
 /**
  *
diff --git a/include/Algo/Modelisation/tetrahedron.hpp b/include/Algo/Modelisation/tetrahedron.hpp
index c78152fc6..5444e9508 100644
--- a/include/Algo/Modelisation/tetrahedron.hpp
+++ b/include/Algo/Modelisation/tetrahedron.hpp
@@ -35,9 +35,9 @@ namespace Modelisation
 
 namespace Tetrahedron
 {
-/***********************************************************************************************
- * 										Tetrahedron functions								   *
- ***********************************************************************************************/
+/************************************************************************************************
+ * 																		Tetrahedron functions															   *
+ ************************************************************************************************/
 
 template <typename PFP>
 bool isTetrahedron(typename PFP::MAP& the_map, Dart d)
@@ -98,138 +98,239 @@ bool isTetrahedron(typename PFP::MAP& the_map, Dart d)
 	return isTetrahedron;
 }
 
+/************************************************************************************************
+ * 																		Topological functions															   *
+ ************************************************************************************************/
 
-/***********************************************************************************************
- * 										swap functions										   *
- ***********************************************************************************************/
-//ok
+//sew a face into the edge
 template <typename PFP>
-void swap2To2(typename PFP::MAP& the_map, Dart d, typename PFP::TVEC3& positions)
+Dart linkIntoEdge(typename PFP::MAP& map, Dart d, Dart e)
 {
-	unsigned int p1 = EMBNULL;
-	unsigned int p2 = EMBNULL;
+	Dart e2 = map.phi2(e);
+	Dart d3 = map.phi3(d);
+
+	//Decoud les 2 brins
+	map.unsewFaces(e);
 
-	Dart r = the_map.phi2(d);
-	Dart f = the_map.phi2(the_map.phi3(d));
+	//Coudre la nouvelle face au milieu de l'ancienne arête
+	map.sewFaces(e2,d3);
+	map.sewFaces(e,d);
 
-	Dart s1 = the_map.phi_1(r);
-	Dart s2 = the_map.phi_1(f);
+	map.setDartEmbedding(VERTEX_ORBIT, d, map.getEmbedding(e2,VERTEX_ORBIT)) ;
+	map.setDartEmbedding(VERTEX_ORBIT, d3, map.getEmbedding(e,VERTEX_ORBIT)) ;
 
-	p1 = the_map.getEmbedding(the_map.phi_1(r), VERTEX_ORBIT);
-	p2 = the_map.getEmbedding(the_map.phi_1(f), VERTEX_ORBIT);
+	return e2;
+}
 
-	// Topological swap
+//unsew a face from the edge
+template <typename PFP>
+void unlinkFromEdge(typename PFP::MAP& map, Dart d)
+{
+	Dart d3 = map.phi3(d);
+
+	if(map.isOrbitEmbedded(VERTEX_ORBIT))
+	{
+		//Si la face n'est pas libre en phi2
+		if(map.phi2(d) != d && map.phi2(d3) != d3)
+		{
+			unsigned int dVEmb = map.getDartEmbedding(VERTEX_ORBIT, d) ;
+			if(dVEmb != EMBNULL)
+			{
+				map.embedOrbit(VERTEX_ORBIT, d, dVEmb) ;
+				map.setDartEmbedding(VERTEX_ORBIT, d, EMBNULL) ;
+			}
+
+			unsigned int d3VEmb = map.getDartEmbedding(VERTEX_ORBIT, d3) ;
+			if(d3VEmb != EMBNULL)
+			{
+				map.embedOrbit(VERTEX_ORBIT, d3, d3VEmb) ;
+				map.setDartEmbedding(VERTEX_ORBIT, d3, EMBNULL) ;
+			}
+		}
+		//Si la face est libre en phi2
+		else
+		{
+
+		}
+	}
+
+	Dart e2 = map.phi2(d3);
+	Dart d2 = map.phi2(d);
+	map.unsewFaces(e2);
+	map.unsewFaces(d2);
+	map.sewFaces(d2,e2);
+}
+
+template <typename PFP>
+void unlinkFace(typename PFP::MAP& map, Dart d)
+{
 	Dart e = d;
 	do
 	{
-		//the_map.unsewFace(e);
-		e = the_map.phi1(e);
+		unlinkFromEdge<PFP>(map, e);
+		e = map.phi1(e);
 	}
 	while (e != d);
+}
 
-	the_map.flipEdge(r);
-	the_map.insertFace(r,d);
+template <typename PFP>
+void insertFace(typename PFP::MAP& map, Dart d, Dart nF)
+{
+	Dart dd = d;
+	Dart nFd = nF;
 
+	do {
+		//TODO linkIntoEdge
 
-	the_map.setDartEmbedding(VERTEX_ORBIT,r,p2);
-	the_map.setDartEmbedding(VERTEX_ORBIT,f,p1);
+		Dart d2 = map.phi2(dd);
+		map.unsewFaces(dd);
+		map.sewFaces(dd,nFd);
+		map.sewFaces(d2,map.phi3(nFd));
+
+		map.setDartEmbedding(VERTEX_ORBIT, nFd, map.getEmbedding(d2,VERTEX_ORBIT)) ;
+		map.setDartEmbedding(VERTEX_ORBIT, map.phi3(nFd), map.getEmbedding(dd,VERTEX_ORBIT)) ;
+
+		dd = map.phi_1(map.phi2(map.phi_1(dd)));
+		nFd = map.phi1(nFd);
+
+	} while (nFd != nF);
+}
+
+/***********************************************************************************************
+ * 										swap functions										   *
+ ***********************************************************************************************/
+//ok
+template <typename PFP>
+void swap2To2(typename PFP::MAP& map, Dart d)
+{
+	//save a dart from a non-modifed-face of one tetrahedron
+	Dart r = map.phi2(d);
+
+	//detach common face from tetrahedron from the rest of the faces
+	unlinkFace<PFP>(map, d);
+
+	//flip the middle edge
+	map.flipEdge(r);
+	Dart e = map.phi2(r);
+
+	unsigned int dVEmb = map.getDartEmbedding(VERTEX_ORBIT, r) ;
+	if(dVEmb != EMBNULL)
+	{
+		map.setDartEmbedding(VERTEX_ORBIT, map.phi_1(r), dVEmb) ;
+		map.setDartEmbedding(VERTEX_ORBIT, r, EMBNULL) ;
+	}
+
+	unsigned int eVEmb = map.getDartEmbedding(VERTEX_ORBIT, e) ;
+	if(eVEmb != EMBNULL)
+	{
+		map.setDartEmbedding(VERTEX_ORBIT, map.phi_1(e), eVEmb) ;
+		map.setDartEmbedding(VERTEX_ORBIT, e, EMBNULL) ;
+	}
+
+	//insert the face in the flipped edge
+	insertFace<PFP>(map, r, d);
 
 	Dart dd = d;
 	do {
-		Dart e = the_map.phi2(dd);
-		Dart e2 = the_map.template phi<32>(dd);
-		the_map.setDartEmbedding(VERTEX_ORBIT, dd, the_map.getEmbedding(e2,VERTEX_ORBIT)) ;
-		the_map.setDartEmbedding(VERTEX_ORBIT, the_map.phi3(dd), the_map.getEmbedding(e,VERTEX_ORBIT)) ;
-		dd = the_map.phi1(dd);
-	}while(dd!=d);
+		Dart e = map.phi2(dd);
+		Dart e2= map.phi2(map.phi3(dd));
+
+		map.setDartEmbedding(VERTEX_ORBIT, dd, map.getEmbedding(e2,VERTEX_ORBIT)) ;
+		map.setDartEmbedding(VERTEX_ORBIT, map.phi3(dd), map.getEmbedding(e,VERTEX_ORBIT)) ;
+
 
+		dd = map.phi1(dd);
+	} while( dd!=d);
 
 }
 
 //ok
 template <typename PFP>
-void swap4To4(typename PFP::MAP& the_map, Dart d, typename PFP::TVEC3& positions)
+void swap4To4(typename PFP::MAP& map, Dart d)
 {
 	//!! 4 decouture inutile, seule l'intersection du centre doit etre decousu puis recousu
 
-	Dart e = the_map.phi2(the_map.phi3(d));
-	Dart dd = the_map.phi2(d);
+	Dart e = map.phi2(map.phi3(d));
+	Dart dd = map.phi2(d);
 
 	//unsew middle crossing darts
-	the_map.unsewVolumes(d);
-	the_map.unsewVolumes(the_map.phi2(the_map.phi3(dd)));
+	map.unsewVolumes(d);
+	map.unsewVolumes(map.phi2(map.phi3(dd)));
 
-	Algo::Modelisation::Tetrahedron::swap2To2<PFP>(the_map, dd, positions);
-	Algo::Modelisation::Tetrahedron::swap2To2<PFP>(the_map, e, positions);
+	Algo::Modelisation::Tetrahedron::swap2To2<PFP>(map, dd);
+	Algo::Modelisation::Tetrahedron::swap2To2<PFP>(map, e);
 
 	//sew middle darts so that they do not cross
-	the_map.sewVolumes(d,the_map.phi2(the_map.phi3(e)));
-	the_map.sewVolumes(the_map.phi2(the_map.phi3(dd)),the_map.phi2(e));
+	map.sewVolumes(d,map.phi2(map.phi3(e)));
+	map.sewVolumes(map.phi2(map.phi3(dd)),map.phi2(e));
 }
 
 template <typename PFP>
-void swap3To2(typename PFP::MAP& map, Dart d, typename PFP::TVEC3& positions)
+void swap3To2(typename PFP::MAP& map, Dart d)
 {
-    Dart en1 = map.phi_1(map.phi2(d));
-    Dart en2 = map.phi1(d);
-    Dart fi = map.phi2(en1);
-
-    //Decouture de la premiere face
-//    map.unsewFace(map.phi2(en1));
-//    map.unsewFace(map.phi2(en2));
-//
-//    //Decouture de la seconde face
-//    en1 = map.phi1(map.phi2(en1));
-//    en2 = map.phi_1(map.phi2(en2));
-//    map.unsewFace(map.phi2(en1));
-//    map.unsewFace(map.phi2(en2));
-//
-//    //Decouture de la troisieme face
-//    en1 = map.phi1(map.phi2(en1));
-//    en2 = map.phi_1(map.phi2(en2));
-//    map.unsewFace(map.phi2(en1));
-//    map.unsewFace(map.phi2(en2));
-
-    //Faces interieurs
-    Dart fi2 = map.phi2(map.phi1(fi));
-    Dart fi3 = map.phi2(map.phi3(map.phi1(fi)));
-
-    map.deleteFace(fi);
-    map.deleteFace(fi2);
-    map.deleteFace(fi3);
-
-    //Couture de cette face au milieu des 2 tetraedres
-    Dart f = map.newFace(3);
-//    Dart g = map.newFace(3);
-//    map.sewVolumes(f,g);
-//
-//    map.sewFace(f,d);
-
-    Dart ff=f;
-    Dart en= d;
-    do {
-        Dart e2 = map.phi2(en);
-        Dart d3 = map.phi3(ff);
-        map.unsewFaces(en);
-        map.sewFaces(e2,d3);
-        map.sewFaces(en,ff);
-
-        en = map.phi_1(map.phi2(map.phi_1(en)));
-
-        ff = map.phi1(ff);
-   } while(ff!=f);
-
-	//tMap3<DART>::flipTetra3To2(d);
+	Dart en1 = map.phi_1(map.phi2(d));
+	Dart en2 = map.phi1(d);
+	Dart fi = map.phi2(en1);
 
-	Dart dd = d;
+	//Decouture de la premiere face
+	unlinkFromEdge<PFP>(map, map.phi2(en1));
+	unlinkFromEdge<PFP>(map, map.phi2(en2));
 
-	do {
-		Dart e = map.phi2(map.phi3(map.phi2(dd)));
-		map.setDartEmbedding(VERTEX_ORBIT, map.phi2(dd), map.getEmbedding(e,VERTEX_ORBIT)) ;
-		map.setDartEmbedding(VERTEX_ORBIT, map.phi2(e), map.getEmbedding(dd,VERTEX_ORBIT)) ;
+	//Decouture de la seconde face
+	en1 = map.phi1(map.phi2(en1));
+	en2 = map.phi_1(map.phi2(en2));
+	unlinkFromEdge<PFP>(map, map.phi2(en1));
+	unlinkFromEdge<PFP>(map, map.phi2(en2));
+
+	//Decouture de la troisieme face
+	en1 = map.phi1(map.phi2(en1));
+	en2 = map.phi_1(map.phi2(en2));
+	unlinkFromEdge<PFP>(map, map.phi2(en1));
+	unlinkFromEdge<PFP>(map, map.phi2(en2));
+
+	//Faces interieurs
+	Dart fi2 = map.phi2(map.phi1(fi));
+	Dart fi3 = map.phi2(map.phi3(map.phi1(fi)));
+
+	map.deleteFace(fi);
+	map.deleteFace(fi2);
+	map.deleteFace(fi3);
+
+	    //Couture de cette face au milieu des 2 tetraedres
+	    Dart f = map.newFace(3);
+	    Dart fprim = map.newFace(3);
+	    map.sewVolumes(f,fprim);
+	//     Dart en = linkIntoEdge(f,d);
+
+	    Dart ff=f;
+	    Dart en= d;
+	    do {
+	        Dart e2 = map.phi2(en);
+	        Dart d3 = map.phi3(ff);
+	        map.unsewFaces(en);
+	        map.sewFaces(e2,d3);
+	        map.sewFaces(en,ff);
+
+	        en = map.phi_1(map.phi2(map.phi_1(en)));
+
+	        ff = map.phi1(ff);
+	    } while(ff!=f);
+
+
+		Dart dd = d;
+
+		do {
+			Dart e = map.phi2(map.phi3(map.phi2(dd)));
+
+			unsigned int eVEmb = map.getDartEmbedding(VERTEX_ORBIT, e) ;
+			unsigned int ddVEmb = map.getDartEmbedding(VERTEX_ORBIT, dd) ;
+
+			map.setDartEmbedding(VERTEX_ORBIT, map.phi2(dd), eVEmb) ;
+			map.setDartEmbedding(VERTEX_ORBIT, map.phi2(e), ddVEmb) ;
+
+			dd = map.phi1(map.phi2(map.phi1(dd)));
+		} while( dd!=d);
 
-		dd = map.phi1(map.phi2(map.phi1(dd)));
-	} while( dd!=d);
 }
 
 
@@ -237,90 +338,56 @@ void swap3To2(typename PFP::MAP& map, Dart d, typename PFP::TVEC3& positions)
 //[precond] le brin doit venir d'une face partagé par 2 tetraèdres
 // renvoie un brin de l'ancienne couture entre les 2 tetras qui est devenu une arête
 template <typename PFP>
-void swap2To3(typename PFP::MAP& map, Dart d, typename PFP::TVEC3& attributs)
+void swap2To3(typename PFP::MAP& map, Dart d)
 {
-	Dart e = map.phi2(d);
-	map.mergeVolumes(d);
-
-	Dart f = map.phi1(e);
-	map.Map2::cutEdge(e);
-	Dart g = map.phi1(e);
-	attributs[g] = attributs[e];
-	attributs[g] += attributs[f];
-	attributs[g] *= 0.5;
-
-	map.splitFace(f, map.phi1(map.phi1(f)));
-
-//		unsigned int p1 = EMBNULL;
-//		unsigned int p2 = EMBNULL;
-//
-//		Dart t1 = the_map.phi1(the_map.phi2(the_map.phi3(d)));
-//		Dart t2 = the_map.phi_1(the_map.phi2(d));
-//
-//		p1 = the_map.getEmbedding(the_map.phi2(t1), VERTEX_ORBIT);
-//		p2 = the_map.getEmbedding(t2, VERTEX_ORBIT);
-//
-//		//unsew the middle face
-//		Dart temp = d;
-//		do{
-//			the_map.unsewFace(temp);
-//			temp = the_map.phi1(temp);
-//		}while(temp != d);
-//
-//		//the_map.deleteFace(d);
-//		//Dart f = the_map.newFace(3);
-//
-//		//sew a first face
-//		the_map.sewFace(t1, d);
-//		the_map.sewFace(t2,the_map.phi1(d));
-//
-//		positions[the_map.phi_1(d)] = positions[t2];
-//		positions[the_map.phi1(the_map.phi3(d))] = positions[the_map.phi2(t1)];
-//		//the_map.setDartEmbedding(VERTEX_ORBIT, the_map.phi_1(d), p2) ;
-//		//the_map.setDartEmbedding(VERTEX_ORBIT, the_map.phi1(the_map.phi3(d)), p1) ;
-//
-//
-//		//Couture de la seconde face
-//		t1 = the_map.phi2(the_map.phi1(t1));
-//		t2 = the_map.phi2(the_map.phi1(the_map.phi1(t2)));
-//
-//		Dart f1 = the_map.newFace(3);
-//		the_map.sewFace(t1,f1);
-//		the_map.sewFace(t2, the_map.phi1(f1));
-//
-//		positions[the_map.phi_1(f1)] = positions[t2];
-//		positions[the_map.phi1(the_map.phi3(f1))] = positions[the_map.phi2(t1)];
-
-
-//		//the_map.setDartEmbedding(VERTEX_ORBIT, the_map.phi_1(f1), p2) ;
-//		//the_map.setDartEmbedding(VERTEX_ORBIT, the_map.phi1(the_map.phi3(f1)), p1) ;
-//		the_map.embedOrbit(VERTEX_ORBIT, the_map.phi_1(f1), p2);
-//		the_map.embedOrbit(VERTEX_ORBIT, the_map.phi1(the_map.phi3(f1)), p1);
-//		the_map.embedOrbit(VERTEX_ORBIT, f1, the_map.getEmbedding(t1 ,VERTEX_ORBIT));
-//		the_map.embedOrbit(VERTEX_ORBIT, the_map.phi1(f1), the_map.getEmbedding(the_map.phi1(t2) ,VERTEX_ORBIT));
-
-
-		///Couture de la troisieme face
-//		t1 = the_map.phi2(the_map.phi1(t1));
-//		t2 = the_map.phi2(the_map.phi1(the_map.phi1(t2)));
-//
-//		Dart f2 = the_map.newFace(3);
-//		the_map.sewFace(t1,f2);
-//		the_map.sewFace(t2,the_map.phi1(f2));
-//
-////		the_map.setDartEmbedding(VERTEX_ORBIT, the_map.phi_1(f2), p2) ;
-////		the_map.setDartEmbedding(VERTEX_ORBIT, the_map.phi1(the_map.phi3(f2)), p1) ;
-//		the_map.embedOrbit(VERTEX_ORBIT, the_map.phi_1(f2), p2);
-//		the_map.embedOrbit(VERTEX_ORBIT, the_map.phi1(the_map.phi3(f2)), p1);
-
-
-		//couture des 3 faces du milieu
-//		the_map.sewFaces(the_map.phi_1(d),the_map.phi1(the_map.phi3(f2)));
-//		the_map.sewFaces(the_map.phi1(the_map.phi3(d)),the_map.phi_1(f1));
-//		the_map.sewFaces(the_map.phi1(the_map.phi3(f1)),the_map.phi_1(f2));
-
-//		the_map.embedOrbit(VERTEX_ORBIT, d, p1);
-//		the_map.embedOrbit(VERTEX_ORBIT, the_map.phi1(the_map.phi3(d)), p2);
+	Dart e = map.phi1(map.phi2(map.phi3(d)));
+
+	unsigned int p1 = map.getDartEmbedding(VERTEX_ORBIT, map.phi_1(map.phi2(d))) ;
+	unsigned int p2 = map.getDartEmbedding(VERTEX_ORBIT, map.phi2(map.phi1(map.phi2(map.phi3(d))))) ;
+
+	//détachement des demi-faces du milieu
+	//garde la relation volumique qui les lies
+	//relie les faces de bords des 2 tetraèdres
+	//renvoie le brin de base d'un des 2 tétraèdres
+	unlinkFace<PFP>(map, d);
+
+	//Couture de la premiere face
+	Dart en1 = linkIntoEdge<PFP>(map,d,e);
+	Dart en2 = linkIntoEdge<PFP>(map, map.phi1(d), map.phi_1(map.phi2(map.phi_1(e))));
+	map.setDartEmbedding(VERTEX_ORBIT, map.phi_1(d), p1);
+	map.setDartEmbedding(VERTEX_ORBIT, map.phi1(map.phi3(d)), p2);
+
+	///Couture de la seconde face
+	en1 = map.phi1(map.phi1(en1));
+	en2 = map.phi_1(map.phi_1(en2));
+
+	Dart f1 = map.newFace(3);
+	Dart f1prim = map.newFace(3);
+	map.sewVolumes(f1,f1prim);
+	en1 = linkIntoEdge<PFP>(map, f1,en1);
+	en2 = linkIntoEdge<PFP>(map, map.phi1(f1),en2);
+
+	map.setDartEmbedding(VERTEX_ORBIT, map.phi_1(f1), p1);
+	map.setDartEmbedding(VERTEX_ORBIT, map.phi1(map.phi3(f1)), p2);
+
+	///Couture de la troisieme face
+	en1 = map.phi1(map.phi1(en1));
+	en2 = map.phi_1(map.phi_1(en2));
+
+	Dart f2 = map.newFace(3);
+	Dart f2prim = map.newFace(3);
+	map.sewVolumes(f2,f2prim);
+	en1 = linkIntoEdge<PFP>(map, f2,en1);
+	en2 = linkIntoEdge<PFP>(map, map.phi1(f2),en2);
+
+	//couture des 3 faces du milieu
+	map.sewFaces(map.phi_1(d), map.phi1(map.phi3(f2)));
+	map.sewFaces(map.phi1(map.phi3(d)), map.phi_1(f1));
+	map.sewFaces(map.phi1(map.phi3(f1)), map.phi_1(f2));
+
+	map.setDartEmbedding(VERTEX_ORBIT, map.phi_1(f2), p1);
+	map.setDartEmbedding(VERTEX_ORBIT, map.phi1(map.phi3(f2)), p2);
+
 }
 
 template <typename PFP>
diff --git a/include/Geometry/bounding_box.hpp b/include/Geometry/bounding_box.hpp
index 5ecce0ef4..c4e6b7197 100644
--- a/include/Geometry/bounding_box.hpp
+++ b/include/Geometry/bounding_box.hpp
@@ -94,7 +94,7 @@ bool BoundingBox<VEC>::intersects(const BoundingBox<VEC>& bb)
 {
 	VEC bbmin = bb.min() ;
 	VEC bbmax = bb.max() ;
-	for(unsigned int i = 0; i < bbmin.size(); ++i)
+	for(unsigned int i = 0; i < bbmin.dimension(); ++i)
 	{
 		if(m_pMax[i] < bbmin[i])
 			return false ;
diff --git a/include/Topology/generic/embeddedMap3.h b/include/Topology/generic/embeddedMap3.h
index 9776a0be8..91b335d20 100644
--- a/include/Topology/generic/embeddedMap3.h
+++ b/include/Topology/generic/embeddedMap3.h
@@ -82,19 +82,6 @@ public:
 	 */
 	virtual Dart cutSpike(Dart d);
 
-	/**
-	 * Flip the edge of d (rotation in phi1 order)
-	 * WARNING : works only if the edge is owned by exactly one or two volumes
-	 * @param d the edge to flip
-	 */
-	//virtual bool flipEdge(Dart d);
-
-	/**
-	 * Flip the edge of d (rotation in phi_1 order)
-	 * WARNING : works only if the edge is owned by exactly one or two volumes
-	 * @param d the edge to flip
-	 */
-	//virtual bool flipBackEdge(Dart d);
 
 	//! Collapse an edge (that is deleted) possibly merging its vertices
 	/*! If delDegenerateFaces is true, the method checks that no degenerate
diff --git a/include/Topology/generic/embeddedMap3.hpp b/include/Topology/generic/embeddedMap3.hpp
index 060198bb2..8d8af3796 100644
--- a/include/Topology/generic/embeddedMap3.hpp
+++ b/include/Topology/generic/embeddedMap3.hpp
@@ -221,33 +221,6 @@ void EmbeddedMap3<MAP3>::cutEdge(Dart d)
 //	}
 }
 
-//template <typename MAP3>
-//bool EmbeddedMap3<MAP3>::flipEdge(Dart d)
-//{
-//	unsigned int eEmbd = EMBNULL;;
-//	unsigned int eEmbd2 = EMBNULL;;
-//
-//	bool res = MAP3::flipEdge(d);
-//
-//	if(MAP3::isOrbitEmbedded(EDGE_ORBIT))
-//	{
-//		eEmbd = MAP3::getEmbedding(d, EDGE_ORBIT);
-//		eEmbd2 = MAP3::getEmbedding(MAP3::phi2(d), EDGE_ORBIT);
-//	}
-//
-//	return res;
-//}
-//
-//
-//template <typename MAP3>
-//bool EmbeddedMap3<MAP3>::flipBackEdge(Dart d)
-//{
-//
-//	bool res = false;
-//
-//
-//	return res;
-//}
 
 template <typename MAP3>
 int EmbeddedMap3<MAP3>::collapseEdge(Dart d, bool delDegenerateFaces,
-- 
GitLab