Modification of topological rendering

TopoRender & Topo3Render can now directly render Map & GMap (see tuto1 & tuto5)
Correction of bug in gmap2 (face of boundary was not marked)

Apps/Tuto/tuto1.cpp

@@ -88,7 +88,7 @@ void MyQT::createMap()
 // initialization GL callback
 void MyQT::cb_initGL()
 {
-	m_render_topo = new Algo::Render::GL2::TopoRenderMapD() ;
+	m_render_topo = new Algo::Render::GL2::TopoRender() ;
 }
 
 // redraw GL callback (clear and swap already done)

Apps/Tuto/tuto1.h

@@ -25,14 +25,20 @@
 #ifndef _TUTO1_
 #define _TUTO1_
 
+#define USE_GMAP
+
 #include "Utils/Qt/qtSimple.h"
 #include "Utils/cgognStream.h"
 
 #include "Topology/generic/parameters.h"
-#include "Topology/map/embeddedMap2.h"
-#include "Algo/Render/GL2/topoRender.h"
 
+#ifdef USE_GMAP
+	#include "Topology/gmap/embeddedGMap2.h"
+#else
+	#include "Topology/map/embeddedMap2.h"
+#endif
 
+#include "Algo/Render/GL2/topoRender.h"
 
 using namespace CGoGN ;
 
@@ -43,10 +49,15 @@ using namespace CGoGN ;
 struct PFP: public PFP_STANDARD
 {
 	// definition of the type of the map
+#ifdef USE_GMAP
+	typedef EmbeddedGMap2 MAP;
+#else
 	typedef EmbeddedMap2 MAP;
+#endif
 };
 
 
