diff --git a/wrap/io_trimesh/import_dae.h b/wrap/io_trimesh/import_dae.h
index fe092a0f..3f815174 100644
--- a/wrap/io_trimesh/import_dae.h
+++ b/wrap/io_trimesh/import_dae.h
@@ -691,6 +691,8 @@ static Matrix44f getTransfMatrixFromNode(const QDomElement parentNode)
 		
         static int Open(OpenMeshType& m,const char* filename, InfoDAE& info, CallBackPos *cb=0)
 		{
+			(void)cb;
+
 			QDEBUG("----- Starting the processing of %s ------",filename);
             //AdditionalInfoDAE& inf = new AdditionalInfoDAE();
             //info = new InfoDAE();
diff --git a/wrap/io_trimesh/import_obj.h b/wrap/io_trimesh/import_obj.h
index b5020732..b97a0ff5 100644
--- a/wrap/io_trimesh/import_obj.h
+++ b/wrap/io_trimesh/import_obj.h
@@ -22,7 +22,7 @@
 ****************************************************************************/
 
 /****************************************************************************
-  History
+History
 
 $Log: not supported by cvs2svn $
 Revision 1.19  2008/01/17 18:02:02  cignoni
@@ -101,7 +101,7 @@ Initial Working version coded by Buzzelli.
 
 namespace vcg {
 namespace tri {
-namespace io {
+namespace io  {
 
 /** 
 This class encapsulate a filter for importing obj (Alias Wavefront) meshes.
@@ -112,796 +112,796 @@ class ImporterOBJ
 {
 public:
 
-typedef typename OpenMeshType::VertexPointer VertexPointer;
-typedef typename OpenMeshType::ScalarType ScalarType;
-typedef typename OpenMeshType::VertexType VertexType;
-typedef typename OpenMeshType::FaceType FaceType;
-typedef typename OpenMeshType::VertexIterator VertexIterator;
-typedef typename OpenMeshType::FaceIterator FaceIterator;
-typedef typename OpenMeshType::CoordType CoordType;
+	typedef typename OpenMeshType::VertexPointer VertexPointer;
+	typedef typename OpenMeshType::ScalarType ScalarType;
+	typedef typename OpenMeshType::VertexType VertexType;
+	typedef typename OpenMeshType::FaceType FaceType;
+	typedef typename OpenMeshType::VertexIterator VertexIterator;
+	typedef typename OpenMeshType::FaceIterator FaceIterator;
+	typedef typename OpenMeshType::CoordType CoordType;
 
-class Info
-{
-public:
+	class Info
+	{
+	public:
 
-  Info()
-  {
-    mask	= 0;
-    cb		= 0;
-    numTexCoords=0;
-  }
+		Info()
+		{
+			mask	= 0;
+			cb		= 0;
+			numTexCoords=0;
+		}
 
-	/// It returns a bit mask describing the field preesnt in the ply file
-  int mask;  
+		/// It returns a bit mask describing the field preesnt in the ply file
+		int mask;  
 
-  /// a Simple callback that can be used for long obj parsing. 
-  // it returns the current position, and formats a string with a description of what th efunction is doing (loading vertexes, faces...)
-  CallBackPos *cb;
+		/// a Simple callback that can be used for long obj parsing. 
+		// it returns the current position, and formats a string with a description of what th efunction is doing (loading vertexes, faces...)
+		CallBackPos *cb;
 
-  /// number of vertices
-  int numVertices;
- 	/// number of faces (the number of triangles could be 
-  /// larger in presence of polygonal faces
-	int numFaces;
- 	/// number of texture coords indexes
-	int numTexCoords;
+		/// number of vertices
+		int numVertices;
+		/// number of faces (the number of triangles could be 
+		/// larger in presence of polygonal faces
+		int numFaces;
+		/// number of texture coords indexes
+		int numTexCoords;
 
-}; // end class
+	}; // end class
 
 
-//struct OBJFacet
-//{
-//  CoordType n;
-//	CoordType t;
-//  CoordType v[3];
-//
-//	short attr;  // material index
-//};
-struct ObjIndexedFace
-{ 
-	void set(const int & num){v.resize(num);n.resize(num); t.resize(num);}
-	std::vector<int> v;
-	std::vector<int> n;
-	std::vector<int> t;
-	int tInd;
-	bool  edge[3];// useless if the face is a polygon, no need to have variable length array
-	Color4b c;
-};
-
-struct ObjTexCoord
-{
-	float u;
-	float v;
-};
-
-enum OBJError {
-		// Successfull opening
-	E_NOERROR													= 0x000,	//	0  (position of correspondig string in the array)
-	
-	// Non Critical Errors (only odd numbers)
-	E_NON_CRITICAL_ERROR							= 0x001,
-	E_MATERIAL_FILE_NOT_FOUND					= 0x003,	//  1
-	E_MATERIAL_NOT_FOUND							= 0x005,	//  2
-	E_TEXTURE_NOT_FOUND								= 0x007,	//  3
-	E_VERTICES_WITH_SAME_IDX_IN_FACE	= 0x009,  //	4
-
-	// Critical Opening Errors (only even numbers)
-	E_CANTOPEN										=	0x00A,	//  5
-	E_UNESPECTEDEOF								= 0x00C,	//  6
-	E_ABORTED											= 0x00E,	//  7
-	E_NO_VERTEX										= 0x010,	//  8
-	E_NO_FACE											= 0x012,	//  9
-	E_BAD_VERTEX_STATEMENT				= 0x014,	// 10
-	E_BAD_VERT_TEX_STATEMENT			= 0x016,	// 11
-	E_BAD_VERT_NORMAL_STATEMENT	  = 0x018,	// 12
-	E_LESS_THAN_3VERTINFACE				= 0x01A,	// 13
-	E_BAD_VERT_INDEX							= 0x01C,	// 14
-	E_BAD_VERT_TEX_INDEX 					= 0x01E,	// 15
-	E_BAD_VERT_NORMAL_INDEX 			= 0x020		// 16
-};
-
-// to check if a given error is critical or not.
-static bool ErrorCritical(int err)
-{ 
-  if(err<0x00A && err>=0) return false;
-  return true;
-}
-
-static const char* ErrorMsg(int error)
-{
-  static const char* obj_error_msg[] =
-  {
-		"No errors",																									//  0
-
-		"Material library file wrong or not found, a default white material is used",						//  1
-		"Some materials definitions were not found, a default white material is used where no material was available",  // 2
-		"Texture file not found",																			//  3
-		"Identical index vertices found in the same face",						//	4
-
-		"Can't open file",																						//  5
-		"Premature End of file",																			//  6
-		"File opening aborted",																				//  7
-		"No vertex field found",																			//  8
-		"No face field found",																				//  9
-		"Vertex statement with less than 3 coords",										// 10
-		"Texture coords statement with less than 2 coords",						// 11
-		"Vertex normal statement with less than 3 coords",						// 12  
-		"Face with less than 3 vertices",															// 13
-		"Bad vertex index in face",																		// 14
-		"Bad texture coords index in face",														// 15
-		"Bad vertex normal index in face"															// 16
+	//struct OBJFacet
+	//{
+	//  CoordType n;
+	//	CoordType t;
+	//  CoordType v[3];
+	//
+	//	short attr;  // material index
+	//};
+	struct ObjIndexedFace
+	{ 
+		void set(const int & num){v.resize(num);n.resize(num); t.resize(num);}
+		std::vector<int> v;
+		std::vector<int> n;
+		std::vector<int> t;
+		int tInd;
+		bool  edge[3];// useless if the face is a polygon, no need to have variable length array
+		Color4b c;
 	};
 
-	// due to approximation, following line works well for either even (critical err codes)
-	// or odd (non critical ones) numbers
-	error = (int) error/2;
-
-  if(error>15 || error<0) return "Unknown error";
-  else return obj_error_msg[error];
-};
-
-// Helper functions that checks the range of indexes 
-// putting them in the correct range if less than zero (as in the obj style)
-
-static bool GoodObjIndex(int &index, const int maxVal)
-{
-  if (index > maxVal)	return false;
-  if (index < 0)
+	struct ObjTexCoord
 	{
-		index += maxVal+1;
-		if (index<0 || index > maxVal)	return false;
+		float u;
+		float v;
+	};
+
+	enum OBJError {
+		// Successfull opening
+		E_NOERROR													= 0x000,	//	0  (position of correspondig string in the array)
+
+		// Non Critical Errors (only odd numbers)
+		E_NON_CRITICAL_ERROR							= 0x001,
+		E_MATERIAL_FILE_NOT_FOUND					= 0x003,	//  1
+		E_MATERIAL_NOT_FOUND							= 0x005,	//  2
+		E_TEXTURE_NOT_FOUND								= 0x007,	//  3
+		E_VERTICES_WITH_SAME_IDX_IN_FACE	= 0x009,  //	4
+
+		// Critical Opening Errors (only even numbers)
+		E_CANTOPEN										=	0x00A,	//  5
+		E_UNESPECTEDEOF								= 0x00C,	//  6
+		E_ABORTED											= 0x00E,	//  7
+		E_NO_VERTEX										= 0x010,	//  8
+		E_NO_FACE											= 0x012,	//  9
+		E_BAD_VERTEX_STATEMENT				= 0x014,	// 10
+		E_BAD_VERT_TEX_STATEMENT			= 0x016,	// 11
+		E_BAD_VERT_NORMAL_STATEMENT	  = 0x018,	// 12
+		E_LESS_THAN_3VERTINFACE				= 0x01A,	// 13
+		E_BAD_VERT_INDEX							= 0x01C,	// 14
+		E_BAD_VERT_TEX_INDEX 					= 0x01E,	// 15
+		E_BAD_VERT_NORMAL_INDEX 			= 0x020		// 16
+	};
+
+	// to check if a given error is critical or not.
+	static bool ErrorCritical(int err)
+	{ 
+		if(err<0x00A && err>=0) return false;
+		return true;
 	}
-  return true;
-}
 
-static int Open(OpenMeshType &mesh, const char *filename, int &loadmask, CallBackPos *cb=0)
-{
-  Info oi;
-  oi.mask=-1;
-  oi.cb=cb;
-  int ret=Open(mesh,filename,oi);
-  loadmask=oi.mask;
-  return ret;
-}
-
-/*!
-* Opens an object file (in ascii format) and populates the mesh passed as first
-* accordingly to read data
-* \param m The mesh model to be populated with data stored into the file
-* \param filename The name of the file to be opened
-* \param oi A structure containing infos about the object to be opened
-*/
-static int Open( OpenMeshType &m, const char * filename, Info &oi)
-{
-	int result = E_NOERROR;
-
-	m.Clear();
-	CallBackPos *cb = oi.cb;
-
-	// if LoadMask has not been called yet, we call it here
-	if (oi.mask == -1)
-		LoadMask(filename, oi);
-
-	const int inputMask = oi.mask;
-	Mask::ClampMask<OpenMeshType>(m,oi.mask);
-
-	if (oi.numVertices == 0)
-		return E_NO_VERTEX;
-
-	// Commented out this test. You should be allowed to load point clouds.
-	//if (oi.numFaces == 0)
-	//	return E_NO_FACE;
-
-	std::ifstream stream(filename);
-	if (stream.fail())
-		return E_CANTOPEN;
-
-	std::vector<Material>	materials;  // materials vector
-	std::vector<ObjTexCoord>	texCoords;  // texture coordinates
-	std::vector<CoordType>  normals;		// vertex normals
-	std::vector<ObjIndexedFace> indexedFaces;
-	std::vector< std::string > tokens;
-	std::string	header;
-
-	short currentMaterialIdx = 0;			// index of current material into materials vector
-	Color4b currentColor=Color4b::LightGray;	// we declare this outside code block since other 
-	// triangles of this face will share the same color
-
-	Material defaultMaterial;					// default material: white
-	materials.push_back(defaultMaterial);
-
-	int numVertices  = 0;  // stores the number of vertices been read till now
-	int numTriangles = 0;  // stores the number of faces been read till now
-	int numTexCoords = 0;  // stores the number of texture coordinates been read till now
-	int numVNormals	 = 0;  // stores the number of vertex normals been read till now
-
-	int numVerticesPlusFaces = oi.numVertices + oi.numFaces;
-	int extraTriangles=0;
-	// vertices and faces allocatetion
-	VertexIterator vi = Allocator<OpenMeshType>::AddVertices(m,oi.numVertices);
-	//FaceIterator   fi = Allocator<OpenMeshType>::AddFaces(m,oi.numFaces);
-
-	ObjIndexedFace	ff; 
-
-	while (!stream.eof())
+	static const char* ErrorMsg(int error)
 	{
-		tokens.clear();
-		TokenizeNextLine(stream, tokens);
-
-		unsigned int numTokens = static_cast<unsigned int>(tokens.size());
-		if (numTokens > 0)
+		static const char* obj_error_msg[] =
 		{
-			header.clear();
-			header = tokens[0];
+			"No errors",																									//  0
 
-			if (header.compare("v")==0)	// vertex
+			"Material library file wrong or not found, a default white material is used",						//  1
+			"Some materials definitions were not found, a default white material is used where no material was available",  // 2
+			"Texture file not found",																			//  3
+			"Identical index vertices found in the same face",						//	4
+
+			"Can't open file",																						//  5
+			"Premature End of file",																			//  6
+			"File opening aborted",																				//  7
+			"No vertex field found",																			//  8
+			"No face field found",																				//  9
+			"Vertex statement with less than 3 coords",										// 10
+			"Texture coords statement with less than 2 coords",						// 11
+			"Vertex normal statement with less than 3 coords",						// 12  
+			"Face with less than 3 vertices",															// 13
+			"Bad vertex index in face",																		// 14
+			"Bad texture coords index in face",														// 15
+			"Bad vertex normal index in face"															// 16
+		};
+
+		// due to approximation, following line works well for either even (critical err codes)
+		// or odd (non critical ones) numbers
+		error = (int) error/2;
+
+		if(error>15 || error<0) return "Unknown error";
+		else return obj_error_msg[error];
+	};
+
+	// Helper functions that checks the range of indexes 
+	// putting them in the correct range if less than zero (as in the obj style)
+
+	static bool GoodObjIndex(int &index, const int maxVal)
+	{
+		if (index > maxVal)	return false;
+		if (index < 0)
+		{
+			index += maxVal+1;
+			if (index<0 || index > maxVal)	return false;
+		}
+		return true;
+	}
+
+	static int Open(OpenMeshType &mesh, const char *filename, int &loadmask, CallBackPos *cb=0)
+	{
+		Info oi;
+		oi.mask=-1;
+		oi.cb=cb;
+		int ret=Open(mesh,filename,oi);
+		loadmask=oi.mask;
+		return ret;
+	}
+
+	/*!
+	* Opens an object file (in ascii format) and populates the mesh passed as first
+	* accordingly to read data
+	* \param m The mesh model to be populated with data stored into the file
+	* \param filename The name of the file to be opened
+	* \param oi A structure containing infos about the object to be opened
+	*/
+	static int Open( OpenMeshType &m, const char * filename, Info &oi)
+	{
+		int result = E_NOERROR;
+
+		m.Clear();
+		CallBackPos *cb = oi.cb;
+
+		// if LoadMask has not been called yet, we call it here
+		if (oi.mask == -1)
+			LoadMask(filename, oi);
+
+		const int inputMask = oi.mask;
+		Mask::ClampMask<OpenMeshType>(m,oi.mask);
+
+		if (oi.numVertices == 0)
+			return E_NO_VERTEX;
+
+		// Commented out this test. You should be allowed to load point clouds.
+		//if (oi.numFaces == 0)
+		//	return E_NO_FACE;
+
+		std::ifstream stream(filename);
+		if (stream.fail())
+			return E_CANTOPEN;
+
+		std::vector<Material>	materials;  // materials vector
+		std::vector<ObjTexCoord>	texCoords;  // texture coordinates
+		std::vector<CoordType>  normals;		// vertex normals
+		std::vector<ObjIndexedFace> indexedFaces;
+		std::vector< std::string > tokens;
+		std::string	header;
+
+		short currentMaterialIdx = 0;			// index of current material into materials vector
+		Color4b currentColor=Color4b::LightGray;	// we declare this outside code block since other 
+		// triangles of this face will share the same color
+
+		Material defaultMaterial;					// default material: white
+		materials.push_back(defaultMaterial);
+
+		int numVertices  = 0;  // stores the number of vertices been read till now
+		int numTriangles = 0;  // stores the number of faces been read till now
+		int numTexCoords = 0;  // stores the number of texture coordinates been read till now
+		int numVNormals	 = 0;  // stores the number of vertex normals been read till now
+
+		int numVerticesPlusFaces = oi.numVertices + oi.numFaces;
+		int extraTriangles=0;
+		// vertices and faces allocatetion
+		VertexIterator vi = Allocator<OpenMeshType>::AddVertices(m,oi.numVertices);
+		//FaceIterator   fi = Allocator<OpenMeshType>::AddFaces(m,oi.numFaces);
+
+		ObjIndexedFace	ff; 
+
+		while (!stream.eof())
+		{
+			tokens.clear();
+			TokenizeNextLine(stream, tokens);
+
+			unsigned int numTokens = static_cast<unsigned int>(tokens.size());
+			if (numTokens > 0)
 			{
-				if (numTokens < 4) return E_BAD_VERTEX_STATEMENT;
+				header.clear();
+				header = tokens[0];
 
-				(*vi).P()[0] = (ScalarType) atof(tokens[1].c_str());
-				(*vi).P()[1] = (ScalarType) atof(tokens[2].c_str());
-				(*vi).P()[2] = (ScalarType) atof(tokens[3].c_str());
-				++numVertices;
-
-				// assigning vertex color
-				// ----------------------
-				if (((oi.mask & vcg::tri::io::Mask::IOM_VERTCOLOR) != 0) && (m.HasPerVertexColor()))
+				if (header.compare("v")==0)	// vertex
 				{
-					(*vi).C() = currentColor;
-				}
+					if (numTokens < 4) return E_BAD_VERTEX_STATEMENT;
 
-				++vi;  // move to next vertex iterator
+					(*vi).P()[0] = (ScalarType) atof(tokens[1].c_str());
+					(*vi).P()[1] = (ScalarType) atof(tokens[2].c_str());
+					(*vi).P()[2] = (ScalarType) atof(tokens[3].c_str());
+					++numVertices;
 
-				// callback invocation, abort loading process if the call returns false
-				if ((cb !=NULL) && (((numTriangles + numVertices)%100)==0) && !(*cb)((100*(numTriangles + numVertices))/numVerticesPlusFaces, "Vertex Loading"))
-					return E_ABORTED;
-			}
-			else if (header.compare("vt")==0)	// vertex texture coords
-			{
-				if (numTokens < 3) return E_BAD_VERT_TEX_STATEMENT;
-
-				ObjTexCoord t;
-				t.u = static_cast<float>(atof(tokens[1].c_str()));
-				t.v = static_cast<float>(atof(tokens[2].c_str()));
-				texCoords.push_back(t);
-
-				numTexCoords++;
-			}
-			else if (header.compare("vn")==0)  // vertex normal
-			{
-				if (numTokens != 4) return E_BAD_VERT_NORMAL_STATEMENT;
-
-				CoordType n;
-				n[0] = (ScalarType) atof(tokens[1].c_str());
-				n[1] = (ScalarType) atof(tokens[2].c_str());
-				n[2] = (ScalarType) atof(tokens[3].c_str());	
-				normals.push_back(n);
-
-				numVNormals++;
-			}
-			else if( (header.compare("f")==0) || (header.compare("q")==0) )  // face
-			{
-				bool QuadFlag = false; // QOBJ format by Silva et al for simply storing quadrangular meshes.				
-				if(header.compare("q")==0) { QuadFlag=true; assert(numTokens == 5); }
-
-				if (numTokens < 4) return E_LESS_THAN_3VERTINFACE;
-				int vertexesPerFace = static_cast<int>(tokens.size()-1);
-
-				if( (vertexesPerFace>3) && OpenMeshType::FaceType::HasPolyInfo() ){
-					//_BEGIN___ if  you are loading a GENERIC POLYGON mesh 
-
-					ff.set(vertexesPerFace);
-
-					std::string vertex;
-					std::string texcoord;
-					std::string normal;
-					for(int i=0;i<vertexesPerFace;++i) // remember index starts from 1 instead of 0
-						SplitToken(tokens[i+1], ff.v[i], ff.n[i], ff.t[i], inputMask);
-
-					if ( oi.mask & vcg::tri::io::Mask::IOM_WEDGTEXCOORD )
+					// assigning vertex color
+					// ----------------------
+					if (((oi.mask & vcg::tri::io::Mask::IOM_VERTCOLOR) != 0) && (m.HasPerVertexColor()))
 					{
-						// verifying validity of texture coords indices
-						for(int i=0;i<vertexesPerFace;i++)
-							if(!GoodObjIndex(ff.t[i],oi.numTexCoords)) 
-								return E_BAD_VERT_TEX_INDEX;
-
-						ff.tInd=materials[currentMaterialIdx].index;
+						(*vi).C() = currentColor;
 					}
 
-					// verifying validity of vertex indices
-					std::vector<int> tmp = ff.v;
-					std::sort(tmp.begin(),tmp.end());
-					std::unique(tmp.begin(),tmp.end());
-					if(tmp.size() != ff.v.size())
-						result = E_VERTICES_WITH_SAME_IDX_IN_FACE;
-
-					for(int i=0;i<vertexesPerFace;i++)
-						if(!GoodObjIndex(ff.v[i],numVertices))
-							return E_BAD_VERT_INDEX;
-
-					// assigning face normal
-					// ---------------------
-					if ( oi.mask & vcg::tri::io::Mask::IOM_WEDGNORMAL )
-					{
-						// verifying validity of vertex normal indices
-						// -------------------------------------------
-						for(int i=0;i<vertexesPerFace;i++)
-							if(!GoodObjIndex(ff.n[i],numVNormals)) return E_BAD_VERT_NORMAL_INDEX;
-					}
-
-					// assigning face color
-					// --------------------
-					if( oi.mask & vcg::tri::io::Mask::IOM_FACECOLOR)		
-						ff.c = currentColor;
-
-					++numTriangles;
-					indexedFaces.push_back(ff);
-
+					++vi;  // move to next vertex iterator
 
 					// callback invocation, abort loading process if the call returns false
-					if ((cb !=NULL)&& (((numTriangles + numVertices)%100)==0) )
-					{
-						if (!(*cb)( (100*(numTriangles +numVertices))/ numVerticesPlusFaces, "Face Loading"))
-							return E_ABORTED;
-					}
-					//_END  ___ if  you are loading a GENERIC POLYGON mesh 
-				}else
+					if ((cb !=NULL) && (((numTriangles + numVertices)%100)==0) && !(*cb)((100*(numTriangles + numVertices))/numVerticesPlusFaces, "Vertex Loading"))
+						return E_ABORTED;
+				}
+				else if (header.compare("vt")==0)	// vertex texture coords
 				{
-					//_BEGIN___ if  you are loading a  TRIMESH mesh 
-					ff.set(3);	
-					std::string vertex;
-					std::string texcoord;
-					std::string normal;
-					for(int i=0;i<3;++i)
-					{		// remember index starts from 1 instead of 0
-						SplitToken(tokens[i+1], ff.v[i], ff.n[i], ff.t[i], inputMask);
-						if(QuadFlag) { ff.v[i]+=1; }
-					}
-					if ( oi.mask & vcg::tri::io::Mask::IOM_WEDGTEXCOORD )
-					{
-						// verifying validity of texture coords indices
-						for(int i=0;i<3;i++)
-							if(!GoodObjIndex(ff.t[i],oi.numTexCoords)) 
-								return E_BAD_VERT_TEX_INDEX;
+					if (numTokens < 3) return E_BAD_VERT_TEX_STATEMENT;
 
-						ff.tInd=materials[currentMaterialIdx].index;
-					}
+					ObjTexCoord t;
+					t.u = static_cast<float>(atof(tokens[1].c_str()));
+					t.v = static_cast<float>(atof(tokens[2].c_str()));
+					texCoords.push_back(t);
 
-					// verifying validity of vertex indices
-					if ((ff.v[0] == ff.v[1]) || (ff.v[0] == ff.v[2]) || (ff.v[1] == ff.v[2]))
-						result = E_VERTICES_WITH_SAME_IDX_IN_FACE;
+					numTexCoords++;
+				}
+				else if (header.compare("vn")==0)  // vertex normal
+				{
+					if (numTokens != 4) return E_BAD_VERT_NORMAL_STATEMENT;
 
-					for(int i=0;i<3;i++)
-						if(!GoodObjIndex(ff.v[i],numVertices))
-							return E_BAD_VERT_INDEX;
+					CoordType n;
+					n[0] = (ScalarType) atof(tokens[1].c_str());
+					n[1] = (ScalarType) atof(tokens[2].c_str());
+					n[2] = (ScalarType) atof(tokens[3].c_str());	
+					normals.push_back(n);
 
-					// assigning face normal
-					// ---------------------
-					if ( oi.mask & vcg::tri::io::Mask::IOM_WEDGNORMAL )
-					{
-						// verifying validity of vertex normal indices
-						// -------------------------------------------
-						for(int i=0;i<3;i++)
-							if(!GoodObjIndex(ff.n[i],numVNormals))
-								return E_BAD_VERT_NORMAL_INDEX;
-					}
+					numVNormals++;
+				}
+				else if( (header.compare("f")==0) || (header.compare("q")==0) )  // face
+				{
+					bool QuadFlag = false; // QOBJ format by Silva et al for simply storing quadrangular meshes.				
+					if(header.compare("q")==0) { QuadFlag=true; assert(numTokens == 5); }
 
-					// assigning face color
-					// --------------------
-					if( oi.mask & vcg::tri::io::Mask::IOM_FACECOLOR)		
-						ff.c = currentColor;
+					if (numTokens < 4) return E_LESS_THAN_3VERTINFACE;
+					int vertexesPerFace = static_cast<int>(tokens.size()-1);
 
-					// by default there are no internal edge
-					ff.edge[0]=ff.edge[1]=ff.edge[2]=false;
-					if(vertexesPerFace>3) ff.edge[2]=true;
-					++numTriangles;
-					indexedFaces.push_back(ff);
-					/*
-					// A face polygon composed of more than three vertices is triangulated
-					// according to the following schema:
-					//                     v5
-					//                    /  \   
-					//                   /    \    
-					//                  /      \   
-					//                 v1------v4 
-					//                 |\      /
-					//                 | \    /
-					//                 |  \  /
-					//                v2---v3
-					//
-					// As shown above, the 5 vertices polygon (v1,v2,v3,v4,v5)
-					// has been split into the triangles (v1,v2,v3), (v1,v3,v4) e (v1,v4,v5).
-					// This way vertex v1 becomes the common vertex of all newly generated
-					// triangles, and this may lead to the creation of very thin triangles.
-					*/
+					if( (vertexesPerFace>3) && OpenMeshType::FaceType::HasPolyInfo() ){
+						//_BEGIN___ if  you are loading a GENERIC POLYGON mesh 
 
-					int iVertex = 3;
-					while (iVertex < vertexesPerFace)  // add other triangles
-					{
-						oi.mask |= Mask::IOM_BITPOLYGONAL;
-						ObjIndexedFace ffNew=ff;
-						int v4_index;
-						int vt4_index;
-						int vn4_index;
+						ff.set(vertexesPerFace);
 
-						SplitToken(tokens[++iVertex], v4_index, vn4_index, vt4_index, inputMask);
-						if(QuadFlag) { v4_index+=1; }
-						if(!GoodObjIndex(v4_index, numVertices))
-							return E_BAD_VERT_INDEX;
+						std::string vertex;
+						std::string texcoord;
+						std::string normal;
+						for(int i=0;i<vertexesPerFace;++i) // remember index starts from 1 instead of 0
+							SplitToken(tokens[i+1], ff.v[i], ff.n[i], ff.t[i], inputMask);
 
-						// assigning wedge texture coordinates
-						// -----------------------------------
-						if( oi.mask & vcg::tri::io::Mask::IOM_WEDGTEXCOORD )
+						if ( oi.mask & vcg::tri::io::Mask::IOM_WEDGTEXCOORD )
 						{
-							// verifying validity of texture coords index
-							// ------------------------------------------
-							if(!GoodObjIndex(vt4_index,oi.numTexCoords))
-								return E_BAD_VERT_TEX_INDEX;
+							// verifying validity of texture coords indices
+							for(int i=0;i<vertexesPerFace;i++)
+								if(!GoodObjIndex(ff.t[i],oi.numTexCoords)) 
+									return E_BAD_VERT_TEX_INDEX;
 
-							if ( oi.mask & vcg::tri::io::Mask::IOM_WEDGNORMAL )
-								if(!GoodObjIndex(vn4_index,numVNormals))
-									return E_BAD_VERT_NORMAL_INDEX;
-
-							ffNew.t[1]=ff.t[2];
-							ffNew.t[2]=vt4_index;            
+							ff.tInd=materials[currentMaterialIdx].index;
 						}
 
-						if ((ff.v[0] == v4_index) || (ff.v[2] == v4_index)) result = E_VERTICES_WITH_SAME_IDX_IN_FACE;
-						ffNew.v[1]=ff.v[2];
-						ffNew.v[2]=v4_index;            
+						// verifying validity of vertex indices
+						std::vector<int> tmp = ff.v;
+						std::sort(tmp.begin(),tmp.end());
+						std::unique(tmp.begin(),tmp.end());
+						if(tmp.size() != ff.v.size())
+							result = E_VERTICES_WITH_SAME_IDX_IN_FACE;
+
+						for(int i=0;i<vertexesPerFace;i++)
+							if(!GoodObjIndex(ff.v[i],numVertices))
+								return E_BAD_VERT_INDEX;
 
 						// assigning face normal
 						// ---------------------
 						if ( oi.mask & vcg::tri::io::Mask::IOM_WEDGNORMAL )
-						{									  
-							ffNew.n[1]=ff.n[2];
-							ffNew.n[2]=vn4_index;            
+						{
+							// verifying validity of vertex normal indices
+							// -------------------------------------------
+							for(int i=0;i<vertexesPerFace;i++)
+								if(!GoodObjIndex(ff.n[i],numVNormals)) return E_BAD_VERT_NORMAL_INDEX;
 						}
-						// Setting internal edges: edge 1 (the opposite to vertex 0) is always an external edge. 
-						ffNew.edge[0]=true;
-						ffNew.edge[1]=false;
-						if(iVertex < vertexesPerFace) ffNew.edge[2]=true;
-						else	ffNew.edge[2]=false;
+
+						// assigning face color
+						// --------------------
+						if( oi.mask & vcg::tri::io::Mask::IOM_FACECOLOR)		
+							ff.c = currentColor;
+
 						++numTriangles;
-						++extraTriangles;
-						indexedFaces.push_back(ffNew);
-						ff.v[2] = v4_index;
-					}
+						indexedFaces.push_back(ff);
 
-					// callback invocation, abort loading process if the call returns false
-					if ((cb !=NULL)&& (((numTriangles + numVertices)%100)==0) )
+
+						// callback invocation, abort loading process if the call returns false
+						if ((cb !=NULL)&& (((numTriangles + numVertices)%100)==0) )
+						{
+							if (!(*cb)( (100*(numTriangles +numVertices))/ numVerticesPlusFaces, "Face Loading"))
+								return E_ABORTED;
+						}
+						//_END  ___ if  you are loading a GENERIC POLYGON mesh 
+					}else
 					{
-						if (!(*cb)( (100*(numTriangles +numVertices))/ numVerticesPlusFaces, "Face Loading"))
-							return E_ABORTED;
-					}
-					//_END___ if  you are loading a  TRIMESH mesh 
+						//_BEGIN___ if  you are loading a  TRIMESH mesh 
+						ff.set(3);	
+						std::string vertex;
+						std::string texcoord;
+						std::string normal;
+						for(int i=0;i<3;++i)
+						{		// remember index starts from 1 instead of 0
+							SplitToken(tokens[i+1], ff.v[i], ff.n[i], ff.t[i], inputMask);
+							if(QuadFlag) { ff.v[i]+=1; }
+						}
+						if ( oi.mask & vcg::tri::io::Mask::IOM_WEDGTEXCOORD )
+						{
+							// verifying validity of texture coords indices
+							for(int i=0;i<3;i++)
+								if(!GoodObjIndex(ff.t[i],oi.numTexCoords)) 
+									return E_BAD_VERT_TEX_INDEX;
 
+							ff.tInd=materials[currentMaterialIdx].index;
+						}
+
+						// verifying validity of vertex indices
+						if ((ff.v[0] == ff.v[1]) || (ff.v[0] == ff.v[2]) || (ff.v[1] == ff.v[2]))
+							result = E_VERTICES_WITH_SAME_IDX_IN_FACE;
+
+						for(int i=0;i<3;i++)
+							if(!GoodObjIndex(ff.v[i],numVertices))
+								return E_BAD_VERT_INDEX;
+
+						// assigning face normal
+						// ---------------------
+						if ( oi.mask & vcg::tri::io::Mask::IOM_WEDGNORMAL )
+						{
+							// verifying validity of vertex normal indices
+							// -------------------------------------------
+							for(int i=0;i<3;i++)
+								if(!GoodObjIndex(ff.n[i],numVNormals))
+									return E_BAD_VERT_NORMAL_INDEX;
+						}
+
+						// assigning face color
+						// --------------------
+						if( oi.mask & vcg::tri::io::Mask::IOM_FACECOLOR)		
+							ff.c = currentColor;
+
+						// by default there are no internal edge
+						ff.edge[0]=ff.edge[1]=ff.edge[2]=false;
+						if(vertexesPerFace>3) ff.edge[2]=true;
+						++numTriangles;
+						indexedFaces.push_back(ff);
+						/*
+						// A face polygon composed of more than three vertices is triangulated
+						// according to the following schema:
+						//                     v5
+						//                    /  \   
+						//                   /    \    
+						//                  /      \   
+						//                 v1------v4 
+						//                 |\      /
+						//                 | \    /
+						//                 |  \  /
+						//                v2---v3
+						//
+						// As shown above, the 5 vertices polygon (v1,v2,v3,v4,v5)
+						// has been split into the triangles (v1,v2,v3), (v1,v3,v4) e (v1,v4,v5).
+						// This way vertex v1 becomes the common vertex of all newly generated
+						// triangles, and this may lead to the creation of very thin triangles.
+						*/
+
+						int iVertex = 3;
+						while (iVertex < vertexesPerFace)  // add other triangles
+						{
+							oi.mask |= Mask::IOM_BITPOLYGONAL;
+							ObjIndexedFace ffNew=ff;
+							int v4_index;
+							int vt4_index;
+							int vn4_index;
+
+							SplitToken(tokens[++iVertex], v4_index, vn4_index, vt4_index, inputMask);
+							if(QuadFlag) { v4_index+=1; }
+							if(!GoodObjIndex(v4_index, numVertices))
+								return E_BAD_VERT_INDEX;
+
+							// assigning wedge texture coordinates
+							// -----------------------------------
+							if( oi.mask & vcg::tri::io::Mask::IOM_WEDGTEXCOORD )
+							{
+								// verifying validity of texture coords index
+								// ------------------------------------------
+								if(!GoodObjIndex(vt4_index,oi.numTexCoords))
+									return E_BAD_VERT_TEX_INDEX;
+
+								if ( oi.mask & vcg::tri::io::Mask::IOM_WEDGNORMAL )
+									if(!GoodObjIndex(vn4_index,numVNormals))
+										return E_BAD_VERT_NORMAL_INDEX;
+
+								ffNew.t[1]=ff.t[2];
+								ffNew.t[2]=vt4_index;            
+							}
+
+							if ((ff.v[0] == v4_index) || (ff.v[2] == v4_index)) result = E_VERTICES_WITH_SAME_IDX_IN_FACE;
+							ffNew.v[1]=ff.v[2];
+							ffNew.v[2]=v4_index;            
+
+							// assigning face normal
+							// ---------------------
+							if ( oi.mask & vcg::tri::io::Mask::IOM_WEDGNORMAL )
+							{									  
+								ffNew.n[1]=ff.n[2];
+								ffNew.n[2]=vn4_index;            
+							}
+							// Setting internal edges: edge 1 (the opposite to vertex 0) is always an external edge. 
+							ffNew.edge[0]=true;
+							ffNew.edge[1]=false;
+							if(iVertex < vertexesPerFace) ffNew.edge[2]=true;
+							else	ffNew.edge[2]=false;
+							++numTriangles;
+							++extraTriangles;
+							indexedFaces.push_back(ffNew);
+							ff.v[2] = v4_index;
+						}
+
+						// callback invocation, abort loading process if the call returns false
+						if ((cb !=NULL)&& (((numTriangles + numVertices)%100)==0) )
+						{
+							if (!(*cb)( (100*(numTriangles +numVertices))/ numVerticesPlusFaces, "Face Loading"))
+								return E_ABORTED;
+						}
+						//_END___ if  you are loading a  TRIMESH mesh 
+
+					}
 				}
-			}
-			else if (header.compare("mtllib")==0)	// material library
-			{
-				// obtain the name of the file containing materials library
-				std::string materialFileName = tokens[1];
-				if (!LoadMaterials( materialFileName.c_str(), materials, m.textures))
-					result = E_MATERIAL_FILE_NOT_FOUND;
-			}
-			else if (header.compare("usemtl")==0)	// material usage
-			{
-				std::string materialName = tokens[1];
-				bool found = false;
-				unsigned i = 0;
-				while (!found && (i < materials.size()))
+				else if (header.compare("mtllib")==0)	// material library
 				{
-					std::string currentMaterialName = materials[i].materialName;
-					if (currentMaterialName == materialName)
+					// obtain the name of the file containing materials library
+					std::string materialFileName = tokens[1];
+					if (!LoadMaterials( materialFileName.c_str(), materials, m.textures))
+						result = E_MATERIAL_FILE_NOT_FOUND;
+				}
+				else if (header.compare("usemtl")==0)	// material usage
+				{
+					std::string materialName = tokens[1];
+					bool found = false;
+					unsigned i = 0;
+					while (!found && (i < materials.size()))
 					{
-						currentMaterialIdx = i;
-						Material &material = materials[currentMaterialIdx];
-						Point3f diffuseColor = material.Kd;
-						unsigned char r			= (unsigned char) (diffuseColor[0] * 255.0);
-						unsigned char g			= (unsigned char) (diffuseColor[1] * 255.0);
-						unsigned char b			= (unsigned char) (diffuseColor[2] * 255.0);
-						unsigned char alpha = (unsigned char) (material.Tr  * 255.0);
-						currentColor= Color4b(r, g, b, alpha);
-						found = true;
+						std::string currentMaterialName = materials[i].materialName;
+						if (currentMaterialName == materialName)
+						{
+							currentMaterialIdx = i;
+							Material &material = materials[currentMaterialIdx];
+							Point3f diffuseColor = material.Kd;
+							unsigned char r			= (unsigned char) (diffuseColor[0] * 255.0);
+							unsigned char g			= (unsigned char) (diffuseColor[1] * 255.0);
+							unsigned char b			= (unsigned char) (diffuseColor[2] * 255.0);
+							unsigned char alpha = (unsigned char) (material.Tr  * 255.0);
+							currentColor= Color4b(r, g, b, alpha);
+							found = true;
+						}
+						++i;
+					}
+
+					if (!found)
+					{
+						currentMaterialIdx = 0;
+						result = E_MATERIAL_NOT_FOUND;
 					}
-					++i;
 				}
+				// we simply ignore other situations
+			} // end for each line...
+		} // end while stream not eof
+		assert((numTriangles +numVertices) == numVerticesPlusFaces+extraTriangles);
 
-				if (!found)
-				{
-					currentMaterialIdx = 0;
-					result = E_MATERIAL_NOT_FOUND;
-				}
-			}
-			// we simply ignore other situations
-		} // end for each line...
-	} // end while stream not eof
-	assert((numTriangles +numVertices) == numVerticesPlusFaces+extraTriangles);
+		FaceIterator   fi = Allocator<OpenMeshType>::AddFaces(m,numTriangles);
+		//-------------------------------------------------------------------------------
 
