Merge cgogn:~untereiner/CGoGN

Conflicts:
	include/Algo/Modelisation/polyhedron.hpp

Apps/Examples/decimationVolumique.cpp

@@ -321,8 +321,8 @@ void MyGlutWin::initGUI()
 void maillageTest()
 {
 	/// on creer une carte
-	Dart dd = Algo::Modelisation::Polyhedron<PFP>::createOrientedPolyhedron(myMap,4);
-	Dart ee = Algo::Modelisation::Polyhedron<PFP>::createOrientedPolyhedron(myMap,4);
+	Dart dd = Algo::Modelisation::Polyhedron<PFP>::createPolyhedron(myMap,4);
+	Dart ee = Algo::Modelisation::Polyhedron<PFP>::createPolyhedron(myMap,4);
     myMap.sewVolumes(dd,ee);
 
     // plongement

Apps/Examples/simpleGMap2.cpp

@@ -31,7 +31,7 @@ SimpleGMap2::SimpleGMap2()
 {
 	 position = myMap.addAttribute<PFP::VEC3>(VERTEX, "position");
 
-     Dart d = Algo::Modelisation::Polyhedron<PFP>::createOrientedTetra(myMap);
+     Dart d = Algo::Modelisation::Polyhedron<PFP>::createTetra(myMap);
      position[d] = VEC3(0,0,0);
      position[myMap.phi1(d)] = VEC3(10,0,15);
      position[myMap.phi_1(d)] = VEC3(10,20,15);

Apps/Examples/squelette3carte.cpp

@@ -269,8 +269,8 @@ void MyGlutWin::initGUI()
 void maillageTest()
 {
 	/// on creer une carte
-	Dart dd = Algo::Modelisation::Polyhedron<PFP>::createOrientedPolyhedron(myMap,4);
-	Dart ee = Algo::Modelisation::Polyhedron<PFP>::createOrientedPolyhedron(myMap,4);
+	Dart dd = Algo::Modelisation::Polyhedron<PFP>::createPolyhedron(myMap,4);
+	Dart ee = Algo::Modelisation::Polyhedron<PFP>::createPolyhedron(myMap,4);
     myMap.sewVolumes(dd,ee);
 
     // plongement

include/Algo/Import/importObjEle.hpp

@@ -146,8 +146,8 @@ bool importOFFWithELERegions(typename PFP::MAP& map, const std::string& filename
 		oss >> nbe;
 //		CGoGNout << "tetra number : " << nbe << CGoGNendl;
 
-		//Algo::Modelisation::Polyhedron<PFP>::createOrientedTetra(map);
-		Dart d = Algo::Modelisation::Polyhedron<PFP>::createOrientedPolyhedron(map, 4);
+		//Algo::Modelisation::Polyhedron<PFP>::createTetra(map);
+		Dart d = Algo::Modelisation::Polyhedron<PFP>::createPolyhedron(map, 4);
 		Geom::Vec4ui pt;
 		oss >> pt[0];
 		oss >> pt[1];

include/Algo/Import/importTet.hpp

@@ -43,10 +43,10 @@ bool importTet(typename PFP::MAP& map, const std::string& filename, std::vector<
 
 	AttributeContainer& container = map.getAttributeContainer(VERTEX) ;
 
-	unsigned int m_nbVertices = 0, m_nbFaces = 0, m_nbEdges = 0, m_nbVolumes = 0;
+	unsigned int m_nbVertices = 0, m_nbVolumes = 0;
 	AutoAttributeHandler<  NoMathIONameAttribute< std::vector<Dart> > > vecDartsPerVertex(map, VERTEX, "incidents");
 
-	// open file
+	//open file
 	std::ifstream fp(filename.c_str(), std::ios::in);
 	if (!fp.good())
 	{
@@ -56,20 +56,17 @@ bool importTet(typename PFP::MAP& map, const std::string& filename, std::vector<
 
 	std::string ligne;
 	unsigned int nbv, nbt;
-	// lecture des nombres de sommets/tetra
+	// reading number of vertices
 	std::getline (fp, ligne);
 	std::stringstream oss(ligne);
 	oss >> nbv;
 
-	//CGoGNout << "nbV = " << nbv << CGoGNendl;
-
+	// reading number of tetrahedra
 	std::getline (fp, ligne);
 	std::stringstream oss2(ligne);
 	oss2 >> nbt;
 
-	//CGoGNout << "nbT = " << nbt << CGoGNendl;
-
-	//lecture sommets
+	//reading vertices
 	std::vector<unsigned int> verticesID;
 	verticesID.reserve(nbv);
 	for(unsigned int i = 0; i < nbv;++i)
@@ -85,32 +82,27 @@ bool importTet(typename PFP::MAP& map, const std::string& filename, std::vector<
 		oss >> x;
 		oss >> y;
 		oss >> z;
-		// on peut ajouter ici la lecture de couleur si elle existe
+		// TODO : if required read other vertices attributes here
 		VEC3 pos(x*scaleFactor,y*scaleFactor,z*scaleFactor);
 
-		//CGoGNout << "VEC3 = " << pos << CGoGNendl;
+//		CGoGNout << "VEC3 = " << pos << CGoGNendl;
 
 		unsigned int id = container.insertLine();
 		position[id] = pos;
 
 		verticesID.push_back(id);
 	}
-	m_nbVertices = verticesID.size();
+	m_nbVertices = nbv;
 
-	//CGoGNout << "nbVertices = " << m_nbVertices << CGoGNendl;
 	m_nbVolumes = nbt;
-	//CGoGNout << "nbVolumes = " << m_nbVolumes << CGoGNendl;
-
-	// lecture tetra
-	// normalement m_nbVolumes*12 (car on ne charge que des tetra)
-
-	m_nbFaces = nbt*4;
 
-	CGoGNout << "nb points = " << m_nbVertices << " / nb faces = " << m_nbFaces << " / nb edges = " << m_nbEdges << " / nb tet = " << m_nbVolumes << CGoGNendl;
+	CGoGNout << "nb points = " << m_nbVertices  << " / nb tet = " << m_nbVolumes << CGoGNendl;
 
-	//Read and embed tetrahedra TODO
+	//Read and embed all tetrahedrons
 	for(unsigned int i = 0; i < m_nbVolumes ; ++i)
 	{
+		//start one tetra
+
 		int nbe;
 		do
 		{
@@ -118,59 +110,53 @@ bool importTet(typename PFP::MAP& map, const std::string& filename, std::vector<
 		} while(ligne.size() == 0);
 
 		std::stringstream oss(ligne);
-		oss >> nbe;
-//		CGoGNout << "tetra number : " << nbe << CGoGNendl;
+		oss >> nbe; //number of vertices =4
+		assert(nbe == 4);
 
-		//Algo::Modelisation::Polyhedron<PFP>::createOrientedTetra(map);
-		Dart d = Algo::Modelisation::Polyhedron<PFP>::createOrientedPolyhedron(map,4);
+		Dart d = Algo::Modelisation::Polyhedron<PFP>::createPolyhedron(map,4);
 		Geom::Vec4ui pt;
 		oss >> pt[0];
 		oss >> pt[1];
 		oss >> pt[2];
 		oss >> pt[3];
 
-		//regions ?
-		oss >> nbe;
+		//if regions are defined use this number
+		oss >> nbe; //ignored here
 
 //		CGoGNout << "\t embedding number : " << pt[0] << " " << pt[1] << " " << pt[2] << " " << pt[3] << CGoGNendl;
 
-		// Embed three vertices
+		// Embed three "base" vertices
 		for(unsigned int j = 0 ; j < 3 ; ++j)
 		{
-//			CGoGNout << "\t embedding number : " << pt[j];
-
 			FunctorSetEmb<typename PFP::MAP> femb(map, VERTEX, verticesID[pt[j]]);
+			map.foreach_dart_of_vertex(d,femb); //apply foreach for gmaps : cannot be included in the following loop
 
+			//store darts per vertices to optimize reconstruction
 			Dart dd = d;
 			do
 			{
-				femb(dd);
-				//vecDartPtrEmb[pt[j]].push_back(dd);
 				vecDartsPerVertex[pt[j]].push_back(dd);
 				dd = map.phi1(map.phi2(dd));
 			} while(dd != d);
 
 			d = map.phi1(d);
-
-//			CGoGNout << " done" << CGoGNendl;
 		}
 
-		//Embed the last vertex
-//		CGoGNout << "\t embedding number : " << pt[3] << CGoGNendl;
+		//Embed the last "top" vertex
 		d = map.phi_1(map.phi2(d));
 
 		FunctorSetEmb<typename PFP::MAP> femb(map, VERTEX, verticesID[pt[3]]);
+		map.foreach_dart_of_vertex(d,femb); //apply foreach for gmaps : cannot be included in the following loop
+
+		//store darts per vertices to optimize reconstruction
 		Dart dd = d;
 		do
 		{
-			femb(dd);
-//			CGoGNout << "embed" << CGoGNendl;
-			//vecDartPtrEmb[pt[3]].push_back(dd);
 			vecDartsPerVertex[pt[3]].push_back(dd);
 			dd = map.phi1(map.phi2(dd));
 		} while(dd != d);
 
-//		CGoGNout << "end tetra" << CGoGNendl;
+		//end of tetra
 	}
 
 //	CGoGNout << "end 1/2" << CGoGNendl;

include/Algo/Import/importTs.hpp

@@ -131,8 +131,8 @@ bool importTs(typename PFP::MAP& map, const std::string& filename, std::vector<s
 		std::stringstream oss(ligne);
 //		CGoGNout << "tetra number : " << nbe << CGoGNendl;
 
-		//Algo::Modelisation::Polyhedron<PFP>::createOrientedTetra(map);
-		Dart d = Algo::Modelisation::Polyhedron<PFP>::createOrientedPolyhedron(map,4);
+		//Algo::Modelisation::Polyhedron<PFP>::createTetra(map);
+		Dart d = Algo::Modelisation::Polyhedron<PFP>::createPolyhedron(map,4);
 		Geom::Vec4ui pt;
 		oss >> pt[0];
 		oss >> pt[1];

include/Algo/Modelisation/polyhedron.h

@@ -170,27 +170,27 @@ public:
 	/**
 	 * create simple simple polyhedron (not handled by Polyhedron object)
 	 */
-	static Dart createOrientedPolyhedron(typename PFP::MAP& the_map, int nbFaces);
+	static Dart createPolyhedron(typename PFP::MAP& the_map, int nbFaces);
 
 	/**
 	 * create simple simple tetrahedron (not handled by Polyhedron object)
 	 */
-	static Dart createOrientedTetra(typename PFP::MAP& the_map);
+	static Dart createTetra(typename PFP::MAP& the_map);
 
 	/**
 	 * create simple simple pyramid (not handled by Polyhedron object)
 	 */
-	static Dart createOrientedPyra(typename PFP::MAP& the_map);
+	static Dart createPyra(typename PFP::MAP& the_map);
 
 	/**
 	 * create simple simple hexaedron (not handled by Polyhedron object)
 	 */
-	static Dart createOrientedHexa(typename PFP::MAP& the_map);
+	static Dart createHexa(typename PFP::MAP& the_map);
 
 	/**
 	 * create simple simple prism (not handled by Polyhedron object)
 	 */
-	static Dart createOrientedPrism(typename PFP::MAP& the_map);
+	static Dart createPrism(typename PFP::MAP& the_map);
 
 	/*
 	* get the reference dart

include/Algo/Modelisation/polyhedron.hpp

@@ -167,7 +167,7 @@ m_positions(p1.m_positions)
 }
 
 template <typename PFP>
-Dart Polyhedron<PFP>::createOrientedTetra(typename PFP::MAP& the_map)
+Dart Polyhedron<PFP>::createTetra(typename PFP::MAP& the_map)
 {
 	Dart base = the_map.newFace(3,false);
 
@@ -188,102 +188,100 @@ Dart Polyhedron<PFP>::createOrientedTetra(typename PFP::MAP& the_map)
 }
 
 template <typename PFP>
-Dart Polyhedron<PFP>::createOrientedPyra(typename PFP::MAP& the_map)
+Dart Polyhedron<PFP>::createPyra(typename PFP::MAP& the_map)
 {
-	Dart base = the_map.newFace(4,false);
+	Dart base = the_map.newFace(4, false);
 
-	Dart side1 = the_map.newFace(3,false);
-	the_map.sewFaces(base,side1,false);
+	Dart side1 = the_map.newFace(3, false);
+	the_map.sewFaces(base, side1, false);
 
-	Dart side2 = the_map.newFace(3,false);
-	the_map.sewFaces(the_map.phi1(base),side2,false);
-	the_map.sewFaces(the_map.phi_1(side1), the_map.phi1(side2),false);
+	Dart side2 = the_map.newFace(3, false);
+	the_map.sewFaces(the_map.phi1(base), side2, false);
+	the_map.sewFaces(the_map.phi_1(side1), the_map.phi1(side2), false);
 
-	Dart side3 = the_map.newFace(3,false);
-	the_map.sewFaces(the_map.phi1(the_map.phi1(base)),side3,false);
-	the_map.sewFaces(the_map.phi_1(side2), the_map.phi1(side3),false);
+	Dart side3 = the_map.newFace(3, false);
+	the_map.sewFaces(the_map.phi1(the_map.phi1(base)), side3, false);
+	the_map.sewFaces(the_map.phi_1(side2), the_map.phi1(side3), false);
 
-	Dart side4 = the_map.newFace(3,false);
-	the_map.sewFaces(the_map.phi_1(base),side4,false);
-	the_map.sewFaces(the_map.phi_1(side3), the_map.phi1(side4),false);
+	Dart side4 = the_map.newFace(3, false);
+	the_map.sewFaces(the_map.phi_1(base), side4, false);
+	the_map.sewFaces(the_map.phi_1(side3), the_map.phi1(side4), false);
 
-	the_map.sewFaces(the_map.phi_1(side4), the_map.phi1(side1),false);
+	the_map.sewFaces(the_map.phi_1(side4), the_map.phi1(side1), false);
 
 	return base;
 }
 
 template <typename PFP>
-Dart Polyhedron<PFP>::createOrientedHexa(typename PFP::MAP& the_map)
+Dart Polyhedron<PFP>::createHexa(typename PFP::MAP& the_map)
 {
-	Dart base = the_map.newFace(4,false);
+	Dart base = the_map.newFace(4, false);
 
-	Dart side1 = the_map.newFace(4,false);
-	the_map.sewFaces(base,side1,false);
+	Dart side1 = the_map.newFace(4, false);
+	the_map.sewFaces(base, side1, false);
 
-	Dart side2 = the_map.newFace(4,false);
-	the_map.sewFaces(the_map.phi1(base),side2,false);
-	the_map.sewFaces(the_map.phi_1(side1), the_map.phi1(side2),false);
+	Dart side2 = the_map.newFace(4, false);
+	the_map.sewFaces(the_map.phi1(base), side2, false);
+	the_map.sewFaces(the_map.phi_1(side1), the_map.phi1(side2), false);
 
-	Dart side3 = the_map.newFace(4,false);
-	the_map.sewFaces(the_map.phi1(the_map.phi1(base)),side3,false);
-	the_map.sewFaces(the_map.phi_1(side2), the_map.phi1(side3),false);
+	Dart side3 = the_map.newFace(4, false);
+	the_map.sewFaces(the_map.phi1(the_map.phi1(base)), side3, false);
+	the_map.sewFaces(the_map.phi_1(side2), the_map.phi1(side3), false);
 
-	Dart side4 = the_map.newFace(4,false);
-	the_map.sewFaces(the_map.phi_1(base),side4,false);
-	the_map.sewFaces(the_map.phi_1(side3), the_map.phi1(side4),false);
+	Dart side4 = the_map.newFace(4, false);
+	the_map.sewFaces(the_map.phi_1(base), side4, false);
+	the_map.sewFaces(the_map.phi_1(side3), the_map.phi1(side4), false);
 
-	the_map.sewFaces(the_map.phi_1(side4), the_map.phi1(side1),false);
+	the_map.sewFaces(the_map.phi_1(side4), the_map.phi1(side1), false);
 
-	Dart top = the_map.newFace(4,false);
-	the_map.sewFaces(top,the_map.phi1(the_map.phi1(side1)),false);
-	the_map.sewFaces(the_map.phi_1(top),the_map.phi1(the_map.phi1(side2)),false);
-	the_map.sewFaces(the_map.phi1(the_map.phi1(top)),the_map.phi1(the_map.phi1(side3)),false);
-	the_map.sewFaces(the_map.phi1(top),the_map.phi1(the_map.phi1(side4)),false);
+	Dart top = the_map.newFace(4, false);
+	the_map.sewFaces(top, the_map.phi1(the_map.phi1(side1)), false);
+	the_map.sewFaces(the_map.phi_1(top), the_map.phi1(the_map.phi1(side2)), false);
+	the_map.sewFaces(the_map.phi1(the_map.phi1(top)), the_map.phi1(the_map.phi1(side3)), false);
+	the_map.sewFaces(the_map.phi1(top), the_map.phi1(the_map.phi1(side4)), false);
 
 	return base;
 }
 
 template <typename PFP>
-Dart  Polyhedron<PFP>::createOrientedPrism(typename PFP::MAP& the_map)
+Dart  Polyhedron<PFP>::createPrism(typename PFP::MAP& the_map)
 {
-	Dart base = the_map.newFace(3,false);
+	Dart base = the_map.newFace(3, false);
 
-	Dart side1 = the_map.newFace(4,false);
-	the_map.sewFaces(base,side1,false);
+	Dart side1 = the_map.newFace(4, false);
+	the_map.sewFaces(base, side1, false);
 
-	Dart side2 = the_map.newFace(4,false);
-	the_map.sewFaces(the_map.phi1(base),side2,false);
-	the_map.sewFaces(the_map.phi_1(side1), the_map.phi1(side2),false);
+	Dart side2 = the_map.newFace(4, false);
+	the_map.sewFaces(the_map.phi1(base), side2, false);
+	the_map.sewFaces(the_map.phi_1(side1), the_map.phi1(side2), false);
 
-	Dart side3 = the_map.newFace(4,false);
-	the_map.sewFaces(the_map.phi1(the_map.phi1(base)),side3,false);
-	the_map.sewFaces(the_map.phi_1(side2), the_map.phi1(side3),false);
+	Dart side3 = the_map.newFace(4, false);
+	the_map.sewFaces(the_map.phi1(the_map.phi1(base)), side3, false);
+	the_map.sewFaces(the_map.phi_1(side2), the_map.phi1(side3), false);
 
-	the_map.sewFaces(the_map.phi_1(side3), the_map.phi1(side1),false);
+	the_map.sewFaces(the_map.phi_1(side3), the_map.phi1(side1), false);
 
-	Dart top = the_map.newFace(3,false);
-	the_map.sewFaces(top,the_map.phi1(the_map.phi1(side1)),false);
-	the_map.sewFaces(the_map.phi_1(top),the_map.phi1(the_map.phi1(side2)),false);
-	the_map.sewFaces(the_map.phi1(top),the_map.phi1(the_map.phi1(side3)),false);
+	Dart top = the_map.newFace(3, false);
+	the_map.sewFaces(top, the_map.phi1(the_map.phi1(side1)), false);
+	the_map.sewFaces(the_map.phi_1(top), the_map.phi1(the_map.phi1(side2)), false);
+	the_map.sewFaces(the_map.phi1(top), the_map.phi1(the_map.phi1(side3)), false);
 
 	return base;
 }
 
 template <typename PFP>
-Dart Polyhedron<PFP>::createOrientedPolyhedron(typename PFP::MAP& the_map, int n)
+Dart Polyhedron<PFP>::createPolyhedron(typename PFP::MAP& the_map, int n)
 {
 	Dart d;
-
 	switch (n)
 	{
-		case 4 : d = createOrientedTetra(the_map);
+		case 4 : d = createTetra(the_map);
 				break;
-		case 5 : d = createOrientedPyra(the_map);
+		case 5 : d = createPyra(the_map);
 				break;
-		case 6 : d = createOrientedHexa(the_map);
+		case 6 : d = createHexa(the_map);
 				break;
 	}
-
 	return d;
 }
 
@@ -1083,8 +1081,6 @@ void Polyhedron<PFP>::mark(CellMarker& m)
 //	}
 //}
 
-
-
 template <typename PFP>
 void Polyhedron<PFP>::embedTwistedStrip( float radius_min,  float radius_max, float turns)
 {
@@ -1205,10 +1201,8 @@ void Polyhedron<PFP>::embedHelicoid(float radius_min, float radius_max, float ma
 // 	return d;
 // }
 
+} // namespace Modelisation
 
+} // namespace Algo
 
-
-
-}//end namespace
-}//end namespace
-}//end namespace
+} // namespace CGoGN

include/Algo/Modelisation/primitives3d.h

@@ -105,7 +105,7 @@ protected:
 	*/	
 	Dart HexaGrid2Topo(int nx, int ny);
 
-	Dart createOrientedHexa();
+	Dart createHexa();
 
 
 public:

include/Algo/Modelisation/primitives3d.hpp

@@ -33,7 +33,7 @@ namespace Modelisation
 
 //TEMPORAIRE
 template <typename PFP>
-Dart Primitive3D<PFP>::createOrientedHexa()
+Dart Primitive3D<PFP>::createHexa()
 {
 	Dart base = m_map.newFace(4);
 
@@ -67,13 +67,18 @@ template <typename PFP>
 Dart Primitive3D<PFP>::HexaGrid1Topo(int nx)
 {
 	// first cube
+<<<<<<< HEAD
 	Dart d0 = createOrientedHexa(); //return a dart from the base of the cube
 	m_tableVertDarts.push_back(d0); //push_back darts frome the base of cubes
+=======
+	Dart d0 = createHexa();
+	m_tableVertDarts.push_back(d0);
+>>>>>>> 9d09fe01ab3a12525ca57c400eb2777dfbc5b528
 	Dart d1 = m_map.template phi<2112>(d0);
 
 	for (int i=1; i< nx; ++i)
 	{
-		Dart d2 = createOrientedHexa();
+		Dart d2 = createHexa();
 		m_tableVertDarts.push_back(d2);
 		m_map.sewVolumes(d1,d2);
 		d1 = m_map.template phi<2112>(d2);

include/Algo/Render/GL2/topo3Render.h

@@ -144,7 +144,7 @@ protected:
 	void popColors();
 
 	/**
-	 * pick dart with color set bey setDartsIdColor
+	 * pick dart with color set by setDartsIdColor
 	 * @param x position of mouse (x)
 	 * @param y position of mouse (pass H-y, classic pb of origin)
 	 * @return the dart or NIL
@@ -270,7 +270,7 @@ class Topo3RenderMapD: public Topo3Render
 {
 public:
 	/**
-	* update all drawing buffers
+	* update all drawing buffers to render a dual map
 	* @param map the map
 	* @param good selector
 	* @param positions  attribute of position vertices
@@ -287,7 +287,7 @@ class Topo3RenderGMap: public Topo3Render
 {
 public:
 	/**
-	* update all drawing buffers
+	* update all drawing buffers to render a gmap
 	* @param map the map
 	* @param good selector
 	* @param positions  attribute of position vertices

include/Algo/Render/GL2/topo3Render.hpp

@@ -305,7 +305,6 @@ Dart Topo3Render::picking(typename PFP::MAP& map, const FunctorSelect& good, int
 	Dart d = pickColor(x,y);
 	popColors();
 	return d;
-
 }
 
 template<typename PFP>
@@ -320,7 +319,6 @@ void Topo3RenderGMap::updateData(typename PFP::MAP& map, const FunctorSelect& go
 	AutoAttributeHandler<Geom::Vec3f> vert(map, DART);
 
 	if (m_attIndex.map() != &map)
-//	if(!m_attIndex.isValid())
 	{
 		m_attIndex  = map.template addAttribute<unsigned int>(DART, "dart_index");
 	}
@@ -388,13 +386,15 @@ void Topo3RenderGMap::updateData(typename PFP::MAP& map, const FunctorSelect& go
 		}
 	}
 
-	m_nbDarts *= 2;
+	m_nbDarts *= 2; // x2 : only one orientation is used for the previous computation, multiply by 2 to get the number of darts
 
+	//colors
 	m_vbo4->bind();
 	glBufferData(GL_ARRAY_BUFFER, 2*m_nbDarts*sizeof(VEC3), 0, GL_STREAM_DRAW);
 	GLvoid* ColorDartsBuffer = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
 	VEC3* colorDartBuf = reinterpret_cast<VEC3*>(ColorDartsBuffer);
 
+	//darts
 	m_vbo0->bind();
 	glBufferData(GL_ARRAY_BUFFER, 2*m_nbDarts*sizeof(VEC3), 0, GL_STREAM_DRAW);
 	GLvoid* PositionDartsBuffer = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
@@ -418,8 +418,11 @@ void Topo3RenderGMap::updateData(typename PFP::MAP& map, const FunctorSelect& go
 			{
 				const VEC3& P = positions[dd];
 				vecPos.push_back(P);
-//				m_attIndex[dd] = posDBI;
+				m_attIndex[dd] = posDBI;
+				posDBI+=2;
+				m_attIndex[map.beta0(dd)] = posDBI; //for gmap : also affect a number to the other orientation for picking
 				posDBI+=2;
+
 				center += P;
 				dd = map.phi1(dd);
 			} while (dd != d);

include/Algo/Render/GL2/topoRender.h

@@ -189,7 +189,7 @@ public:
 
 
 	/**
-	 * pick dart with color set bey setDartsIdColor
+	 * pick dart with color set by setDartsIdColor
 	 * Do not forget to apply same transformation to scene before picking than before drawing !
 	 * @param map the map in which we pick (same as drawn !)
 	 * @param good the selector (same as used during drawing)
@@ -205,7 +205,7 @@ class TopoRenderMapD : public TopoRender
 {
 public:
 	/**
-	* update all drawing buffers
+	* update all drawing buffers to render a dual map
 	* @param map the map
 	* @param positions  attribute of position vertices
 	* @param ke exploding coef for edge
@@ -220,7 +220,7 @@ class TopoRenderGMap : public TopoRender
 {
 public:
 	/**
-	* update all drawing buffers
+	* update all drawing buffers to render a gmap
 	* @param map the map
 	* @param positions  attribute of position vertices
 	* @param ke exploding coef for edge

src/Algo/ImplicitHierarchicalMesh/ihm3.cpp

@@ -481,10 +481,10 @@ bool ImplicitHierarchicalMap3::faceCanBeCoarsened(Dart d)
 		subd = true;
 		Dart d3 = phi3(d);
 
-		std::cout << "d3 = " << d3 << std::endl;
-		std::cout << "d = " << d << std::endl;
-		std::cout << "curLevel = " << m_curLevel << std::endl;
-		std::cout << "volSubd(d3) = " << volumeIsSubdivided(d3) << std::endl;
+//		std::cout << "d3 = " << d3 << std::endl;
+//		std::cout << "d = " << d << std::endl;
+//		std::cout << "curLevel = " << m_curLevel << std::endl;
+//		std::cout << "volSubd(d3) = " << volumeIsSubdivided(d3) << std::endl;
 
 		//tester si le volume voisin est subdivise
 		if(d3 != d && volumeIsSubdivided(d3))
@@ -506,8 +506,8 @@ bool ImplicitHierarchicalMap3::faceCanBeCoarsened(Dart d)
 		--m_curLevel;
 	}
 
-	std::cout << "subdNeighborhood = " << subdNeighborhood << std::endl;
-	std::cout << "faceCanBeCoarsened ? " << (subd && !subdNeighborhood && subdOnce) << std::endl;
+//	std::cout << "subdNeighborhood = " << subdNeighborhood << std::endl;
+// 	std::cout << "faceCanBeCoarsened ? " << (subd && !subdNeighborhood && subdOnce) << std::endl;
 
 	return subd && !subdNeighborhood && subdOnce;
 }