Merge branch 'develop' into 'master'

Develop



See merge request !86

Apps/Examples/volumeExplorer.cpp

@@ -415,7 +415,7 @@ int main(int argc, char **argv)
 	{
 		position = myMap.addAttribute<VEC3, VERTEX, MAP>("position");
 
-		int nb = 16;
+		int nb = 3;
 		Algo::Volume::Tilings::Cubic::Grid<PFP> cubic(myMap, nb, nb, nb);
 		cubic.embedIntoGrid(position, 1.0f, 1.0f, 1.0f);
 

Apps/Tuto/Modelling/tuto_oper2.cpp

@@ -132,7 +132,7 @@ void MyQT::operation(int x)
 		break;
 	case 7:
 		CGoGNout <<"split face"<<CGoGNendl;
-		if (m_selected != NIL)
+		if ((m_selected != NIL) && (m_selected2 != NIL) && myMap.sameFace(m_selected,m_selected2))
 		{
 			myMap.splitFace(m_selected,m_selected2);
 			updateMap();
@@ -310,6 +310,26 @@ void MyQT::cb_keyPress(int keycode)
 		updateMap();
 		updateGL();
 		break;
+	case '1':
+		if (m_selected!=NIL)
+			m_selected = myMap.phi1(m_selected);
+		updateMap();
+		updateGL();
+		break;
+	case '2':
+		if (m_selected!=NIL)
+			m_selected = myMap.phi2(m_selected);
+		updateMap();
+		updateGL();
+		break;
+
+	case ' ':
+		m_selected=NIL;
+		m_selected2=NIL;
+		updateMap();
+		updateGL();
+		break;
+
 	}
 	updateGL();
 }

CGoGN/include/Algo/MC/marchingcube.hpp

@@ -1230,10 +1230,13 @@ void MarchingCube<DataType, Windowing, PFP>::recalPoints(const Geom::Vec3f& orig
 	{
 		VEC3& P = m_positions[i];
 		P -= m_fOrigin;
-		P[0] = (P[0]+0.5f) * m_fScal[0];
-		P[1] = (P[1]+0.5f) * m_fScal[1];
-		P[2] = (P[2]+0.5f) * m_fScal[2];
-		P+=origin;
+		P[0] = P[0] * m_fScal[0];
+		P[1] = P[1] * m_fScal[1];
+		P[2] = P[2] * m_fScal[2];
+//		P[0] = (P[0]+0.5f) * m_fScal[0];
+//		P[1] = (P[1]+0.5f) * m_fScal[1];
+//		P[2] = (P[2]+0.5f) * m_fScal[2];
+		P-=origin;
 	}
 }
 

CGoGN/include/Container/attributeMultiVector.hpp

@@ -191,7 +191,7 @@ bool AttributeMultiVector<T>::copy(const AttributeMultiVectorGen* atmvg)
 	}
 
 	for (unsigned int i = 0; i < atmv->m_tableData.size(); ++i)
-		std::memcpy(m_tableData[i], atmv->m_tableData[i], _BLOCKSIZE_ * sizeof(T));
+		std::memcpy( (void*) m_tableData[i], (void*) atmv->m_tableData[i], _BLOCKSIZE_ * sizeof(T));
 
 	return true;
 }

CGoGN/include/Topology/generic/traversor/traversorCell.hpp