-	FaceIterator   fi = Allocator<OpenMeshType>::AddFaces(m,numTriangles);
-	//-------------------------------------------------------------------------------
-
-	// Now the final pass to convert indexes into pointers for face to vert/norm/tex references
-	for(int i=0; i<numTriangles; ++i)
-	{
-		assert(m.face.size() == size_t(m.fn));
-		m.face[i].Alloc(indexedFaces[i].v.size()); // it does not do anything if it is a trimesh
-
-		for(unsigned int j=0;j<indexedFaces[i].v.size();++j)
+		// Now the final pass to convert indexes into pointers for face to vert/norm/tex references
+		for(int i=0; i<numTriangles; ++i)
 		{
-			m.face[i].V(j) = &(m.vert[indexedFaces[i].v[j]]);
+			assert(m.face.size() == size_t(m.fn));
+			m.face[i].Alloc(indexedFaces[i].v.size()); // it does not do anything if it is a trimesh
 
-			if (((oi.mask & vcg::tri::io::Mask::IOM_WEDGTEXCOORD) != 0) && (m.HasPerWedgeTexCoord()))
+			for(unsigned int j=0;j<indexedFaces[i].v.size();++j)
 			{
-				ObjTexCoord t = texCoords[indexedFaces[i].t[j]];
-				m.face[i].WT(j).u() = t.u;
-				m.face[i].WT(j).v() = t.v;
-				m.face[i].WT(j).n() = indexedFaces[i].tInd;
+				m.face[i].V(j) = &(m.vert[indexedFaces[i].v[j]]);
+
+				if (((oi.mask & vcg::tri::io::Mask::IOM_WEDGTEXCOORD) != 0) && (m.HasPerWedgeTexCoord()))
+				{
+					ObjTexCoord t = texCoords[indexedFaces[i].t[j]];
+					m.face[i].WT(j).u() = t.u;
+					m.face[i].WT(j).v() = t.v;
+					m.face[i].WT(j).n() = indexedFaces[i].tInd;
+				}
+
+				if (((oi.mask & vcg::tri::io::Mask::IOM_WEDGNORMAL) != 0) && (m.HasPerWedgeNormal()))
+				{
+					m.face[i].WN(j).Import(normals[indexedFaces[i].n[j]]);
+				}
+
+				// set faux edge flags according to internals faces
+				if (indexedFaces[i].edge[j])
+				{
+					m.face[i].SetF(j);
+				}
+				else
+				{
+					m.face[i].ClearF(j);
+				}
+			}
+
+			if (((oi.mask & vcg::tri::io::Mask::IOM_FACECOLOR) != 0) && (m.HasPerFaceColor()))
+			{
+				m.face[i].C() = indexedFaces[i].c;
 			}
 
 			if (((oi.mask & vcg::tri::io::Mask::IOM_WEDGNORMAL) != 0) && (m.HasPerWedgeNormal()))
 			{
-				m.face[i].WN(j).Import(normals[indexedFaces[i].n[j]]);
-			}
-
-			// set faux edge flags according to internals faces
-			if (indexedFaces[i].edge[j])
-			{
-				m.face[i].SetF(j);
+				// face normal is computed as an average of wedge normals
+				m.face[i].N().Import(m.face[i].WN(0)+m.face[i].WN(1)+m.face[i].WN(2));
 			}
 			else
 			{
-				m.face[i].ClearF(j);
+				// computing face normal from position of face vertices
+				if (m.HasPerFaceNormal())
+				{
+					face::ComputeNormalizedNormal(m.face[i]);
+				}
 			}
 		}
 
-		if (((oi.mask & vcg::tri::io::Mask::IOM_FACECOLOR) != 0) && (m.HasPerFaceColor()))
-		{
-			m.face[i].C() = indexedFaces[i].c;
-		}
+		return result;
+	} // end of Open
 