+
 class MyQT: public Utils::QT::SimpleQT
 {
 	Q_OBJECT
@@ -61,7 +72,7 @@ protected:
 	PFP::MAP myMap;
 
 	// render (for the topo)
-	Algo::Render::GL2::TopoRenderMapD* m_render_topo;
+	Algo::Render::GL2::TopoRender* m_render_topo;
 
 	// just for more compact writing
 	inline Dart PHI1(Dart d)	{return myMap.phi1(d);}

Apps/Tuto/tuto2.h

@@ -25,12 +25,18 @@
 #ifndef _TUTO2_
 #define _TUTO2_
 
+#define USE_GMAP
+
 
 #include "Utils/Qt/qtSimple.h"
 #include "Utils/cgognStream.h"
-
 #include "Topology/generic/parameters.h"
-#include "Topology/map/embeddedMap2.h"
+
+#ifdef USE_GMAP
+	#include "Topology/gmap/embeddedGMap2.h"
+#else
+	#include "Topology/map/embeddedMap2.h"
+#endif
 
 #include "Algo/Render/GL2/mapRender.h"
 #include "Utils/Shaders/shaderSimpleColor.h"
@@ -46,7 +52,11 @@ using namespace CGoGN ;
 struct PFP: public PFP_STANDARD
 {
 	// definition of the type of the map
+#ifdef USE_GMAP
+	typedef EmbeddedGMap2 MAP;
+#else
 	typedef EmbeddedMap2 MAP;
+#endif
 };
 
 

Apps/Tuto/tuto3.cpp

@@ -157,7 +157,7 @@ void MyQT::createMap()
 // initialization GL callback
 void MyQT::cb_initGL()
 {
-	m_render_topo = new Algo::Render::GL2::TopoRenderMapD() ;
+	m_render_topo = new Algo::Render::GL2::TopoRender();
 }
 
 // redraw GL callback (clear and swap already done)

Apps/Tuto/tuto3.h

@@ -65,7 +65,7 @@ protected:
 	PFP::TVEC3 position;
 
 	// render (for the topo)
-	Algo::Render::GL2::TopoRenderMapD* m_render_topo;
+	Algo::Render::GL2::TopoRender* m_render_topo;
 
 	// selected dart (mouse click)
 	Dart dart_selected;

Apps/Tuto/tuto4.cpp

@@ -165,7 +165,7 @@ void MyQT::createMap()
 // initialization GL callback
 void MyQT::cb_initGL()
 {
-	m_render_topo = new Algo::Render::GL2::TopoRenderMapD() ;
+	m_render_topo = new Algo::Render::GL2::TopoRender() ;
 }
 
 // redraw GL callback (clear and swap already done)

Apps/Tuto/tuto4.h

@@ -63,7 +63,7 @@ protected:
 	PFP::TVEC3 position;
 
 	// render (for the topo)
-	Algo::Render::GL2::TopoRenderMapD* m_render_topo;
+	Algo::Render::GL2::TopoRender* m_render_topo;
 
 	// selected dart (mouse click)
 	std::vector<Dart> dart_selected;

Apps/Tuto/tuto5.cpp

@@ -22,13 +22,18 @@
 *                                                                              *
 *******************************************************************************/
 
-#include "tuto5.h"
+#define WITH_GMAP 1
+
 
+#include "tuto5.h"
 #include <iostream>
 
 #include "Topology/generic/parameters.h"
-#include "Topology/map/embeddedMap3.h"
-
+#ifdef WITH_GMAP
+	#include "Topology/gmap/embeddedGMap3.h"
+#else
+	#include "Topology/map/embeddedMap3.h"
+#endif
 
 #include "Geometry/vector_gen.h"
 #include "Algo/Geometry/boundingbox.h"
@@ -55,7 +60,11 @@ using namespace CGoGN ;
 struct PFP: public PFP_STANDARD
 {
 	// definition de la carte
+#ifdef WITH_GMAP
+	typedef EmbeddedGMap3 MAP;
+#else
 	typedef EmbeddedMap3 MAP;
+#endif
 };
 
 PFP::MAP myMap;
@@ -143,7 +152,7 @@ void MyQT::cb_initGL()
 	// create the render
 	m_render = new Algo::Render::GL2::MapRender();
 
-    m_render_topo = new Algo::Render::GL2::Topo3RenderMapD();
+    m_render_topo = new Algo::Render::GL2::Topo3Render();
 
  	// create VBO for position
 	m_positionVBO = new Utils::VBO();
@@ -190,7 +199,7 @@ void MyQT::cb_initGL()
 	m_render->initPrimitives<PFP>(myMap, allDarts, Algo::Render::GL2::POINTS);
 
 	SelectorDartNoBoundary<PFP::MAP> nb(myMap);
-	m_render_topo->updateData<PFP>(myMap, nb, position,  0.9f, 0.9f, 0.9f);
+	m_render_topo->updateData<PFP>(myMap, position,  0.9f, 0.9f, 0.9f, nb);
 
 
 	// timer example for animation

Apps/Tuto/tuto5.h

@@ -36,7 +36,7 @@
 
 // forward definitions (minimize includes)
 namespace CGoGN { namespace Algo { namespace Render { namespace GL2 { class MapRender; } } } }
-namespace CGoGN { namespace Algo { namespace Render { namespace GL2 { class Topo3RenderMapD; } } } }
+namespace CGoGN { namespace Algo { namespace Render { namespace GL2 { class Topo3Render; } } } }
 namespace CGoGN { namespace Utils { class VBO; } }
 namespace CGoGN { namespace Utils { class ShaderSimpleColor; } }
 namespace CGoGN { namespace Utils { class Strings3D; } }
@@ -63,7 +63,7 @@ class MyQT: public Utils::QT::SimpleQT
     bool render_topo;
 
 	Algo::Render::GL2::MapRender* m_render;
-	Algo::Render::GL2::Topo3RenderMapD* m_render_topo;
+	Algo::Render::GL2::Topo3Render* m_render_topo;
 
 	Utils::VBO* m_positionVBO;
 	Utils::VBO* m_dataVBO;

include/Algo/Render/GL2/topo3Render.h

@@ -60,9 +60,9 @@ protected:
 	/**
 	* vbo buffers
 	* 0: vertices darts
-	* 1: vertices phi1
-	* 2: vertices phi2
-	* 3: vertices phi3
+	* 1: vertices phi1 / beta1
+	* 2: vertices phi2 / beta2
+	* 3: vertices phi3 / beta3
 	* 4: colors
 	*/
 	Utils::VBO* m_vbo0;
@@ -238,8 +238,6 @@ public:
 	 */
 	void overdrawDart(Dart d, float width, float r, float g, float b);
 
-
-
 	/*
 	 * store darts in color for picking
 	 * @param map the map (must be the same than during updating data)
@@ -248,8 +246,6 @@ public:
 	template<typename PFP>
 	void setDartsIdColor(typename PFP::MAP& map, const FunctorSelect& good);
 
-
-
 	/**
 	 * pick dart with color set bey setDartsIdColor
 	 * Do not forget to apply same transformation to scene before picking than before drawing !
@@ -262,13 +258,6 @@ public:
 	template<typename PFP>
 	Dart picking(typename PFP::MAP& map, const FunctorSelect& good, int x, int y);
 
-};
-
-
-
-class Topo3RenderMapD: public Topo3Render
-{
-public:
 	/**
 	* update all drawing buffers to render a dual map
 	* @param map the map
@@ -279,27 +268,37 @@ public:
  	* @param kv exploding coef for face
 	*/
 	template<typename PFP>
-	void updateData(typename PFP::MAP& map, const FunctorSelect& good, const typename PFP::TVEC3& positions, float ke, float kf, float kv);
-};
+	void updateData(typename PFP::MAP& map, const typename PFP::TVEC3& positions, float ke, float kf, float kv, const FunctorSelect& good = allDarts);
 