@@ -648,28 +648,155 @@ inline void foreach_cell_until(const MAP& map, FUNC f, TraversalOptim opt)
 namespace Parallel
 {
 
+///// internal functor for boost call
+//template <unsigned int ORBIT, typename FUNC>
+//class ThreadFunction
+//{
+//protected:
+//	typedef Cell<ORBIT> CELL;
+//	std::vector<CELL>& m_cells;
+//	Utils::Barrier& m_sync1;
+//	Utils::Barrier& m_sync2;
+//	bool& m_finished;
+//	unsigned int m_id;
+//	FUNC m_lambda;
+//	std::thread::id& m_threadId; // ref on thread::id in table of threads in genericMap for init at operator()
+
+//public:
+//	ThreadFunction(FUNC func, std::vector<CELL>& vd, Utils::Barrier& s1, Utils::Barrier& s2, bool& finished, unsigned int id, std::thread::id& threadId) :
+//		m_cells(vd), m_sync1(s1), m_sync2(s2), m_finished(finished), m_id(id), m_lambda(func), m_threadId(threadId)
+//	{
+//	}
+
+//	ThreadFunction(const ThreadFunction<ORBIT, FUNC>& tf):
+//		m_cells(tf.m_cells), m_sync1(tf.m_sync1), m_sync2(tf.m_sync2), m_finished(tf.m_finished), m_id(tf.m_id), m_lambda(tf.m_lambda){}
+
+//	std::thread::id& getThreadId() { return m_threadId; }
+
+//	void operator()()
+//	{
+//		// first thing to do set the thread id in genericMap
+//		m_threadId = std::this_thread::get_id();
+
+//		while (!m_finished)
+//		{
+//			for (typename std::vector<CELL>::const_iterator it = m_cells.begin(); it != m_cells.end(); ++it)
+//				m_lambda(*it, m_id);
+//			m_cells.clear();
+//			m_sync1.wait(); // wait every body has finished
+//			m_sync2.wait(); // wait vectors has been refilled
+//		}
+//	}
+//};
+
+
+//template <TraversalOptim OPT, unsigned int ORBIT, typename MAP, typename FUNC>
+//void foreach_cell_tmpl(MAP& map, FUNC func, unsigned int nbth)
+//{
+//	// buffer for cell traversing
+//	std::vector< Cell<ORBIT> >* vd = new std::vector< Cell<ORBIT> >[nbth];
+//	for (unsigned int i = 0; i < nbth; ++i)
+//		vd[i].reserve(SIZE_BUFFER_THREAD);
+
+//	unsigned int nb = 0;
+//	TraversorCell<MAP, ORBIT, OPT> trav(map);
+//	Cell<ORBIT> cell = trav.begin();
+//	Cell<ORBIT> c_end = trav.end();
+//	while ((cell.dart != c_end.dart) && (nb < nbth*SIZE_BUFFER_THREAD) )
+//	{
+//		vd[nb%nbth].push_back(cell);
+//		nb++;
+//		cell = trav.next();
+//	}
+//	Utils::Barrier sync1(nbth+1);
+//	Utils::Barrier sync2(nbth+1);
+//	bool finished=false;
+
+//	// launch threads
+//	std::thread** threads = new std::thread*[nbth];
+//	ThreadFunction<ORBIT,FUNC>** tfs = new ThreadFunction<ORBIT,FUNC>*[nbth];
+
+//	// add place for nbth new threads in the table of threadId in genericmap
+////	unsigned int firstThread = map.addEmptyThreadIds(nbth);
+
+//	for (unsigned int i = 0; i < nbth; ++i)
+//	{
+//		std::thread::id& threadId = map.addEmptyThreadId();
+//		tfs[i] = new ThreadFunction<ORBIT,FUNC>(func, vd[i], sync1, sync2, finished, 1+i, threadId);
+//		threads[i] = new std::thread( std::ref( *(tfs[i]) ) );
+//	}
+
+//	// and continue to traverse the map
+//	std::vector< Cell<ORBIT> >* tempo = new std::vector< Cell<ORBIT> >[nbth];
+//	for (unsigned int i = 0; i < nbth; ++i)
+//		tempo[i].reserve(SIZE_BUFFER_THREAD);
+
+//	while (cell.dart != c_end.dart)
+//	{
+//		for (unsigned int i = 0; i < nbth; ++i)
+//			tempo[i].clear();
+//		unsigned int nb = 0;
+
+//		while ((cell.dart != c_end.dart) && (nb < nbth*SIZE_BUFFER_THREAD) )
+//		{
+//			tempo[nb%nbth].push_back(cell);
+//			nb++;
+//			cell = trav.next();
+//		}
+//		sync1.wait();// wait for all thread to finish its vector
+//		for (unsigned int i = 0; i < nbth; ++i)
+//			vd[i].swap(tempo[i]);
+//		sync2.wait();// everybody refilled then go
+//	}
+
+//	sync1.wait(); // wait for all thread to finish its vector
+//	finished = true; // say finsih to everyone
+//	sync2.wait(); // just wait for last barrier wait !
+
+//	// wait for all theads to be finished
+//	for (unsigned int i = 0; i < nbth; ++i)
+//	{
+//		threads[i]->join();
+//		delete threads[i];
+//		map.removeThreadId(tfs[i]->getThreadId());
+//		delete tfs[i];
+//	}
+
+//	delete[] tfs;
+//	delete[] threads;
+//	delete[] vd;
+//	delete[] tempo;
+//}
+
+
 /// internal functor for boost call
-template <unsigned int ORBIT, typename FUNC>
+template <TraversalOptim OPT, unsigned int ORBIT, typename MAP, typename FUNC>
 class ThreadFunction
 {
 protected:
 	typedef Cell<ORBIT> CELL;
-	std::vector<CELL>& m_cells;
-	Utils::Barrier& m_sync1;
-	Utils::Barrier& m_sync2;
-	bool& m_finished;
+
+	std::vector<CELL> m_cells;
+
 	unsigned int m_id;
 	FUNC m_lambda;
 	std::thread::id& m_threadId; // ref on thread::id in table of threads in genericMap for init at operator()
+	std::mutex& m_mutex_map;
+	TraversorCell<MAP, ORBIT, OPT>& m_trav;
+	Cell<ORBIT>& m_current_cell;
+
 
 public:
-	ThreadFunction(FUNC func, std::vector<CELL>& vd, Utils::Barrier& s1, Utils::Barrier& s2, bool& finished, unsigned int id, std::thread::id& threadId) :
-		m_cells(vd), m_sync1(s1), m_sync2(s2), m_finished(finished), m_id(id), m_lambda(func), m_threadId(threadId)
+	ThreadFunction(FUNC func,unsigned int id, std::thread::id& threadId, std::mutex& mutmap, TraversorCell<MAP, ORBIT, OPT>& trav, Cell<ORBIT>& current_cell) :
+		m_id(id), m_lambda(func), m_threadId(threadId),
+		m_mutex_map(mutmap), m_trav(trav), m_current_cell(current_cell)
 	{
 	}
 
-	ThreadFunction(const ThreadFunction<ORBIT, FUNC>& tf):
-		m_cells(tf.m_cells), m_sync1(tf.m_sync1), m_sync2(tf.m_sync2), m_finished(tf.m_finished), m_id(tf.m_id), m_lambda(tf.m_lambda){}
+	ThreadFunction(const ThreadFunction<OPT,ORBIT,MAP,FUNC>& tf):
+		 m_id(tf.m_id), m_lambda(tf.m_lambda),
+		 m_mutex_map(tf.mutmap), m_trav(tf.trav), m_current_cell(tf.current_cell)
+	{}
 
 	std::thread::id& getThreadId() { return m_threadId; }
 
@@ -678,81 +805,55 @@ public:
 		// first thing to do set the thread id in genericMap
 		m_threadId = std::this_thread::get_id();
 
-		while (!m_finished)
+		m_cells.reserve(SIZE_BUFFER_THREAD);
+
+		bool finished = false;
+
+		while (!finished)
 		{
-			for (typename std::vector<CELL>::const_iterator it = m_cells.begin(); it != m_cells.end(); ++it)
-				m_lambda(*it, m_id);
-			m_cells.clear();
-			m_sync1.wait(); // wait every body has finished
-			m_sync2.wait(); // wait vectors has been refilled
+			// get data
+			m_mutex_map.lock();
+			Cell<ORBIT> c_end = m_trav.end();
+			while ((m_current_cell.dart != c_end.dart) && (m_cells.size() <SIZE_BUFFER_THREAD) )
+			{
+				m_cells.push_back(m_current_cell);
+				m_current_cell = m_trav.next();
+			}
+			m_mutex_map.unlock();
+
+			// and traverse
+			if (m_cells.empty())
+				finished = true;
+			else
+			{
+				for (typename std::vector<CELL>::const_iterator it = m_cells.begin(); it != m_cells.end(); ++it)
+					m_lambda(*it, m_id);
+				m_cells.clear();
+			}
 		}
 	}
 };
 