-		if (((oi.mask & vcg::tri::io::Mask::IOM_WEDGNORMAL) != 0) && (m.HasPerWedgeNormal()))
+
+	/*!
+	* Read the next valid line and parses it into "tokens", allowing
+	*	the tokens to be read one at a time.
+	* \param stream	The object providing the input stream
+	*	\param tokens	The "tokens" in the next line
+	*/
+	inline static const void TokenizeNextLine(std::ifstream &stream, std::vector< std::string > &tokens)
+	{
+		if(stream.eof()) return;
+		std::string line;
+		do
+		std::getline(stream, line);
+		while ((line[0] == '#' || line.length()==0) && !stream.eof());  // skip comments and empty lines
+
+		if ((line[0] == '#') || (line.length() == 0))  // can be true only on last line of file
+			return;
+
+		size_t from		= 0; 
+		size_t to			= 0;
+		size_t length = line.size();
+		tokens.clear();
+		do
 		{
-			// face normal is computed as an average of wedge normals
-			m.face[i].N().Import(m.face[i].WN(0)+m.face[i].WN(1)+m.face[i].WN(2));
-		}
-		else
-		{
-			// computing face normal from position of face vertices
-			if (m.HasPerFaceNormal())
+			while (from!=length && (line[from]==' ' || line[from]=='\t' || line[from]=='\r') )
+				from++;
+			if(from!=length)
 			{
-				face::ComputeNormalizedNormal(m.face[i]);
+				to = from+1;
+				while (to!=length && line[to]!=' ' && line[to] != '\t' && line[to]!='\r')
+					to++;
+				tokens.push_back(line.substr(from, to-from).c_str());
+				from = to;
 			}
 		}
+		while (from<length);
+	} // end TokenizeNextLine
+
+	inline static const void SplitToken(std::string token, int &vId, int &nId, int &tId, int mask)
+	{
+		std::string vertex;
+		std::string texcoord;
+		std::string normal;
+
+		if( ( mask & Mask::IOM_WEDGTEXCOORD ) && (mask & Mask::IOM_WEDGNORMAL) )   SplitVVTVNToken(token, vertex, texcoord, normal);
+		if(!( mask & Mask::IOM_WEDGTEXCOORD ) && (mask & Mask::IOM_WEDGNORMAL) )   SplitVVNToken(token, vertex, normal);
+		if( ( mask & Mask::IOM_WEDGTEXCOORD ) &&!(mask & Mask::IOM_WEDGNORMAL) )   SplitVVTToken(token, vertex, texcoord);
+		if(!( mask & Mask::IOM_WEDGTEXCOORD ) &&!(mask & Mask::IOM_WEDGNORMAL) )   SplitVToken(token, vertex);
+
+		vId = atoi(vertex.c_str()) - 1;
+		if(mask & Mask::IOM_WEDGTEXCOORD) tId = atoi(texcoord.c_str()) - 1;
+		if(mask & Mask::IOM_WEDGNORMAL)   nId = atoi(normal.c_str())   - 1;
 	}
 
