changing import functions + adding import volume plugin

Apps/Examples/volumeExplorer.cpp

@@ -144,52 +144,28 @@ void MyQT::cb_Open()
 	size_t pos = filename.rfind(".");    // position of "." in filename
 	std::string extension = filename.substr(pos);
 
-	if(extension == std::string(".tet"))
-	{
-		if(!Algo::Volume::Import::importTet<PFP>(myMap,filename,attrNames))
-		{
-			CGoGNerr << "could not import " << filename << CGoGNendl ;
-			return;
-		}
-		else
-			position = myMap.getAttribute<PFP::VEC3, VERTEX>(attrNames[0]) ;
-	}
-
-	if(extension == std::string(".node"))
+	if(extension == std::string(".off"))
 	{
-		if(!Algo::Volume::Import::importMeshV<PFP>(myMap, filename, attrNames, Algo::Volume::Import::NODE))
+		if(!Algo::Volume::Import::importMeshToExtrude<PFP>(myMap, filename, attrNames))
 		{
 			std::cerr << "could not import " << filename << std::endl ;
 			return ;
 		}
 		else
-			position = myMap.getAttribute<PFP::VEC3,VERTEX>(attrNames[0]) ;
-	}
-
-	if(extension == std::string(".ts"))
-	{
-		if(!Algo::Volume::Import::importMeshV<PFP>(myMap, filename, attrNames, Algo::Volume::Import::TS))
 		{
-			std::cerr << "could not import " << filename << std::endl ;
-			return ;
+			position = myMap.getAttribute<PFP::VEC3, VERTEX>(attrNames[0]) ;
+			myMap.closeMap();
 		}
-		else
-			position = myMap.getAttribute<PFP::VEC3,VERTEX>(attrNames[0]) ;
 	}
-
-
-	if(extension == std::string(".off"))
+	else
 	{
-		if(!Algo::Volume::Import::importMeshToExtrude<PFP>(myMap, filename, attrNames))
+		if(!Algo::Volume::Import::importMesh<PFP>(myMap, filename, attrNames))
 		{
 			std::cerr << "could not import " << filename << std::endl ;
 			return ;
 		}
 		else
-		{
-			position = myMap.getAttribute<PFP::VEC3, VERTEX>(attrNames[0]) ;
-			myMap.closeMap();
-		}
+			position = myMap.getAttribute<PFP::VEC3,VERTEX>(attrNames[0]) ;
 	}
 
 	color = myMap.addAttribute<PFP::VEC3, VOLUME>("color");
@@ -397,31 +373,22 @@ int main(int argc, char **argv)
 		size_t pos = filename.rfind(".");    // position of "." in filename
 		std::string extension = filename.substr(pos);
 
-		if(extension == std::string(".tet"))
+		if(extension == std::string(".off"))
 		{
-			if(!Algo::Volume::Import::importTet<PFP>(myMap,argv[1],attrNames))
+			if(!Algo::Volume::Import::importMeshToExtrude<PFP>(myMap, filename, attrNames))
 			{
-				CGoGNerr << "could not import " << argv[1] << CGoGNendl ;
+				std::cerr << "could not import " << filename << std::endl ;
 				return 1;
 			}
 			else
-				position = myMap.getAttribute<PFP::VEC3, VERTEX>(attrNames[0]) ;
-		}
-
-		if(extension == std::string(".node"))
-		{
-			if(!Algo::Volume::Import::importMeshV<PFP>(myMap, argv[1], attrNames, Algo::Volume::Import::NODE))
 			{
-				std::cerr << "could not import " << argv[1] << std::endl ;
-				return 1;
+				position = myMap.getAttribute<PFP::VEC3, VERTEX>(attrNames[0]) ;
+				myMap.closeMap();
 			}
-			else
-				position = myMap.getAttribute<PFP::VEC3,VERTEX>(attrNames[0]) ;
 		}