-
 template <TraversalOptim OPT, unsigned int ORBIT, typename MAP, typename FUNC>
 void foreach_cell_tmpl(MAP& map, FUNC func, unsigned int nbth)
 {
-	// buffer for cell traversing
-	std::vector< Cell<ORBIT> >* vd = new std::vector< Cell<ORBIT> >[nbth];
-	for (unsigned int i = 0; i < nbth; ++i)
-		vd[i].reserve(SIZE_BUFFER_THREAD);
 
-	unsigned int nb = 0;
 	TraversorCell<MAP, ORBIT, OPT> trav(map);
 	Cell<ORBIT> cell = trav.begin();
-	Cell<ORBIT> c_end = trav.end();
-	while ((cell.dart != c_end.dart) && (nb < nbth*SIZE_BUFFER_THREAD) )
-	{
-		vd[nb%nbth].push_back(cell);
-		nb++;
-		cell = trav.next();
-	}
-	Utils::Barrier sync1(nbth+1);
-	Utils::Barrier sync2(nbth+1);
-	bool finished=false;
+
+	std::mutex mutex_map;
 
 	// launch threads
 	std::thread** threads = new std::thread*[nbth];
-	ThreadFunction<ORBIT,FUNC>** tfs = new ThreadFunction<ORBIT,FUNC>*[nbth];
-
-	// add place for nbth new threads in the table of threadId in genericmap
-//	unsigned int firstThread = map.addEmptyThreadIds(nbth);
+	ThreadFunction<OPT,ORBIT,MAP,FUNC>** tfs = new ThreadFunction<OPT,ORBIT,MAP,FUNC>*[nbth];
 
 	for (unsigned int i = 0; i < nbth; ++i)
 	{
 		std::thread::id& threadId = map.addEmptyThreadId();
-		tfs[i] = new ThreadFunction<ORBIT,FUNC>(func, vd[i], sync1, sync2, finished, 1+i, threadId);
+		tfs[i] = new ThreadFunction<OPT,ORBIT,MAP,FUNC>(func, 1+i,threadId,mutex_map,trav,cell);
 		threads[i] = new std::thread( std::ref( *(tfs[i]) ) );
 	}
 
-	// and continue to traverse the map
-	std::vector< Cell<ORBIT> >* tempo = new std::vector< Cell<ORBIT> >[nbth];
-	for (unsigned int i = 0; i < nbth; ++i)
-		tempo[i].reserve(SIZE_BUFFER_THREAD);
-
-	while (cell.dart != c_end.dart)
-	{
-		for (unsigned int i = 0; i < nbth; ++i)
-			tempo[i].clear();
-		unsigned int nb = 0;
-
-		while ((cell.dart != c_end.dart) && (nb < nbth*SIZE_BUFFER_THREAD) )
-		{
-			tempo[nb%nbth].push_back(cell);
-			nb++;
-			cell = trav.next();
-		}
-		sync1.wait();// wait for all thread to finish its vector
-		for (unsigned int i = 0; i < nbth; ++i)
-			vd[i].swap(tempo[i]);
-		sync2.wait();// everybody refilled then go
-	}
-
-	sync1.wait(); // wait for all thread to finish its vector
-	finished = true; // say finsih to everyone
-	sync2.wait(); // just wait for last barrier wait !
-
 	// wait for all theads to be finished
 	for (unsigned int i = 0; i < nbth; ++i)
 	{
@@ -764,10 +865,9 @@ void foreach_cell_tmpl(MAP& map, FUNC func, unsigned int nbth)
 
 	delete[] tfs;
 	delete[] threads;
-	delete[] vd;
-	delete[] tempo;
 }
 
+
 template <unsigned int ORBIT, typename MAP, typename FUNC>
 void foreach_cell(MAP& map, FUNC func, TraversalOptim opt, unsigned int nbth)
 {

CGoGN/include/Utils/vbo.hpp

@@ -28,23 +28,42 @@ namespace CGoGN
 namespace Utils
 {
 
-template <typename T>
+template <unsigned int VEC_DIM, typename T>
 void VBO::updateData(std::vector<T>& data)
 {
 	if (m_lock)
 	{
-		CGoGNerr << "Error locked VBO" << CGoGNendl;
+		CGoGNerr << "VBO::updateData : Error locked VBO" << CGoGNendl;
 		return;
 	}
 
 	if (data.empty())
 		return;
 
-	m_data_size = sizeof(T) / sizeof(float);
+	m_data_size = VEC_DIM;
 	m_nbElts = uint32(data.size());
-
 	glBindBuffer(GL_ARRAY_BUFFER, *m_id);
-	glBufferData(GL_ARRAY_BUFFER, m_nbElts * sizeof(T), &(data[0]), GL_STREAM_DRAW);
+
+	if (sizeof(T) / sizeof(double) == VEC_DIM)
+	{
+		unsigned int nbf = m_nbElts * m_data_size;
+		float* buffer = new float[nbf];
+		float* ptr_out = buffer;
+		double* ptr_in = reinterpret_cast<double*>(&(data[0]));
+		for (unsigned int i=0; i<nbf; ++i)
+			*ptr_out++ = float(*ptr_in++);
+		glBufferData(GL_ARRAY_BUFFER, nbf * sizeof(float), buffer, GL_STREAM_DRAW);
+		delete[] buffer;
+		return;
+	}
+	if (sizeof(T) / sizeof(float) == VEC_DIM)
+	{
+		glBufferData(GL_ARRAY_BUFFER, m_nbElts * VEC_DIM * sizeof(float), &(data[0]), GL_STREAM_DRAW);
+		return;
+	}
+
+	// we should normally never reach this code
+	CGoGNerr << "VBO::updateData : Error only float, double, VecXf, VecXd" << CGoGNendl;
 }
 
 } // namespace Utils

CGoGN/include/Utils/vbo_base.h

@@ -142,8 +142,10 @@ public:
 	/**
 	 * update data from given data vector
 	 * @warning use only with include vbo.h (not vbo_base.h)
+	 * @tparam VEC_DIM dim of vec (1,2,3 or 4)
+	 * @param data a vector of float/VecXf or double/VecXd
 	 */
-	template <typename T>
+	template <unsigned int VEC_DIM, typename T>
 	void updateData(std::vector<T>& data);
 
 	void* lockPtr();

CGoGN/src/Utils/GLSLShader.cpp

@@ -39,43 +39,7 @@ namespace CGoGN
 namespace Utils
 {
 
-//#ifdef CGOGN_USE_OGL_CORE_PROFILE
-//unsigned int GLSLShader::CURRENT_OGL_VERSION = 3;
-//unsigned int GLSLShader::MAJOR_OGL_CORE = 3;
-//unsigned int GLSLShader::MINOR_OGL_CORE = 3;
-//#else
-//unsigned int GLSLShader::CURRENT_OGL_VERSION = 2;
-//unsigned int GLSLShader::MAJOR_OGL_CORE = 2;
-//unsigned int GLSLShader::MINOR_OGL_CORE = 1;
-//#endif
-
-
-
-//std::string GLSLShader::DEFINES_GL2=\
-//"#version 110\n"
-//"#define PRECISION float pipo_PRECISION\n"
-//"#define ATTRIBUTE attribute\n"
-//"#define VARYING_VERT varying\n"
-//"#define VARYING_FRAG varying\n"
-//"#define FRAG_OUT_DEF float pipo_FRAGDEF\n"
-//"#define FRAG_OUT gl_FragColor\n"
-//"#define INVARIANT_POS float pipo_INVARIANT\n"
-//"#define TEXTURE2D texture2D\n";
-
-
-//std::string GLSLShader::DEFINES_GL3=\
-//"#version 150\n"
-//"#define PRECISION precision highp float\n"
-//"#define ATTRIBUTE in\n"
-//"#define VARYING_VERT out\n"
-//"#define VARYING_FRAG in\n"
-//"#define FRAG_OUT_DEF out vec4 outFragColor\n"
-//"#define FRAG_OUT outFragColor\n"
-//"#define INVARIANT_POS invariant gl_Position\n"
-//"#define TEXTURE2D texture\n";
-
-
-//std::string* GLSLShader::DEFINES_GL = NULL;
+
 
 std::vector<std::string> GLSLShader::m_pathes;
 

CGoGN/src/Utils/drawer.cpp

@@ -190,6 +190,9 @@ void Drawer::newList(GLenum comp)
 	m_dataPos.clear();
 	m_dataCol.clear();
 	m_begins.clear();
+	m_begins_point.clear();
+	m_begins_line.clear();
+	m_begins_face.clear();
 }
 
 void Drawer::endList()

README.md

@@ -78,10 +78,7 @@ Dependencies
 ------------
 * install (or compile) Qt (choose 32/64 bits)
 * install python 2.7 (choose 32/64 bits) (Needed for SCHNApps)
-* Other Windows dependencies are furnished at:
-  * http://cgogn.unistra.fr/Dependencies/dependencies.txt
-  * http://cgogn.unistra.fr/Dependencies/windows_dependencies32.zip
-  * http://cgogn.unistra.fr/Dependencies/windows_dependencies64.zip
+* Other Windows dependencies are furnished at: http://cgogn.unistra.fr/download
 
 **Supported compilers: Visual C++ 2013 (12.0) or greater**
 

SCHNApps/Plugins/CMakeLists.txt

@@ -24,14 +24,15 @@ ADD_SUBDIRECTORY(surface_subdivision)
 ADD_SUBDIRECTORY(surface_selection)
 ADD_SUBDIRECTORY(surface_deformation)
 ADD_SUBDIRECTORY(surface_modelisation)
-#ADD_SUBDIRECTORY(surface_tilings)
-ADD_SUBDIRECTORY(surface_distance)
 ADD_SUBDIRECTORY(surface_radiance)
+ADD_SUBDIRECTORY(surface_distance)
 
+ADD_SUBDIRECTORY(volume_import)
+
+#ADD_SUBDIRECTORY(surface_tilings)
 #ADD_SUBDIRECTORY(cage2D_deformation)
 #ADD_SUBDIRECTORY(cage3D_deformation)
 
-ADD_SUBDIRECTORY(volume_import)
 #ADD_SUBDIRECTORY(volume_render)
 
 #ADD_SUBDIRECTORY(volumetric)

SCHNApps/Plugins/surface_selection/src/surface_selection.cpp

@@ -40,7 +40,7 @@ bool Surface_Selection_Plugin::enable()
 
 	m_selectedEdgesDrawer = new Utils::Drawer(1);
 	m_selectedFacesDrawer = new Utils::Drawer();
-	m_selectedFacesDrawer->setFaceShading(true);
+	m_selectedFacesDrawer->setFaceShading(false);
 
 	m_selectingCellDrawer = new Utils::Drawer(1);
 
@@ -110,7 +110,7 @@ void Surface_Selection_Plugin::drawMap(View* view, MapHandlerGen* map)
 			CellSelectorGen* selector = m_schnapps->getSelectedSelector(orbit);
 			if(selector)
 			{
-				unsigned int nbCells = map->getGenericMap()->getNbCells(orbit);
+//				unsigned int nbCells = map->getGenericMap()->getNbCells(orbit);
 				switch(orbit)
 				{
 					case VERTEX : {
@@ -132,7 +132,7 @@ void Surface_Selection_Plugin::drawMap(View* view, MapHandlerGen* map)
 						{
 							std::vector<PFP2::VEC3> selectionPoint;
 							selectionPoint.push_back(p.positionAttribute[m_selectingVertex]);
-							m_selectionSphereVBO->updateData(selectionPoint);
+							m_selectionSphereVBO->updateData<3>(selectionPoint);
 							m_pointSprite->setAttributePosition(m_selectionSphereVBO);
 							m_pointSprite->setColor(CGoGN::Geom::Vec4f(0.0f, 0.0f, 1.0f, 0.5f));
 							m_pointSprite->setLightPosition(CGoGN::Geom::Vec3f(0.0f, 0.0f, 1.0f));
@@ -184,7 +184,7 @@ void Surface_Selection_Plugin::drawMap(View* view, MapHandlerGen* map)
 //									PFP2::MAP* m = static_cast<MapHandler<PFP2>*>(map)->getMap();
 									std::vector<PFP2::VEC3> selectionPoint;
 									selectionPoint.push_back(p.positionAttribute[m_selectingEdge.dart]);
-									m_selectionSphereVBO->updateData(selectionPoint);
+									m_selectionSphereVBO->updateData<3>(selectionPoint);
 
 									m_pointSprite->setAttributePosition(m_selectionSphereVBO);
 									m_pointSprite->setColor(CGoGN::Geom::Vec4f(0.0f, 0.0f, 1.0f, 0.5f));
@@ -237,7 +237,7 @@ void Surface_Selection_Plugin::drawMap(View* view, MapHandlerGen* map)
 
 									std::vector<PFP2::VEC3> selectionPoint;
 									selectionPoint.push_back(p.positionAttribute[m_selectingFace.dart]);
-									m_selectionSphereVBO->updateData(selectionPoint);
+									m_selectionSphereVBO->updateData<3>(selectionPoint);
 
 									m_pointSprite->setAttributePosition(m_selectionSphereVBO);
 									m_pointSprite->setColor(CGoGN::Geom::Vec4f(0.0f, 0.0f, 1.0f, 0.5f));
@@ -561,7 +561,7 @@ void Surface_Selection_Plugin::updateSelectedCellsRendering()
 					std::vector<PFP2::VEC3> selectedPoints;
 					for(std::vector<Vertex>::const_iterator v = selectedCells.begin(); v != selectedCells.end(); ++v)
 						selectedPoints.push_back(p.positionAttribute[*v]);
-					m_selectedVerticesVBO->updateData(selectedPoints);
+					m_selectedVerticesVBO->updateData<3>(selectedPoints);
 					m_selectedVertices_dirty = false;
 					break;
 				}
@@ -609,7 +609,6 @@ void Surface_Selection_Plugin::updateSelectedCellsRendering()
 					}
 					m_selectedFacesDrawer->end();
 					m_selectedFacesDrawer->endList();
-					m_selectedFacesDrawer->setFaceShading(true);
 					m_selectedFaces_dirty = false;
 					break;
 				}

SCHNApps/Plugins/surface_selection/src/surface_selection_dockTab.cpp

@@ -178,11 +178,11 @@ void Surface_Selection_DockTab::clearPressed()
 	{
 		MapHandlerGen* map = m_schnapps->getSelectedMap();
 		unsigned int orbit = m_schnapps->getCurrentOrbit();
-
-		if (map)
+		CellSelectorGen* sel = m_schnapps->getSelectedSelector(orbit);
+		if (map && sel)
 		{
-			m_plugin->clearSelection(map->getName(), orbit, m_schnapps->getSelectedSelector(orbit)->getName());
-			m_plugin->pythonRecording("clearSelection", "", map->getName(), orbit, m_schnapps->getSelectedSelector(orbit)->getName());
+			m_plugin->clearSelection(map->getName(), orbit, sel->getName());
+			m_plugin->pythonRecording("clearSelection", "", map->getName(), orbit, sel->getName());
 		}
 	}
 }

SCHNApps/src/view.cpp

@@ -329,7 +329,7 @@ void View::init()
 
 	std::cout << "using " << glGetString(GL_VERSION) << std::endl;
 
-	qglviewer::Camera* c = this->camera();
+//	qglviewer::Camera* c = this->camera();
 	this->setCamera(m_currentCamera);
 //	delete c;