-	return result;
-} // end of Open
-
-
-/*!
-* Read the next valid line and parses it into "tokens", allowing
-*	the tokens to be read one at a time.
-* \param stream	The object providing the input stream
-*	\param tokens	The "tokens" in the next line
-*/
-inline static const void TokenizeNextLine(std::ifstream &stream, std::vector< std::string > &tokens)
-{
-	if(stream.eof()) return;
-	std::string line;
-	do
-	std::getline(stream, line);
-	while ((line[0] == '#' || line.length()==0) && !stream.eof());  // skip comments and empty lines
-
-	if ((line[0] == '#') || (line.length() == 0))  // can be true only on last line of file
-		return;
-
-	size_t from		= 0; 
-	size_t to			= 0;
-	size_t length = line.size();
-	tokens.clear();
-	do
+	inline static const void SplitVToken(std::string token, std::string &vertex) 
 	{
-		while (from!=length && (line[from]==' ' || line[from]=='\t' || line[from]=='\r') )
-			from++;
+		vertex = token; 
+	}
+
+	inline static const void SplitVVTToken(std::string token, std::string &vertex, std::string &texcoord)
+	{
+		vertex.clear();
+		texcoord.clear();
+
+		size_t from   = 0; 
+		size_t to     = 0;
+		size_t length = token.size();
+
 		if(from!=length)
 		{
+			char c = token[from];
+			vertex.push_back(c);
+
 			to = from+1;
-			while (to!=length && line[to]!=' ' && line[to] != '\t' && line[to]!='\r')
-				to++;
-			tokens.push_back(line.substr(from, to-from).c_str());
-			from = to;
+			while (to!=length && ((c = token[to]) !='/'))
+			{
+				vertex.push_back(c);
+				++to;
+			}
+			++to;
+			while (to!=length && ((c = token[to]) !=' '))
+			{
+				texcoord.push_back(c);
+				++to;
+			}
 		}
-	}
-	while (from<length);
-} // end TokenizeNextLine
+	}	// end of SplitVVTToken
 