-
-		if(extension == std::string(".ts"))
+		else
 		{
-			if(!Algo::Volume::Import::importMeshV<PFP>(myMap, filename, attrNames, Algo::Volume::Import::TS))
+			if(!Algo::Volume::Import::importMesh<PFP>(myMap, filename, attrNames))
 			{
 				std::cerr << "could not import " << filename << std::endl ;
 				return 1;
@@ -430,20 +397,6 @@ int main(int argc, char **argv)
 				position = myMap.getAttribute<PFP::VEC3,VERTEX>(attrNames[0]) ;
 		}
 
-		if(extension == std::string(".off"))
-		{
-			if(!Algo::Volume::Import::importMeshToExtrude<PFP>(myMap, argv[1], attrNames))
-			{
-				std::cerr << "could not import "  << std::endl ;
-				return 1;
-			}
-			else
-			{
-				position = myMap.getAttribute<PFP::VEC3, VERTEX>(attrNames[0]) ;
-				myMap.closeMap();
-			}
-		}
-
 		color = myMap.addAttribute<PFP::VEC3, VOLUME>("color");
 
 		TraversorCell<PFP::MAP, VOLUME> tra(myMap);

Apps/Tuto/tuto_dual3.cpp

@@ -61,7 +61,7 @@ int main(int argc, char **argv)
 	PFP::MAP myMap;
 
 	std::vector<std::string> attrNames ;
-	Algo::Volume::Import::importMeshV<PFP>(myMap, argv[1], attrNames, Algo::Volume::Import::NODE);
+	Algo::Volume::Import::importMesh<PFP>(myMap, argv[1], attrNames);
 
 	// get a handler to the 3D vector attribute created by the import
 	VertexAttribute<PFP::VEC3> position = myMap.getAttribute<PFP::VEC3, VERTEX>(attrNames[0]);

Apps/Tuto/tuto_oper3.cpp

@@ -612,47 +612,20 @@ void MyQT::importMesh(std::string& filename)
 
 	size_t pos = filename.rfind(".");    // position of "." in filename
 	std::string extension = filename.substr(pos);
+	std::vector<std::string> attrNames ;
 
 	if (extension == std::string(".map"))
 	{
 		myMap.loadMapBin(filename);
 		position = myMap.getAttribute<VEC3, VERTEX>("position") ;
 	}
-	else if (extension == std::string(".node"))
-	{
-		std::vector<std::string> attrNames ;
-		if(!Algo::Volume::Import::importMeshV<PFP>(myMap, filename, attrNames, Algo::Volume::Import::NODE))
-		{
-			std::cerr << "could not import " << filename << std::endl ;
-			return ;
-		}
-		position = myMap.getAttribute<VEC3, VERTEX>(attrNames[0]) ;
-	}
-	else if(extension == std::string(".tet"))
-	{
-		std::vector<std::string> attrNames ;
-		if(!Algo::Volume::Import::importMeshV<PFP>(myMap, filename, attrNames, Algo::Volume::Import::TET))
-		{
-			std::cerr << "could not import " << filename << std::endl ;
-			return ;
-		}
-		position = myMap.getAttribute<VEC3, VERTEX>(attrNames[0]) ;
-	}
-	else if(extension == std::string(".off"))
-	{
-		std::vector<std::string> attrNames ;
-		if(!Algo::Volume::Import::importMeshV<PFP>(myMap, filename, attrNames, Algo::Volume::Import::OFF))
-		{
-			std::cerr << "could not import " << filename << std::endl ;
-			return ;
-		}
-		position = myMap.getAttribute<VEC3, VERTEX>(attrNames[0]) ;
-	}
-	else
+	else if(!Algo::Volume::Import::importMesh<PFP>(myMap, filename, attrNames))
 	{
 		std::cerr << "could not import " << filename << std::endl ;
 		return ;
 	}
+	else
+		position = myMap.getAttribute<PFP::VEC3,VERTEX>(attrNames[0]) ;
 
 	m_selected  = NIL;
 	m_selected2 = NIL;

SCHNApps/Plugins/CMakeLists.txt

 cmake_minimum_required(VERSION 2.8)
 
 ADD_SUBDIRECTORY(importSurface)
+ADD_SUBDIRECTORY(importVolume)
 ADD_SUBDIRECTORY(differentialProperties)
 ADD_SUBDIRECTORY(render)
 ADD_SUBDIRECTORY(renderVector)

SCHNApps/Plugins/importVolume/CMakeLists.txt

+cmake_minimum_required(VERSION 2.8)
+
+INCLUDE_DIRECTORIES(
+	${SCHNApps_ROOT_DIR}/include
+	${SCHNApps_ROOT_DIR}/Plugins/importVolume
+	${CMAKE_CURRENT_BINARY_DIR}
+)
+
+SET( PLUGIN_SRC
+    ${SCHNApps_ROOT_DIR}/Plugins/importVolume/importVolume.cpp
+)
+
+SET( PLUGIN_H
+    ${SCHNApps_ROOT_DIR}/Plugins/importVolume/importVolume.h
+)
+
+IF( ${CMAKE_BUILD_TYPE} STREQUAL Debug )
+
+	ADD_DEFINITIONS(-DDEBUG)
+
+	IF(WIN32)
+		link_directories( ${CGoGN_ROOT_DIR}/lib/Release )
+	ELSE (WIN32)
+		link_directories( ${CGoGN_ROOT_DIR}/lib/Debug ${CGoGN_ROOT_DIR}/lib/Release )
+	ENDIF (WIN32)
+
+#	QT4_WRAP_UI( PLUGIN_UI ${PLUGIN_FORM} )
+	QT4_WRAP_CPP( PLUGIN_MOC ${PLUGIN_H} )
+	
+	ADD_LIBRARY( ImportVolumePluginD SHARED
+		${PLUGIN_SRC}
+		${PLUGIN_UI}
+		${PLUGIN_MOC}
+	)
+
+	TARGET_LINK_LIBRARIES( ImportVolumePluginD
+		${CGoGN_LIBS_D}
+		${COMMON_LIBS}
+		${QGLVIEWER_LIBRARIES}
+	)
+
+	ADD_DEPENDENCIES( ImportVolumePluginD SCHNAppsD )
+
+	SET_TARGET_PROPERTIES( ImportVolumePluginD PROPERTIES COMPILE_DEFINITIONS "DEBUG" )
+		
+ELSE ( ${CMAKE_BUILD_TYPE} STREQUAL Debug )
+	
+	IF(WIN32)
+	link_directories( ${CGoGN_ROOT_DIR}/lib/Release )
+	ELSE (WIN32)
+		link_directories( ${CGoGN_ROOT_DIR}/lib/Release )
+	ENDIF (WIN32)
+
+#	QT4_WRAP_UI( PLUGIN_UI ${PLUGIN_FORM} )
+	QT4_WRAP_CPP( PLUGIN_MOC ${PLUGIN_H} )
+
+	ADD_LIBRARY( ImportVolumePlugin SHARED
+		${PLUGIN_SRC}
+		${PLUGIN_UI}
+		${PLUGIN_MOC}
+	)
+
+	TARGET_LINK_LIBRARIES( ImportVolumePlugin
+		${CGoGN_LIBS_R}
+		${COMMON_LIBS}
+		${QGLVIEWER_LIBRARIES}
+	)
+
+	ADD_DEPENDENCIES( ImportVolumePlugin SCHNApps )
+	
+ENDIF ( ${CMAKE_BUILD_TYPE} STREQUAL Debug )

SCHNApps/Plugins/importVolume/importVolume.cpp

+#include "importVolume.h"
+
+#include "mapHandler.h"
+
+#include "Algo/Import/import.h"
+
+#include <QFileDialog>
+#include <QFileInfo>
+
+bool ImportVolumePlugin::enable()
+{
+	importAction = new QAction("import", this);
+	addMenuAction("Volume;Import", importAction);
+	connect(importAction, SIGNAL(triggered()), this, SLOT(cb_import()));
+	return true;
+}
+
+void ImportVolumePlugin::cb_import()
+{
+	QString fileName = QFileDialog::getOpenFileName(m_window, "Import file", m_window->getAppPath(), "Mesh Files (*.node *.ts *.off *.tet)");
+	QFileInfo fi(fileName);
+
+	if(fi.exists())
+	{
+		GenericMap* m = m_window->createMap(3);
+		PFP3::MAP* map = static_cast<PFP3::MAP*>(m);
+		MapHandler<PFP3>* h = new MapHandler<PFP3>(fi.baseName(), m_window, map);
+
+		std::vector<std::string> attrNames ;
+		Algo::Volume::Import::importMesh<PFP3>(*map, fileName.toUtf8().constData(), attrNames);
+
+		// get vertex position attribute
+		VertexAttribute<PFP2::VEC3> position = map->getAttribute<PFP2::VEC3, CGoGN::VERTEX>(attrNames[0]);
+
+		// create VBO for vertex position attribute
+		h->createVBO(position);
+
+		// compute map bounding box
+		h->updateBB(position);
+
+		// compute primitive connectivity VBOs
+		h->updatePrimitives(Algo::Render::GL2::POINTS);
+		h->updatePrimitives(Algo::Render::GL2::LINES);
+		h->updatePrimitives(Algo::Render::GL2::TRIANGLES);
+
+		m_window->addMap(h);
+	}
+}
+
+#ifndef DEBUG
+Q_EXPORT_PLUGIN2(ImportVolumePlugin, ImportVolumePlugin)
+#else
+Q_EXPORT_PLUGIN2(ImportVolumePluginD, ImportVolumePlugin)
+#endif

SCHNApps/Plugins/importVolume/importVolume.h

+#ifndef _IMPORTSURFACE_PLUGIN_H_
+#define _IMPORTSURFACE_PLUGIN_H_
+
+#include "plugin.h"
+
+
+using namespace CGoGN;
+using namespace SCHNApps;
+
+
+class ImportVolumePlugin : public Plugin
+{
+	Q_OBJECT
+	Q_INTERFACES(CGoGN::SCHNApps::Plugin)
+
+public:
+	ImportVolumePlugin()
+	{
+		setProvidesRendering(false);
+	}
+
+	~ImportVolumePlugin()
+	{}
+
+	virtual bool enable();
+	virtual void disable() {}
+
+	virtual void redraw(View *view) {}
+
+	virtual void keyPress(View* view, int key) {}
+	virtual void keyRelease(View* view, int key) {}
+	virtual void mousePress(View* view, int button, int x, int y) {}
+	virtual void mouseRelease(View* view, int button, int x, int y) {}
+	virtual void mouseMove(View* view, int buttons, int x, int y) {}
+	virtual void wheelEvent(View* view, int delta, int x, int y) {}
+
+	virtual void viewLinked(View* view) {}
+	virtual void viewUnlinked(View* view) {}
+	virtual void currentViewChanged(View* view) {}
+
+	virtual void mapLinked(View* view, MapHandlerGen* m) {}
+	virtual void mapUnlinked(View* view, MapHandlerGen* m) {}
+
+public slots:
+	void cb_import();
+
+private:
+	QAction* importAction;
+};
+
+#endif

include/Algo/Import/import.h

@@ -84,7 +84,7 @@ namespace Import
  * @return a boolean indicating if import was successful
  */
 template <typename PFP>
-bool importMeshV(typename PFP::MAP& map, const std::string& filename, std::vector<std::string>& attrNames, bool mergeCloseVertices = false);
+bool importMesh(typename PFP::MAP& map, const std::string& filename, std::vector<std::string>& attrNames, bool mergeCloseVertices = false);
 
 /**
  * import a mesh and extrude it

include/Algo/Import/importMesh.hpp

@@ -507,7 +507,7 @@ bool importMesh(typename PFP::MAP& map, MeshTablesVolume<PFP>& mtv)
 
 
 template <typename PFP>
-bool importMeshV(typename PFP::MAP& map, const std::string& filename, std::vector<std::string>& attrNames, bool mergeCloseVertices)
+bool importMesh(typename PFP::MAP& map, const std::string& filename, std::vector<std::string>& attrNames, bool mergeCloseVertices)
 {
 	ImportType kind = Volume::Import::UNKNOWNVOLUME;