+protected:
+	/**
+	* 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
+	* @param kf exploding coef for face
+ 	* @param kv exploding coef for face
+	* @param good selector
+	*/
+	template<typename PFP>
+	void updateDataMap3(typename PFP::MAP& map, const typename PFP::TVEC3& positions, float ke, float kf, float kv, const FunctorSelect& good = allDarts);
 
-class Topo3RenderGMap: public Topo3Render
-{
-public:
 	/**
 	* update all drawing buffers to render a gmap
 	* @param map the map
-	* @param good selector
 	* @param positions  attribute of position vertices
 	* @param ke exploding coef for edge
 	* @param kf exploding coef for face
  	* @param kv exploding coef for face
+	* @param good selector
 	*/
 	template<typename PFP>
-	void updateData(typename PFP::MAP& map, const FunctorSelect& good, const typename PFP::TVEC3& positions, float kd, float ke, float kf, float kv);
+	void updateDataGMap3(typename PFP::MAP& map, const typename PFP::TVEC3& positions, float ke, float kf, float kv, const FunctorSelect& good = allDarts);
+
 };
 
-}//end namespace VBO
+
+}//end namespace GL2
 
 }//end namespace Algo
 

include/Algo/Render/GL2/topo3Render.hpp

@@ -42,10 +42,27 @@ namespace Render
 
 namespace GL2
 {
+template<typename PFP>
+void Topo3Render::updateData(typename PFP::MAP& map, const typename PFP::TVEC3& positions, float ke, float kf, float kv, const FunctorSelect& good)
+{
+	Map3* ptrMap3 = dynamic_cast<Map3*>(&map);
+	if (ptrMap3 != NULL)
+	{
+		updateDataMap3<PFP>(map,positions,ke,kf,kv,good);
+	}
+	GMap3* ptrGMap3 = dynamic_cast<GMap3*>(&map);
+	if (ptrGMap3 != NULL)
+	{
+		updateDataGMap3<PFP>(map,positions,ke,kf,kv,good);
+	}
+}
+
 
 template<typename PFP>
-void Topo3RenderMapD::updateData(typename PFP::MAP& map, const FunctorSelect& good, const typename PFP::TVEC3& positions, float ke, float kf, float kv)
+void Topo3Render::updateDataMap3(typename PFP::MAP& mapx, const typename PFP::TVEC3& positions, float ke, float kf, float kv, const FunctorSelect& good)
 {
+	Map3& map = reinterpret_cast<Map3&>(mapx);
+
 	typedef typename PFP::VEC3 VEC3;
 	typedef typename PFP::REAL REAL;
 
@@ -57,8 +74,6 @@ void Topo3RenderMapD::updateData(typename PFP::MAP& map, const FunctorSelect& go
 			m_attIndex  = map.template addAttribute<unsigned int>(DART, "dart_index");
 	}
 
-
-
 	m_nbDarts = 0;
 
 	// table of center of volume
@@ -236,7 +251,7 @@ void Topo3RenderMapD::updateData(typename PFP::MAP& map, const FunctorSelect& go
 				m_nbRel2++;
 			}
 			e = map.phi3(d);
-			if (!map.isBoundaryFace(d) && (d < e))
+			if (!map.isBoundaryMarked(e) && (d < e))
 			{
 				*positionF3++ = fv2[d];
 				*positionF3++ = fv2x[e];
@@ -268,7 +283,6 @@ void Topo3RenderMapD::updateData(typename PFP::MAP& map, const FunctorSelect& go
 template<typename PFP>
 void Topo3Render::setDartsIdColor(typename PFP::MAP& map, const FunctorSelect& good)
 {
-
 	m_vbo4->bind();
 	float* colorBuffer =  reinterpret_cast<float*>(glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE));
 	unsigned int nb=0;
@@ -312,15 +326,13 @@ Dart Topo3Render::picking(typename PFP::MAP& map, const FunctorSelect& good, int
 }
 
 template<typename PFP>
-void Topo3RenderGMap::updateData(typename PFP::MAP& map, const FunctorSelect& good, const typename PFP::TVEC3& positions, float kd, float ke, float kf, float kv)
+void Topo3Render::updateDataGMap3(typename PFP::MAP& mapx, const typename PFP::TVEC3& positions, float ke, float kf, float kv, const FunctorSelect& good)
 {
+	GMap3& map = reinterpret_cast<GMap3&>(mapx);
+
 	typedef typename PFP::VEC3 VEC3;
 	typedef typename PFP::REAL REAL;
 
-	AutoAttributeHandler<Geom::Vec3f> posBeta1(map, DART);
-	AutoAttributeHandler<Geom::Vec3f> posBeta2(map, DART); //beta 3 link is represented at the same location as beta2
-	AutoAttributeHandler<Geom::Vec3f> posBeta2x(map, DART); //beta 3 link is represented at the same location as beta2
-	AutoAttributeHandler<Geom::Vec3f> vert(map, DART);
 
 	if (m_attIndex.map() != &map)
 	{
@@ -331,29 +343,25 @@ void Topo3RenderGMap::updateData(typename PFP::MAP& map, const FunctorSelect& go
 
 	m_nbDarts = 0;
 
-	// table of face (one dart of each)
-	std::vector<Dart> vecDartFaces;
-	vecDartFaces.reserve(map.getNbDarts()/6); //6 = nb of darts for tri mesh
-
+	// table of center of volume
+	std::vector<VEC3> vecCenters;
+	vecCenters.reserve(1000);
 	// table of nbfaces per volume
 	std::vector<unsigned int> vecNbFaces;
-	vecNbFaces.reserve(vecDartFaces.size());
-
-	// table of center of volume
-	std::vector<VEC3> vecVolCenters;
-	vecVolCenters.reserve(vecDartFaces.size()/4); // = nb of volumes for a tetra mesh
+	vecNbFaces.reserve(1000);
+	// table of face (one dart of each)
+	std::vector<Dart> vecDartFaces;
+	vecDartFaces.reserve(map.getNbDarts()/4);
 
 	DartMarker mark(map);					// marker for darts
-	CellMarker mVol(map, VOLUME);
 	for (Dart d = map.begin(); d != map.end(); map.next(d))
 	{
-		if(!mVol.isMarked(d))
+		if (good(d))
 		{
-			mVol.mark(d);
 			CellMarkerStore markVert(map, VERTEX);		//marker for vertices
-			VEC3 center(0);
-			unsigned int nbVertices = 0;
-			unsigned int nbFace = 0;
+			VEC3 center(0, 0, 0);
+			unsigned int nbv = 0;
+			unsigned int nbf = 0;
 			std::list<Dart> visitedFaces;	// Faces that are traversed
 			visitedFaces.push_back(d);		// Start with the face of d
 
@@ -364,31 +372,285 @@ void Topo3RenderGMap::updateData(typename PFP::MAP& map, const FunctorSelect& go
 				{
 					// store a dart of face
 					vecDartFaces.push_back(*face);
-					nbFace++;
+					nbf++;
 					Dart dNext = *face ;
 					do
 					{
-						mark.mark(dNext); // Mark
-						m_nbDarts++;
-
 						if (!markVert.isMarked(dNext))
 						{
 							markVert.mark(dNext);
 							center += positions[dNext];
-							nbVertices++;
+							nbv++;
 						}
-
-						Dart adj = map.phi2(dNext); // add adjacent face if not done already
+						mark.mark(dNext);					// Mark
+						m_nbDarts++;
+						Dart adj = map.phi2(dNext);				// Get adjacent face
 						if (adj != dNext && !mark.isMarked(adj))
-							visitedFaces.push_back(adj);
-
+							visitedFaces.push_back(adj);	// Add it
 						dNext = map.phi1(dNext);
 					} while(dNext != *face);
 				}
 			}
-			center /= typename PFP::REAL(nbVertices);
-			vecVolCenters.push_back(center);
-			vecNbFaces.push_back(nbFace);
+			center /= typename PFP::REAL(nbv);
+			vecCenters.push_back(center);
+			vecNbFaces.push_back(nbf);
+		}
+	}
+
+	m_nbDarts *=2;
+
+	// beta1
+	AutoAttributeHandler<VEC3> fv1(map, DART);
+	// beta2/3
+	AutoAttributeHandler<VEC3> fv2(map, DART);
+	AutoAttributeHandler<VEC3> fv2x(map, DART);
+
+	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);
+
+	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);
+	VEC3* positionDartBuf = reinterpret_cast<VEC3*>(PositionDartsBuffer);
+	unsigned int posDBI=0;
+
+	std::vector<Dart>::iterator face = vecDartFaces.begin();
+	for (unsigned int iVol=0; iVol<vecNbFaces.size(); ++iVol)
+	{
+		for (unsigned int iFace = 0; iFace < vecNbFaces[iVol]; ++iFace)
+		{
+			Dart d = *face++;
+
+			std::vector<VEC3> vecPos;
+			vecPos.reserve(16);
+
+			// store the face & center
+			VEC3 center(0, 0, 0);
+			Dart dd = d;
+			do
+			{
+				const VEC3& P = positions[d];
+				vecPos.push_back(P);
+				m_attIndex[d] = posDBI;
+				posDBI+=2;
+				center += P;
+				d = map.phi1(d);
+			} while (d != dd);
+			center /= REAL(vecPos.size());
+
+			//shrink the face
+			unsigned int nb = vecPos.size();
+			float okf = 1.0f - kf;
+			float okv = 1.0f - kv;
+			for (unsigned int i = 0; i < nb; ++i)
+			{
+				vecPos[i] = vecCenters[iVol]*okv + vecPos[i]*kv;
+				vecPos[i] = center*okf + vecPos[i]*kf;
+			}
+			vecPos.push_back(vecPos.front()); // copy the first for easy computation on next loop
+
+			// compute position of points to use for drawing topo
+			float oke = 1.0f - ke;
+			for (unsigned int i = 0; i < nb; ++i)
+			{
+				VEC3 P = vecPos[i]*ke + vecPos[i+1]*oke;
+				VEC3 Q = vecPos[i+1]*ke + vecPos[i]*oke;
+
+				VEC3 PP = 0.52f*P + 0.48f*Q;
+				VEC3 QQ = 0.52f*Q + 0.48f*P;
+
+				*positionDartBuf++ = P;
+				*positionDartBuf++ = PP;
+				*positionDartBuf++ = Q;
+				*positionDartBuf++ = QQ;
+				*colorDartBuf++ = VEC3(1.,1.,1.);
+				*colorDartBuf++ = VEC3(1.,1.,1.);
+				*colorDartBuf++ = VEC3(1.,1.,1.);
+				*colorDartBuf++ = VEC3(1.,1.,1.);
+
+				fv1[d] = P*0.9f + PP*0.1f;
+				fv2x[d] = P*0.52f + PP*0.48f;
+				fv2[d] = P*0.48f + PP*0.52f;
+				Dart dx = map.beta0(d);
+				fv1[dx] = Q*0.9f + QQ*0.1f;
+				fv2[dx] = Q*0.52f + QQ*0.48f;
+				fv2x[dx] = Q*0.48f + QQ*0.52f;
+				d = map.phi1(d);
+			}
+
+		}
+	}
+
+	m_vbo0->bind();
+	glUnmapBuffer(GL_ARRAY_BUFFER);
+
+	// beta1
+	m_vbo1->bind();
+	glBufferData(GL_ARRAY_BUFFER, m_nbDarts*sizeof(typename PFP::VEC3), 0, GL_STREAM_DRAW);
+	GLvoid* PositionBuffer1 = glMapBufferARB(GL_ARRAY_BUFFER, GL_READ_WRITE);
+
+	// beta2
+	m_vbo2->bind();
+	glBufferData(GL_ARRAY_BUFFER, 2*m_nbDarts*sizeof(typename PFP::VEC3), 0, GL_STREAM_DRAW);
+	GLvoid* PositionBuffer2 = glMapBufferARB(GL_ARRAY_BUFFER, GL_READ_WRITE);
+
+	// beta3
+	m_vbo3->bind();
+	glBufferData(GL_ARRAY_BUFFER, 2*m_nbDarts*sizeof(typename PFP::VEC3), 0, GL_STREAM_DRAW);
+	GLvoid* PositionBuffer3 = glMapBufferARB(GL_ARRAY_BUFFER, GL_READ_WRITE);
+
+	VEC3* positionF1 = reinterpret_cast<VEC3*>(PositionBuffer1);
+	VEC3* positionF2 = reinterpret_cast<VEC3*>(PositionBuffer2);
+	VEC3* positionF3 = reinterpret_cast<VEC3*>(PositionBuffer3);
+
+	m_nbRel2=0;
+	m_nbRel3=0;
+
+	for(std::vector<Dart>::iterator face = vecDartFaces.begin(); face != vecDartFaces.end(); ++face)
+	{
+		Dart d = *face;
+		do
+		{
+			Dart e = map.beta2(d);
+			if (d < e)
+			{
+				*positionF2++ = fv2[d];
+				*positionF2++ = fv2x[e];
+				*positionF2++ = fv2[e];
+				*positionF2++ = fv2x[d];
+				m_nbRel2++;
+			}
+			e = map.beta3(d);
+			if (!map.isBoundaryMarked(e) && (d < e))
+			{
+				*positionF3++ = fv2[d];
+				*positionF3++ = fv2x[e];
+				*positionF3++ = fv2[e];
+				*positionF3++ = fv2x[d];
+				m_nbRel3++;
+			}
+			d = map.beta0(d);
+			e = map.beta2(d);
+			if (d < e)
+			{
+				*positionF2++ = fv2[d];
+				*positionF2++ = fv2x[e];
+				*positionF2++ = fv2[e];
+				*positionF2++ = fv2x[d];
+				m_nbRel2++;
+			}
+			e = map.beta3(d);
+			if (!map.sBoundaryMarked(e) && (d < e))
+			{
+				*positionF3++ = fv2[d];
+				*positionF3++ = fv2x[e];
+				*positionF3++ = fv2[e];
+				*positionF3++ = fv2x[d];
+				m_nbRel3++;
+			}
+			*positionF1++ = fv1[d];
+			d = map.beta1(d);
+			*positionF1++ = fv1[d];
+		} while (d != *face );
+	}
+
+	m_vbo3->bind();
+	glUnmapBufferARB(GL_ARRAY_BUFFER);
+
+	m_vbo2->bind();
+	glUnmapBufferARB(GL_ARRAY_BUFFER);
+