-inline static const void SplitToken(std::string token, int &vId, int &nId, int &tId, int mask)
-{
-	std::string vertex;
-	std::string texcoord;
-	std::string normal;
-
-	if( ( mask & Mask::IOM_WEDGTEXCOORD ) && (mask & Mask::IOM_WEDGNORMAL) )   SplitVVTVNToken(token, vertex, texcoord, normal);
-	if(!( mask & Mask::IOM_WEDGTEXCOORD ) && (mask & Mask::IOM_WEDGNORMAL) )   SplitVVNToken(token, vertex, normal);
-	if( ( mask & Mask::IOM_WEDGTEXCOORD ) &&!(mask & Mask::IOM_WEDGNORMAL) )   SplitVVTToken(token, vertex, texcoord);
-	if(!( mask & Mask::IOM_WEDGTEXCOORD ) &&!(mask & Mask::IOM_WEDGNORMAL) )   SplitVToken(token, vertex);
-
-	vId = atoi(vertex.c_str()) - 1;
-	if(mask & Mask::IOM_WEDGTEXCOORD) tId = atoi(texcoord.c_str()) - 1;
-	if(mask & Mask::IOM_WEDGNORMAL)   nId = atoi(normal.c_str())   - 1;
-}
-
-inline static const void SplitVToken(std::string token, std::string &vertex) 
-{
-	vertex = token; 
-}
-
-inline static const void SplitVVTToken(std::string token, std::string &vertex, std::string &texcoord)
-{
-	vertex.clear();
-	texcoord.clear();
-
-	size_t from   = 0; 
-	size_t to     = 0;
-	size_t length = token.size();
-
-	if(from!=length)
+	inline static const void SplitVVNToken(std::string token, std::string &vertex, std::string &normal)
 	{
-		char c = token[from];
-		vertex.push_back(c);
+		vertex.clear();
+		normal.clear();
 
-		to = from+1;
-		while (to!=length && ((c = token[to]) !='/'))
+		size_t from   = 0; 
+		size_t to     = 0;
+		size_t length = token.size();
+
+		if(from!=length)
 		{
+			char c = token[from];
 			vertex.push_back(c);
+
+			to = from+1;
+			while (to!=length && ((c = token[to]) !='/'))
+			{
+				vertex.push_back(c);
+				++to;
+			}
 			++to;
+			++to;  // should be the second '/'
+			while (to!=length && ((c = token[to]) !=' '))
+			{
+				normal.push_back(c);
+				++to;
+			}
 		}
-		++to;
-		while (to!=length && ((c = token[to]) !=' '))
-		{
-			texcoord.push_back(c);
-			++to;
-		}
-	}
-}	// end of SplitVVTToken
+	}	// end of SplitVVNToken
 
-inline static const void SplitVVNToken(std::string token, std::string &vertex, std::string &normal)
-{
-	vertex.clear();
-	normal.clear();
-
-	size_t from   = 0; 
-	size_t to     = 0;
-	size_t length = token.size();
-
-	if(from!=length)
+	inline static const void SplitVVTVNToken(std::string token, std::string &vertex, std::string &texcoord, std::string &normal)
 	{
-		char c = token[from];
-		vertex.push_back(c);
+		vertex.clear();
+		texcoord.clear();
+		normal.clear();
 
-		to = from+1;
-		while (to!=length && ((c = token[to]) !='/'))
+		size_t from   = 0; 
+		size_t to     = 0;
+		size_t length = token.size();
+
+		if(from!=length)
 		{
+			char c = token[from];
 			vertex.push_back(c);
-			++to;
-		}
-		++to;
-		++to;  // should be the second '/'
-		while (to!=length && ((c = token[to]) !=' '))
-		{
-			normal.push_back(c);
-			++to;
-		}
-	}
-}	// end of SplitVVNToken
 
-inline static const void SplitVVTVNToken(std::string token, std::string &vertex, std::string &texcoord, std::string &normal)
-{
-	vertex.clear();
-	texcoord.clear();
-	normal.clear();
-
-	size_t from   = 0; 
-	size_t to     = 0;
-	size_t length = token.size();
-
-	if(from!=length)
-	{
-		char c = token[from];
-		vertex.push_back(c);
-
-		to = from+1;
-		while (to!=length && ((c = token[to]) !='/'))
-		{
-			vertex.push_back(c);
+			to = from+1;
+			while (to!=length && ((c = token[to]) !='/'))
+			{
+				vertex.push_back(c);
+				++to;
+			}
 			++to;
-		}
-		++to;
-		while (to!=length && ((c = token[to]) !='/'))
-		{
-			texcoord.push_back(c);
+			while (to!=length && ((c = token[to]) !='/'))
+			{
+				texcoord.push_back(c);
+				++to;
+			}
 			++to;
+			while (to!=length && ((c = token[to]) !=' '))
+			{
+				normal.push_back(c);
+				++to;
+			}
 		}
-		++to;
-		while (to!=length && ((c = token[to]) !=' '))
-		{
-			normal.push_back(c);
-			++to;
-		}
-	}
-}	// end of SplitVVTVNToken
+	}	// end of SplitVVTVNToken
 
 	/*!
 	* Retrieves infos about kind of data stored into the file and fills a mask appropriately
 	* \param filename The name of the file to open
 	*	\param mask	A mask which will be filled according to type of data found in the object
 	* \param oi A structure which will be filled with infos about the object to be opened
-  	*/
+	*/
 
-static bool LoadMask(const char * filename, Info &oi)
-{
- 		std::ifstream stream(filename);
+	static bool LoadMask(const char * filename, Info &oi)
+	{
+		std::ifstream stream(filename);
 		if (stream.fail()) return false;
 
-		 // obtain length of file:
-    stream.seekg (0, std::ios::end);
+		// obtain length of file:
+		stream.seekg (0, std::ios::end);
 		int length = stream.tellg();
-    stream.seekg (0, std::ios::beg);
-    
-    if (length == 0) return false;
+		stream.seekg (0, std::ios::beg);
 
-    bool bHasPerFaceColor			= false;
-	bool bHasNormals = false;
+		if (length == 0) return false;
 
-    oi.numVertices=0;
-    oi.numFaces=0;
-    oi.numTexCoords=0;
+		bool bHasPerFaceColor			= false;
+		bool bHasNormals = false;
+
+		oi.numVertices=0;
+		oi.numFaces=0;
+		oi.numTexCoords=0;
 		int lineCount=0;
 		int totRead=0;
-    std::string line;
-	  while (!stream.eof())
-    {
-      lineCount++;
+		std::string line;
+		while (!stream.eof())
+		{
+			lineCount++;
 			std::getline(stream, line);
-      totRead+=line.size();
-      if(oi.cb && (lineCount%1000)==0) 
-					(*oi.cb)( (int)(100.0*(float(totRead))/float(length)), "Loading mask...");
+			totRead+=line.size();
+			if(oi.cb && (lineCount%1000)==0) 
+				(*oi.cb)( (int)(100.0*(float(totRead))/float(length)), "Loading mask...");
 			if(line.size()>2)
-      {
-        if(line[0]=='v')
-        {
-          if(line[1]==' ') oi.numVertices++;
-          if(line[1]=='t') oi.numTexCoords++;
-		  if(line[1]=='n') bHasNormals = true;
-        } 
-        else 
-         if((line[0]=='f') || (line[0]=='q')) oi.numFaces++;
-				 else 
-				 if(line[0]=='u' && line[1]=='s') bHasPerFaceColor = true; // there is a usematerial so add per face color
-      }
+			{
+				if(line[0]=='v')
+				{
+					if(line[1]==' ') oi.numVertices++;
+					if(line[1]=='t') oi.numTexCoords++;
+					if(line[1]=='n') bHasNormals = true;
+				} 
+				else 
+					if((line[0]=='f') || (line[0]=='q')) oi.numFaces++;
+					else 
+						if(line[0]=='u' && line[1]=='s') bHasPerFaceColor = true; // there is a usematerial so add per face color
+			}
 		}
 		oi.mask = 0;
 		if (oi.numTexCoords)	
-			{
-				oi.mask |= vcg::tri::io::Mask::IOM_WEDGTEXCOORD;
-				// Usually if you have tex coords you also have materials
-				oi.mask |= vcg::tri::io::Mask::IOM_FACECOLOR; 
-			}
-  if(bHasPerFaceColor) 				oi.mask |= vcg::tri::io::Mask::IOM_FACECOLOR; 
-	if (bHasNormals) oi.mask |= vcg::tri::io::Mask::IOM_WEDGNORMAL;
+		{
+			oi.mask |= vcg::tri::io::Mask::IOM_WEDGTEXCOORD;
+			// Usually if you have tex coords you also have materials
+			oi.mask |= vcg::tri::io::Mask::IOM_FACECOLOR; 
+		}
+		if(bHasPerFaceColor) 				oi.mask |= vcg::tri::io::Mask::IOM_FACECOLOR; 
+		if (bHasNormals) oi.mask |= vcg::tri::io::Mask::IOM_WEDGNORMAL;
 
-  return true;
-}
+		return true;
+	}
 
-static bool LoadMask(const char * filename, int &mask)
-{
-  Info oi;
-  bool ret=LoadMask(filename, oi);
-  mask= oi.mask;
-  return ret;
-}
+	static bool LoadMask(const char * filename, int &mask)
+	{
+		Info oi;
+		bool ret=LoadMask(filename, oi);
+		mask= oi.mask;
+		return ret;
+	}
 
 	static bool LoadMaterials(const char * filename, std::vector<Material> &materials, std::vector<std::string> &textures)
 	{
@@ -910,20 +910,20 @@ static bool LoadMask(const char * filename, int &mask)
 		std::ifstream stream(filename);
 		if (stream.fail())
 			return false;
-    
+
 		std::vector< std::string > tokens;
 		std::string	header;
-	
+
 		materials.clear();
 		Material currentMaterial;
-		currentMaterial.index = -1;
-		
+		currentMaterial.index = (unsigned int)(-1);
+
 		bool first = true;
 		while (!stream.eof())
 		{
 			tokens.clear();
 			TokenizeNextLine(stream, tokens);
-		
+
 			if (tokens.size() > 0)
 			{
 				header.clear();
@@ -935,12 +935,12 @@ static bool LoadMask(const char * filename, int &mask)
 					{
 						materials.push_back(currentMaterial);
 						currentMaterial = Material();
-						currentMaterial.index = -1;
+						currentMaterial.index = (unsigned int)(-1);
 					}
 					else
 						first = false;
 					//strcpy(currentMaterial.name, tokens[1].c_str());
-          if(tokens.size() < 2) 
+					if(tokens.size() < 2) 
 						return false; 
 					currentMaterial.materialName=tokens[1];
 				}
@@ -958,7 +958,7 @@ static bool LoadMask(const char * filename, int &mask)
 					float g = (float) atof(tokens[2].c_str());
 					float b = (float) atof(tokens[3].c_str());
 
-          currentMaterial.Kd = Point3f(r, g, b); 
+					currentMaterial.Kd = Point3f(r, g, b); 
 				}
 				else if (header.compare("Ks")==0)
 				{
@@ -966,12 +966,12 @@ static bool LoadMask(const char * filename, int &mask)
 					float g = (float) atof(tokens[2].c_str());
 					float b = (float) atof(tokens[3].c_str());
 
-          currentMaterial.Ks = Point3f(r, g, b); 
+					currentMaterial.Ks = Point3f(r, g, b); 
 				}
 				else if (	(header.compare("d")==0) ||
-									(header.compare("Tr")==0)	)	// alpha
+					(header.compare("Tr")==0)	)	// alpha
 				{
-          currentMaterial.Tr = (float) atof(tokens[1].c_str());
+					currentMaterial.Tr = (float) atof(tokens[1].c_str());
 				}
 				else if (header.compare("Ns")==0)  // shininess        
 				{
@@ -980,15 +980,15 @@ static bool LoadMask(const char * filename, int &mask)
 				else if (header.compare("illum")==0)	// specular illumination on/off
 				{
 					int illumination = atoi(tokens[1].c_str());
-          //currentMaterial.bSpecular = (illumination == 2);
-          currentMaterial.illum = illumination;
+					//currentMaterial.bSpecular = (illumination == 2);
+					currentMaterial.illum = illumination;
 				}
 				else if( (header.compare("map_Kd")==0)	|| (header.compare("map_Ka")==0) ) // texture name
 				{
 					std::string textureName = tokens[1];
 					//strcpy(currentMaterial.textureFileName, textureName.c_str());
-					 currentMaterial.map_Kd=textureName;
-					
+					currentMaterial.map_Kd=textureName;
+
 					// adding texture name into textures vector (if not already present)
 					// avoid adding the same name twice
 					bool found = false;
diff --git a/wrap/io_trimesh/import_vmi.h b/wrap/io_trimesh/import_vmi.h
index f033dd30..c1b988f9 100644
--- a/wrap/io_trimesh/import_vmi.h
+++ b/wrap/io_trimesh/import_vmi.h
@@ -638,7 +638,7 @@ namespace io {
             if(fnameV != nameV) return VMI_INCOMPATIBLE_VERTEX_TYPE;
             if(fnameF != nameF) return VMI_INCOMPATIBLE_FACE_TYPE;
 
-			 int offsetV,offsetF;
+			 int offsetV=0,offsetF=0;
 
 			 if(vertSize!=0)
 				/* read the address of the first vertex */