diff --git a/src/meshlabplugins/filter_isoparametrization/diam_parametrization.h b/src/meshlabplugins/filter_isoparametrization/diam_parametrization.h
index 2920e0f23..cef13c267 100644
--- a/src/meshlabplugins/filter_isoparametrization/diam_parametrization.h
+++ b/src/meshlabplugins/filter_isoparametrization/diam_parametrization.h
@@ -1,562 +1,562 @@
-#include <algorithm>
-#include <time.h>
-#include <vcg/complex/trimesh/refine.h>
-#include <vcg/simplex/face/pos.h>
-#include <vcg/space/color4.h>
-#include <vcg/space/intersection2.h>
-
-#ifndef _DIAMONDPARA
-#define _DIAMONDPARA
-
-class DiamondParametrizator
-{
-	typedef IsoParametrization::CoordType CoordType;
-	typedef IsoParametrization::ScalarType ScalarType;
-
-	IsoParametrization *isoParam;
-
-	///data used for splitting
-	typedef std::pair<int,int> EdgeKey;
-
-	///interpolation data
-	struct InterpData
-	{
-		float alpha;
-		int I;
-		vcg::Point2<float> UV;
-	};
-
-	std::map<EdgeKey,InterpData> alphaMap;
-
-	///data used to store an retrieve edges
-	//typedef std::pair<AbstractFace*,int> TriEdge;
-	//std::vector<DiamondPatch> DDAdiacency;
-	//std::map<TriEdge,int> edgeMap;
-	//int sampleSize;
-
-	template <class FaceType>
-	int AssignDiamond(FaceType *face)
-	{
-		ScalarType val=(ScalarType)1.0/(ScalarType)3.0;
-		CoordType bary3d(val,val,val);
-		int I_interp;
-		vcg::Point2<ScalarType> UV_interp;
-		isoParam->Phi(face,bary3d,I_interp,UV_interp);
-		int D_interp=isoParam->getHDiamIndex(I_interp,UV_interp);
-		face->WT(0).N()=D_interp;
-		face->WT(1).N()=D_interp;
-		face->WT(2).N()=D_interp;
-		return D_interp;
-	}
-
-	///associate the diamond in which a face belongs to
-	void AssociateDiamond()
-	{
-		ParamMesh *to_param=isoParam->ParaMesh();
-		typedef ParamMesh::FaceType FaceType;
-		
-		///first step first associating initial faces to diamond
-		for (unsigned int i=0;i<to_param->face.size();i++)
-		{
-			#ifndef _MESHLAB
-			if ((i%1000)==0)
-			printf("associating diamond %d - %d \n",i,i+1000);
-			#endif
-			FaceType *curr=&to_param->face[i];
-			AssignDiamond(curr);
-			curr->C()=colorDiam[curr->WT(0).N()];
-		}
-	}
-
-	void InterpEdge(const ParamFace *f,const int &index_edge,
-					const float &alpha,int &I,vcg::Point2<ScalarType> &UV)
-	{
-		#ifndef NDEBUG
-		float eps=0.00001f;
-		#endif
-		int index0=index_edge;
-		int index1=(index_edge+1)%3;
-		CoordType bary=CoordType(0,0,0);
-		assert((alpha>=0)&&(alpha<=1));
-		bary.V(index0)=alpha;
-		bary.V(index1)=((ScalarType)1.0-alpha);
-		isoParam->Phi(f,bary,I,UV);
-		assert((UV.X()>=0)&&(UV.Y()>=0)&&(UV.X()<=1)&&(UV.Y()<=1)&&(UV.X()+UV.Y()<=1+eps));
-	}
-
-template <class FaceType>
-void QuadCoord(FaceType * curr,const int &vert_num,vcg::Point2f &UVQuad,int &indexQuad)
-{
-	typedef typename FaceType::VertexType VertexType;
-	typedef typename FaceType::ScalarType ScalarType;
-
-	VertexType* v=curr->V(vert_num);
-	
-	int DiamIndex=curr->WT(0).N(); ///get index of diamond associated to the face
-	assert((curr->WT(0).N()==curr->WT(1).N())&&(curr->WT(1).N()==curr->WT(2).N()));
-
-	///transform to quad coordinates
-	int I=v->T().N();
-	vcg::Point2f UV=v->T().P();
-	
-	///transform in diamond coordinates
-	vcg::Point2f UVDiam/*,UVQuad*/;
-	isoParam->GE1(I,UV,DiamIndex,UVDiam);
-	
-	///transform in quad coordinates
-	isoParam->GE1Quad(DiamIndex,UVDiam,UVQuad);
-
-	indexQuad=DiamIndex;
-	/*return (UVQuad);*/
-}
-
-template <class FaceType>
-	bool To_Split(FaceType * curr,const float	&border,
-				  bool to_split[3],InterpData Idata[3])
-	{
-		to_split[0]=false;
-		to_split[1]=false;
-		to_split[2]=false;
-
-		typedef typename FaceType::VertexType VertexType;
-		typedef typename FaceType::ScalarType ScalarType;
-
-		/*ParamMesh *to_param=isoParam->ParaMesh();*/
-
-		/*int DiamIndex=curr->WT(0).N(); *////get index of diamond associated to the face
-		assert((curr->WT(0).N()==curr->WT(1).N())&&(curr->WT(1).N()==curr->WT(2).N()));
-		
-		vcg::Point2f UVQuad[3];
-		int index[3];
-
-		QuadCoord(curr,0,UVQuad[0],index[0]);
-		QuadCoord(curr,1,UVQuad[1],index[1]);
-		QuadCoord(curr,2,UVQuad[2],index[2]);
-
-		///outern border
-		vcg::Box2<ScalarType> bbox,bbox0;
-		bbox.Add(vcg::Point2f(-border,-border));
-		bbox.Add(vcg::Point2f(1+border,1+border));
-		bbox0.Add(vcg::Point2f(0,0));
-		bbox0.Add(vcg::Point2f(1,1));
-		
-		if (bbox.IsIn(UVQuad[0])&&bbox.IsIn(UVQuad[1])&&bbox.IsIn(UVQuad[2]))
-			return false; ///no intersection is possible
-
-		///else test which edges must be splitted		
-		//vcg::Segment2<float> border_seg[4];
-		vcg::Line2<float> border_seg[4];
-		border_seg[0].Set(vcg::Point2f(0,0),vcg::Point2f(1,0));
-		border_seg[1].Set(vcg::Point2f(1,0),vcg::Point2f(0,1));
-		border_seg[2].Set(vcg::Point2f(0,1),vcg::Point2f(1,0));
-		border_seg[3].Set(vcg::Point2f(0,0),vcg::Point2f(0,1));
-		bool intersected=false;
-		for (int edge=0;edge<3;edge++)
-		{	
-			vcg::Segment2<float> curr_edge=vcg::Segment2<float>(UVQuad[edge],UVQuad[(edge+1)%3]);
-			float dist_medium=1.0;
-			for (int j=0;j<4;j++)
-			{
-				vcg::Point2f p_inters;
-				vcg::Line2<float> curr_border=border_seg[j];
-				bool intersect=LineSegmentIntersection(curr_border,curr_edge,p_inters);
-
-				float l_test0=(curr_edge.P0()-p_inters).Norm();
-				float l_test1=(curr_edge.P1()-p_inters).Norm();
-				float l_test=std::min(l_test0,l_test1);
-	
-				const ScalarType _EPS=(ScalarType)0.0001;
-				if ((intersect)&&(l_test>=_EPS))
-				{
-					float lenght=curr_edge.Length();
-					float dist=((curr_edge.P0()-p_inters).Norm());
-					float Ndist=dist/lenght;
-					float alpha=1.0-Ndist;
-					float dist_medium1=fabs(alpha-0.5);
-					
-					if (dist_medium1<dist_medium)
-					{
-						dist_medium=dist_medium1;
-						int I;
-						vcg::Point2f UV;
-						InterpEdge(curr,edge,alpha,I,UV);
-						Idata[edge].alpha=alpha;
-						Idata[edge].I=I;
-						Idata[edge].UV=UV;
-						to_split[edge]=true;
-						intersected=true;
-					}
-				}
-			}
-		}
-		if(!intersected)
-			assert(0);
-		return(intersected);
-	}
-
-	// Basic subdivision class
-	// This class must provide methods for finding the position of the newly created vertices
-	// In this implemenation we simply put the new vertex in the MidPoint position.
-	// Color and TexCoords are interpolated accordingly.
-	template<class MESH_TYPE>
-	struct SplitMidPoint : public   std::unary_function<vcg::face::Pos<typename MESH_TYPE::FaceType> ,  typename MESH_TYPE::CoordType >
-	{
-		typedef typename MESH_TYPE::VertexType VertexType;
-		typedef typename MESH_TYPE::FaceType FaceType;
-		typedef typename MESH_TYPE::CoordType CoordType;
-
-		std::map<EdgeKey,InterpData> *alphaMap;
-		IsoParametrization *isoParam;
-
-
-
-		void operator()(typename MESH_TYPE::VertexType &nv, vcg::face::Pos<typename MESH_TYPE::FaceType>  ep)
-		{
-			//printf("DONE\n");
-
-			ParamMesh *to_param=isoParam->ParaMesh();
-
-			///get eth value on which the edge must be splitted
-			VertexType* v0=ep.f->V(ep.z);
-			VertexType* v1=ep.f->V1(ep.z);
-
-			int i0=IndexFromPointer(v0,to_param);
-			int i1=IndexFromPointer(v1,to_param);
-
-			assert(v0!=v1);
-			EdgeKey k;
-			int index0=ep.z;
-			int index1=(ep.z+1)%3;
-
-			if (i0>i1)
-			{
-				std::swap(v0,v1);
-				std::swap(i0,i1);
-				std::swap(index0,index1);
-			}
-
-			k=EdgeKey(i0,i1);
-			std::map<EdgeKey,InterpData>::iterator ItE=alphaMap->find(k);
-			assert(ItE!=alphaMap->end());
-			InterpData interp=(*ItE).second;
-			float alpha=interp.alpha;
-			assert((alpha>=0)&&(alpha<=1));
-			nv.P()= v0->P()*alpha+v1->P()*(1.0-alpha);
-			nv.RPos= v0->RPos*alpha+v1->RPos*(1.0-alpha);
-
-			if( MESH_TYPE::HasPerVertexNormal())
-				nv.N()=v0->N()*alpha+v1->N()*((ScalarType)1.0-alpha);
-			if( MESH_TYPE::HasPerVertexColor())
-			{
-				CoordType color=CoordType(v0->C().X(),v0->C().Y(),v0->C().Z());
-				color=color*alpha+color*((ScalarType)1.0-alpha);
-				nv.C()=vcg::Color4b((unsigned char)color.X(),(unsigned char)color.Y(),(unsigned char)color.Z(),(unsigned char)255);
-			}
-
-			nv.T().N()=interp.I;
-			nv.T().P()=interp.UV;
-		}
-
-		vcg::TexCoord2<float> WedgeInterp(vcg::TexCoord2<float> &t0, vcg::TexCoord2<float> &t1)
-		{
-			vcg::TexCoord2<float> tmp;
-			assert(t0.n()== t1.n());
-			tmp.n()=t0.n(); 
-			tmp.t()=(t0.t()+t1.t())/2.0;
-			return tmp;
-		}
-	};
-
-
-
-	template <class MESH_TYPE>//, class FLT>
-	class EdgePredicate
-	{
-		typedef typename MESH_TYPE::VertexType VertexType;
-		typedef typename MESH_TYPE::FaceType FaceType;
-	public:
-		std::map<EdgeKey,InterpData> *alphaMap;
-		IsoParametrization *isoParam;
-
-		bool operator()(vcg::face::Pos<typename MESH_TYPE::FaceType> ep) const
-		{
-			ParamMesh *to_param=isoParam->ParaMesh();
-
-			VertexType* v0=ep.f->V(ep.z);
-			VertexType* v1=ep.f->V1(ep.z);
-
-			int i0=IndexFromPointer(v0,to_param);
-			int i1=IndexFromPointer(v1,to_param);
-
-			assert(v0!=v1);
-			EdgeKey k;
-
-			if (i0>i1)
-			{
-				std::swap(v0,v1);
-				std::swap(i0,i1);
-			}
-
-			k=EdgeKey(i0,i1);
-			std::map<EdgeKey,InterpData>::iterator ItE=alphaMap->find(k);
-			bool to_split=(ItE!=alphaMap->end());
-			return (to_split);
-		}
-	};
-
-	static int IndexFromPointer(ParamVertex * v,ParamMesh *mesh)
-	{
-		int index=v-&(*mesh->vert.begin());
-		return (index);
-	}
-
-	void InsertInterpData(ParamFace *curr,const int &edge,
-						  ParamMesh *to_param,InterpData &Idata)
-	{
-		ParamVertex *v0=curr->V(edge);
-		ParamVertex *v1=curr->V1(edge);
-		int i0=IndexFromPointer(v0,to_param);
-		int i1=IndexFromPointer(v1,to_param);
-		if (i0>i1)
-		{
-			std::swap(v0,v1);
-			std::swap(i0,i1);
-			Idata.alpha=(ScalarType)1.0-Idata.alpha;
-			assert((Idata.alpha>=0)&&(Idata.alpha<=1));
-		}	
-		EdgeKey k=EdgeKey(i0,i1);
-		std::map<EdgeKey,InterpData>::iterator ItE=alphaMap.find(k);
-		if(ItE!=alphaMap.end())
-		{
-			if (fabs((*ItE).second.alpha-0.5)>fabs(Idata.alpha-0.5))
-			{
-				(*ItE).second.alpha=Idata.alpha;
-				(*ItE).second.I=Idata.I;
-				(*ItE).second.UV=Idata.UV;
-			}	
-		}
-		else
-			alphaMap.insert(std::pair<EdgeKey,InterpData>(k,Idata));
-	}
-	
-	bool Split(const ScalarType &border)
-	{
-		alphaMap.clear();
-
-		ParamMesh *to_param=isoParam->ParaMesh();
-
-		///copy paramesh
-
-		typedef ParamMesh::VertexType VertexType;
-		typedef ParamMesh::FaceType FaceType;
-		SplitMidPoint<ParamMesh> splMd;
-		EdgePredicate<ParamMesh> eP;
-
-		///second step.. test the split if needed
-		for (unsigned int i=0;i<to_param->face.size();i++)
-		{
-			///get the current face and test the edges
-			FaceType * curr=&to_param->face[i];
-			InterpData Idata[3];
-			bool to_split[3];
-#ifndef _MESHLAB
-			if ((i%1000)==0)
-			printf("testing face %d - %d \n",i,i+1000);
-#endif
-			bool is_out=To_Split<FaceType>(curr,border,to_split,Idata);
-			if (is_out){
-				for (int edge=0;edge<3;edge++)
-					if (to_split[edge])
-						InsertInterpData(curr,edge,to_param,Idata[edge]);
-			}
-			
-		}
-		splMd.isoParam=isoParam;
-		splMd.alphaMap=&alphaMap;
-		eP.isoParam=isoParam;
-		eP.alphaMap=&alphaMap;
-
-		#ifndef _MESHLAB
-		int f0=to_param->fn;
-		#endif
-		bool done=vcg::RefineE<ParamMesh,SplitMidPoint<ParamMesh>,EdgePredicate<ParamMesh> >(*to_param,splMd,eP);
-		#ifndef _MESHLAB
-		printf("FACE ADDED  %d \n",to_param->fn-f0);
-		#endif
-		return done;
-		
-	}
-	
-	void SetWedgeCoords(const ScalarType &border)
-	{
-		typedef ParamMesh::VertexType VertexType;
-		typedef ParamMesh::FaceType FaceType;
-	
-		ParamMesh *to_param=isoParam->ParaMesh();
-		int edge_size=(int)ceil(sqrt((ScalarType)num_diamonds));
-		ScalarType edgedim=1.0/(ScalarType)edge_size;
-		for (unsigned int i=0;i<to_param->face.size();i++)
-		{
-			#ifndef _MESHLAB
-			if ((i%1000)==0)
-			printf("setting Wedge coords %d - %d \n",i,i+1000);
-			#endif
-			///get the current face and test the edges
-			FaceType * curr=&to_param->face[i];
-			for (int j=0;j<3;j++)
-			{
-				vcg::Point2f QCoord;
-				vcg::Point2i IntCoord;
-				int index;
-				QuadCoord(curr,j,QCoord,index);
-				IntCoord.X()=index/edge_size;
-				IntCoord.Y()=index%edge_size;
-				///transform from [ -border,1 + border] to [0,1]
-				QCoord+=vcg::Point2f(border,border);
-				QCoord/=(ScalarType)1.0+(ScalarType)2.0*border;
-				assert((QCoord.X()>=0)&&(QCoord.X()<=1)&&(QCoord.Y()>=0)&&(QCoord.Y()<=1));
-
-				QCoord*=edgedim;
-				QCoord.X()+=edgedim*(ScalarType)IntCoord.X();
-				QCoord.Y()+=edgedim*(ScalarType)IntCoord.Y();
-				assert(QCoord.X()<=1);
-				assert(QCoord.Y()<=1);
-				curr->WT(j).P()=QCoord;
-				///and finally set for global texture coords
-			}
-		}
-	}
-
-	int num_diamonds;
-
-public:
-	
-	std::vector<vcg::Color4b > colorDiam;
-
-	///initialize the parameterization
-	void Init(IsoParametrization *_isoParam)
-	{
-	
-		isoParam=_isoParam;
-
-		///COUNT THE NUMBER OF EDGES
-		num_diamonds=0;
-		for (unsigned int i=0;i<isoParam->AbsMesh()->face.size();i++)
-		{
-			AbstractFace *f=&isoParam->AbsMesh()->face[i];
-			for (int j=0;j<3;j++)
-				if (f->FFp(j)<f)
-					num_diamonds++;
-		}
-
-		colorDiam.resize(num_diamonds);
-		srand(clock());
-		for (unsigned int i=0;i<colorDiam.size();i++)
-			colorDiam[i]=vcg::Color4b(rand()%255,rand()%255,rand()%255,255);
-
-	}
-
-	//void Draw()
-	//{
-	//	ParamMesh *to_param=isoParam->ParaMesh();
-	//	//vcg::tri::UpdateNormals<ParamMesh>::PerFaceNormalized(*to_param);
-	//	glDepthRange(0.01,1.0);
-	//	glEnable(GL_LIGHTING);
-	//	glEnable(GL_LIGHT0);
-	//	glEnable(GL_NORMALIZE);
-	//	glBegin(GL_TRIANGLES);
-	//	for (int i=0;i<to_param->face.size();i++)
-	//	{
-
-	//		/*vcg::glColor(to_param->face[i].C());*/
-
-	//		CoordType p0=to_param->face[i].V(0)->P();
-	//		CoordType p1=to_param->face[i].V(1)->P();
-	//		CoordType p2=to_param->face[i].V(2)->P();
-	//		CoordType norm=(p1-p0)^(p2-p0);
-	//		norm.Normalize();
-	//		vcg::glNormal(norm);
-	//		vcg::Point2f t0=to_param->face[i].WT(0).P();
-	//		vcg::Point2f t1=to_param->face[i].WT(1).P();
-	//		vcg::Point2f t2=to_param->face[i].WT(2).P();
-	//		vcg::Color4b c0,c1,c2;
-	//		if ((t0.X()< 0)||(t0.Y()< 0)||(t0.X()>1.0)||(t0.Y()>1.0))
-	//		c0=vcg::Color4b(0,0,255,255);
-	//		else
-	//		c0=vcg::Color4b(t0.X()*255.0,t0.Y()*255.0,0,255);
-	//		if ((t1.X()< 0)||(t1.Y()< 0)||(t1.X()>1.0)||(t1.Y()>1.0))
-	//		c1=vcg::Color4b(0,0,255,255);
-	//		else
-	//		c1=vcg::Color4b(t1.X()*255.0,t1.Y()*255.0,0,255);
-	//		if ((t2.X()< 0)||(t2.Y()< 0)||(t2.X()>1.0)||(t2.Y()>1.0))
-	//		c2=vcg::Color4b(0,0,255,255);
-	//		else
-	//		c2=vcg::Color4b(t2.X()*255.0,t2.Y()*255.0,0,255);
-	//		vcg::glColor(c0);
-	//		vcg::glVertex(to_param->face[i].V(0)->P());
-	//		vcg::glColor(c1);
-	//		vcg::glVertex(to_param->face[i].V(1)->P());
-	//		vcg::glColor(c2);
-	//		vcg::glVertex(to_param->face[i].V(2)->P());
-	//	}
-	//	glEnd();
-
-	//	/*glDepthRange(0,0.99999);
-	//	glDisable(GL_LIGHTING);
-	//	glDisable(GL_LIGHT0);
-	//	glDisable(GL_NORMALIZE);
-	//	glLineWidth(1);
-	//	glColor3d(0,0,0);
-	//	for (int i=0;i<to_param->face.size();i++)
-	//	{
-	//		glBegin(GL_LINE_LOOP);
-	//		CoordType p0=to_param->face[i].V(0)->P();
-	//		CoordType p1=to_param->face[i].V(1)->P();
-	//		CoordType p2=to_param->face[i].V(2)->P();
-	//		vcg::glVertex(to_param->face[i].V(0)->P());
-	//		vcg::glVertex(to_param->face[i].V(1)->P());
-	//		vcg::glVertex(to_param->face[i].V(2)->P());
-	//		glEnd();
-	//	}*/
-	//	
-	//	glDepthRange(0.0,1.0);
-	//}
-
-	
-
-	///set the vertex coordinates
-	template <class MeshType>
-	void SetCoordinates(MeshType &mesh,const ScalarType &border=0.01)
-	{
-		std::vector<vcg::Color4b > colorDiam;
-		
-		//ParamMesh *to_param=isoParam->ParaMesh();
-
-		typedef ParamMesh::FaceType FaceType;
-		typedef ParamMesh::VertexType VertexType;
-
-		bool done=true;
-		/*int n0=to_param->fn;*/
-		int step=0;
-		while (done)
-		{
-			#ifndef _MESHLAB
-				printf("step %d \n",step);
-			#endif
-			AssociateDiamond();
-			done=Split(border);
-			isoParam->Update();
-			step++;
-		}
-
-		AssociateDiamond();
-		SetWedgeCoords(border);
-
-		///copy parametrization to the new mesh
-		mesh.Clear();
-		vcg::tri::Append<MeshType,ParamMesh>::Mesh(mesh,*isoParam->ParaMesh());
-		
-	}
-
-};
-#endif
+#include <algorithm>
+#include <time.h>
+#include <vcg/complex/algorithms/refine.h>
+#include <vcg/simplex/face/pos.h>
+#include <vcg/space/color4.h>
+#include <vcg/space/intersection2.h>
+
+#ifndef _DIAMONDPARA
+#define _DIAMONDPARA
+
+class DiamondParametrizator
+{
+	typedef IsoParametrization::CoordType CoordType;
+	typedef IsoParametrization::ScalarType ScalarType;
+
+	IsoParametrization *isoParam;
+
+	///data used for splitting
+	typedef std::pair<int,int> EdgeKey;
+
+	///interpolation data
+	struct InterpData
+	{
+		float alpha;
+		int I;
+		vcg::Point2<float> UV;
+	};
+
+	std::map<EdgeKey,InterpData> alphaMap;
+
+	///data used to store an retrieve edges
+	//typedef std::pair<AbstractFace*,int> TriEdge;
+	//std::vector<DiamondPatch> DDAdiacency;
+	//std::map<TriEdge,int> edgeMap;
+	//int sampleSize;
+
+	template <class FaceType>
+	int AssignDiamond(FaceType *face)
+	{
+		ScalarType val=(ScalarType)1.0/(ScalarType)3.0;
+		CoordType bary3d(val,val,val);
+		int I_interp;
+		vcg::Point2<ScalarType> UV_interp;
+		isoParam->Phi(face,bary3d,I_interp,UV_interp);
+		int D_interp=isoParam->getHDiamIndex(I_interp,UV_interp);
+		face->WT(0).N()=D_interp;
+		face->WT(1).N()=D_interp;
+		face->WT(2).N()=D_interp;
+		return D_interp;
+	}
+
+	///associate the diamond in which a face belongs to
+	void AssociateDiamond()
+	{
+		ParamMesh *to_param=isoParam->ParaMesh();
+		typedef ParamMesh::FaceType FaceType;
+		
+		///first step first associating initial faces to diamond
+		for (unsigned int i=0;i<to_param->face.size();i++)
+		{
+			#ifndef _MESHLAB
+			if ((i%1000)==0)
+			printf("associating diamond %d - %d \n",i,i+1000);
+			#endif
+			FaceType *curr=&to_param->face[i];
+			AssignDiamond(curr);
+			curr->C()=colorDiam[curr->WT(0).N()];
+		}
+	}
+
+	void InterpEdge(const ParamFace *f,const int &index_edge,
+					const float &alpha,int &I,vcg::Point2<ScalarType> &UV)
+	{
+		#ifndef NDEBUG
+		float eps=0.00001f;
+		#endif
+		int index0=index_edge;
+		int index1=(index_edge+1)%3;
+		CoordType bary=CoordType(0,0,0);
+		assert((alpha>=0)&&(alpha<=1));
+		bary.V(index0)=alpha;
+		bary.V(index1)=((ScalarType)1.0-alpha);
+		isoParam->Phi(f,bary,I,UV);
+		assert((UV.X()>=0)&&(UV.Y()>=0)&&(UV.X()<=1)&&(UV.Y()<=1)&&(UV.X()+UV.Y()<=1+eps));
+	}
+
+template <class FaceType>
+void QuadCoord(FaceType * curr,const int &vert_num,vcg::Point2f &UVQuad,int &indexQuad)
+{
+	typedef typename FaceType::VertexType VertexType;
+	typedef typename FaceType::ScalarType ScalarType;
+
+	VertexType* v=curr->V(vert_num);
+	
+	int DiamIndex=curr->WT(0).N(); ///get index of diamond associated to the face
+	assert((curr->WT(0).N()==curr->WT(1).N())&&(curr->WT(1).N()==curr->WT(2).N()));
+
+	///transform to quad coordinates
+	int I=v->T().N();
+	vcg::Point2f UV=v->T().P();
+	
+	///transform in diamond coordinates
+	vcg::Point2f UVDiam/*,UVQuad*/;
+	isoParam->GE1(I,UV,DiamIndex,UVDiam);
+	
+	///transform in quad coordinates
+	isoParam->GE1Quad(DiamIndex,UVDiam,UVQuad);
+
+	indexQuad=DiamIndex;
+	/*return (UVQuad);*/
+}
+
+template <class FaceType>
+	bool To_Split(FaceType * curr,const float	&border,
+				  bool to_split[3],InterpData Idata[3])
+	{
+		to_split[0]=false;
+		to_split[1]=false;
+		to_split[2]=false;
+
+		typedef typename FaceType::VertexType VertexType;
+		typedef typename FaceType::ScalarType ScalarType;
+
+		/*ParamMesh *to_param=isoParam->ParaMesh();*/
+
+		/*int DiamIndex=curr->WT(0).N(); *////get index of diamond associated to the face
+		assert((curr->WT(0).N()==curr->WT(1).N())&&(curr->WT(1).N()==curr->WT(2).N()));
+		
+		vcg::Point2f UVQuad[3];
+		int index[3];
+
+		QuadCoord(curr,0,UVQuad[0],index[0]);
+		QuadCoord(curr,1,UVQuad[1],index[1]);
+		QuadCoord(curr,2,UVQuad[2],index[2]);
+
+		///outern border
+		vcg::Box2<ScalarType> bbox,bbox0;
+		bbox.Add(vcg::Point2f(-border,-border));
+		bbox.Add(vcg::Point2f(1+border,1+border));
+		bbox0.Add(vcg::Point2f(0,0));
+		bbox0.Add(vcg::Point2f(1,1));
+		
+		if (bbox.IsIn(UVQuad[0])&&bbox.IsIn(UVQuad[1])&&bbox.IsIn(UVQuad[2]))
+			return false; ///no intersection is possible
+
+		///else test which edges must be splitted		
+		//vcg::Segment2<float> border_seg[4];
+		vcg::Line2<float> border_seg[4];
+		border_seg[0].Set(vcg::Point2f(0,0),vcg::Point2f(1,0));
+		border_seg[1].Set(vcg::Point2f(1,0),vcg::Point2f(0,1));
+		border_seg[2].Set(vcg::Point2f(0,1),vcg::Point2f(1,0));
+		border_seg[3].Set(vcg::Point2f(0,0),vcg::Point2f(0,1));
+		bool intersected=false;
+		for (int edge=0;edge<3;edge++)
+		{	
+			vcg::Segment2<float> curr_edge=vcg::Segment2<float>(UVQuad[edge],UVQuad[(edge+1)%3]);
+			float dist_medium=1.0;
+			for (int j=0;j<4;j++)
+			{
+				vcg::Point2f p_inters;
+				vcg::Line2<float> curr_border=border_seg[j];
+				bool intersect=LineSegmentIntersection(curr_border,curr_edge,p_inters);
+
+				float l_test0=(curr_edge.P0()-p_inters).Norm();
+				float l_test1=(curr_edge.P1()-p_inters).Norm();
+				float l_test=std::min(l_test0,l_test1);
+	
+				const ScalarType _EPS=(ScalarType)0.0001;
+				if ((intersect)&&(l_test>=_EPS))
+				{
+					float lenght=curr_edge.Length();
+					float dist=((curr_edge.P0()-p_inters).Norm());
+					float Ndist=dist/lenght;
+					float alpha=1.0-Ndist;
+					float dist_medium1=fabs(alpha-0.5);
+					
+					if (dist_medium1<dist_medium)
+					{
+						dist_medium=dist_medium1;
+						int I;
+						vcg::Point2f UV;
+						InterpEdge(curr,edge,alpha,I,UV);
+						Idata[edge].alpha=alpha;
+						Idata[edge].I=I;
+						Idata[edge].UV=UV;
+						to_split[edge]=true;
+						intersected=true;
+					}
+				}
+			}
+		}
+		if(!intersected)
+			assert(0);
+		return(intersected);
+	}
+
+	// Basic subdivision class
+	// This class must provide methods for finding the position of the newly created vertices
+	// In this implemenation we simply put the new vertex in the MidPoint position.
+	// Color and TexCoords are interpolated accordingly.
+	template<class MESH_TYPE>
+	struct SplitMidPoint : public   std::unary_function<vcg::face::Pos<typename MESH_TYPE::FaceType> ,  typename MESH_TYPE::CoordType >
+	{
+		typedef typename MESH_TYPE::VertexType VertexType;
+		typedef typename MESH_TYPE::FaceType FaceType;
+		typedef typename MESH_TYPE::CoordType CoordType;
+
+		std::map<EdgeKey,InterpData> *alphaMap;
+		IsoParametrization *isoParam;
+
+
+
+		void operator()(typename MESH_TYPE::VertexType &nv, vcg::face::Pos<typename MESH_TYPE::FaceType>  ep)
+		{
+			//printf("DONE\n");
+
+			ParamMesh *to_param=isoParam->ParaMesh();
+
+			///get eth value on which the edge must be splitted
+			VertexType* v0=ep.f->V(ep.z);
+			VertexType* v1=ep.f->V1(ep.z);
+
+			int i0=IndexFromPointer(v0,to_param);
+			int i1=IndexFromPointer(v1,to_param);
+
+			assert(v0!=v1);
+			EdgeKey k;
+			int index0=ep.z;
+			int index1=(ep.z+1)%3;
+
+			if (i0>i1)
+			{
+				std::swap(v0,v1);
+				std::swap(i0,i1);
+				std::swap(index0,index1);
+			}
+
+			k=EdgeKey(i0,i1);
+			std::map<EdgeKey,InterpData>::iterator ItE=alphaMap->find(k);
+			assert(ItE!=alphaMap->end());
+			InterpData interp=(*ItE).second;
+			float alpha=interp.alpha;
+			assert((alpha>=0)&&(alpha<=1));
+			nv.P()= v0->P()*alpha+v1->P()*(1.0-alpha);
+			nv.RPos= v0->RPos*alpha+v1->RPos*(1.0-alpha);
+
+			if( MESH_TYPE::HasPerVertexNormal())
+				nv.N()=v0->N()*alpha+v1->N()*((ScalarType)1.0-alpha);
+			if( MESH_TYPE::HasPerVertexColor())
+			{
+				CoordType color=CoordType(v0->C().X(),v0->C().Y(),v0->C().Z());
+				color=color*alpha+color*((ScalarType)1.0-alpha);
+				nv.C()=vcg::Color4b((unsigned char)color.X(),(unsigned char)color.Y(),(unsigned char)color.Z(),(unsigned char)255);
+			}
+
+			nv.T().N()=interp.I;
+			nv.T().P()=interp.UV;
+		}
+
+		vcg::TexCoord2<float> WedgeInterp(vcg::TexCoord2<float> &t0, vcg::TexCoord2<float> &t1)
+		{
+			vcg::TexCoord2<float> tmp;
+			assert(t0.n()== t1.n());
+			tmp.n()=t0.n(); 
+			tmp.t()=(t0.t()+t1.t())/2.0;
+			return tmp;
+		}
+	};
+
+
+
+	template <class MESH_TYPE>//, class FLT>
+	class EdgePredicate
+	{
+		typedef typename MESH_TYPE::VertexType VertexType;
+		typedef typename MESH_TYPE::FaceType FaceType;
+	public:
+		std::map<EdgeKey,InterpData> *alphaMap;
+		IsoParametrization *isoParam;
+
+		bool operator()(vcg::face::Pos<typename MESH_TYPE::FaceType> ep) const
+		{
+			ParamMesh *to_param=isoParam->ParaMesh();
+
+			VertexType* v0=ep.f->V(ep.z);
+			VertexType* v1=ep.f->V1(ep.z);
+
+			int i0=IndexFromPointer(v0,to_param);
+			int i1=IndexFromPointer(v1,to_param);
+
+			assert(v0!=v1);
+			EdgeKey k;
+
+			if (i0>i1)
+			{
+				std::swap(v0,v1);
+				std::swap(i0,i1);
+			}
+
+			k=EdgeKey(i0,i1);
+			std::map<EdgeKey,InterpData>::iterator ItE=alphaMap->find(k);
+			bool to_split=(ItE!=alphaMap->end());
+			return (to_split);
+		}
+	};
+
+	static int IndexFromPointer(ParamVertex * v,ParamMesh *mesh)
+	{
+		int index=v-&(*mesh->vert.begin());
+		return (index);
+	}
+
+	void InsertInterpData(ParamFace *curr,const int &edge,
+						  ParamMesh *to_param,InterpData &Idata)
+	{
+		ParamVertex *v0=curr->V(edge);
+		ParamVertex *v1=curr->V1(edge);
+		int i0=IndexFromPointer(v0,to_param);
+		int i1=IndexFromPointer(v1,to_param);
+		if (i0>i1)
+		{
+			std::swap(v0,v1);
+			std::swap(i0,i1);
+			Idata.alpha=(ScalarType)1.0-Idata.alpha;
+			assert((Idata.alpha>=0)&&(Idata.alpha<=1));
+		}	
+		EdgeKey k=EdgeKey(i0,i1);
+		std::map<EdgeKey,InterpData>::iterator ItE=alphaMap.find(k);
+		if(ItE!=alphaMap.end())
+		{
+			if (fabs((*ItE).second.alpha-0.5)>fabs(Idata.alpha-0.5))
+			{
+				(*ItE).second.alpha=Idata.alpha;
+				(*ItE).second.I=Idata.I;
+				(*ItE).second.UV=Idata.UV;
+			}	
+		}
+		else
+			alphaMap.insert(std::pair<EdgeKey,InterpData>(k,Idata));
+	}
+	
+	bool Split(const ScalarType &border)
+	{
+		alphaMap.clear();
+
+		ParamMesh *to_param=isoParam->ParaMesh();
+
+		///copy paramesh
+
+		typedef ParamMesh::VertexType VertexType;
+		typedef ParamMesh::FaceType FaceType;
+		SplitMidPoint<ParamMesh> splMd;
+		EdgePredicate<ParamMesh> eP;
+
+		///second step.. test the split if needed
+		for (unsigned int i=0;i<to_param->face.size();i++)
+		{
+			///get the current face and test the edges
+			FaceType * curr=&to_param->face[i];
+			InterpData Idata[3];
+			bool to_split[3];
+#ifndef _MESHLAB
+			if ((i%1000)==0)
+			printf("testing face %d - %d \n",i,i+1000);
+#endif
+			bool is_out=To_Split<FaceType>(curr,border,to_split,Idata);
+			if (is_out){
+				for (int edge=0;edge<3;edge++)
+					if (to_split[edge])
+						InsertInterpData(curr,edge,to_param,Idata[edge]);
+			}
+			
+		}
+		splMd.isoParam=isoParam;
+		splMd.alphaMap=&alphaMap;
+		eP.isoParam=isoParam;
+		eP.alphaMap=&alphaMap;
+
+		#ifndef _MESHLAB
+		int f0=to_param->fn;
+		#endif
+		bool done=vcg::RefineE<ParamMesh,SplitMidPoint<ParamMesh>,EdgePredicate<ParamMesh> >(*to_param,splMd,eP);
+		#ifndef _MESHLAB
+		printf("FACE ADDED  %d \n",to_param->fn-f0);
+		#endif
+		return done;
+		
+	}
+	
+	void SetWedgeCoords(const ScalarType &border)
+	{
+		typedef ParamMesh::VertexType VertexType;
+		typedef ParamMesh::FaceType FaceType;
+	
+		ParamMesh *to_param=isoParam->ParaMesh();
+		int edge_size=(int)ceil(sqrt((ScalarType)num_diamonds));
+		ScalarType edgedim=1.0/(ScalarType)edge_size;
+		for (unsigned int i=0;i<to_param->face.size();i++)
+		{
+			#ifndef _MESHLAB
+			if ((i%1000)==0)
+			printf("setting Wedge coords %d - %d \n",i,i+1000);
+			#endif
+			///get the current face and test the edges
+			FaceType * curr=&to_param->face[i];
+			for (int j=0;j<3;j++)
+			{
+				vcg::Point2f QCoord;
+				vcg::Point2i IntCoord;
+				int index;
+				QuadCoord(curr,j,QCoord,index);
+				IntCoord.X()=index/edge_size;
+				IntCoord.Y()=index%edge_size;
+				///transform from [ -border,1 + border] to [0,1]
+				QCoord+=vcg::Point2f(border,border);
+				QCoord/=(ScalarType)1.0+(ScalarType)2.0*border;
+				assert((QCoord.X()>=0)&&(QCoord.X()<=1)&&(QCoord.Y()>=0)&&(QCoord.Y()<=1));
+
+				QCoord*=edgedim;
+				QCoord.X()+=edgedim*(ScalarType)IntCoord.X();
+				QCoord.Y()+=edgedim*(ScalarType)IntCoord.Y();
+				assert(QCoord.X()<=1);
+				assert(QCoord.Y()<=1);
+				curr->WT(j).P()=QCoord;
+				///and finally set for global texture coords
+			}
+		}
+	}
+
+	int num_diamonds;
+
+public:
+	
+	std::vector<vcg::Color4b > colorDiam;
+
+	///initialize the parameterization
+	void Init(IsoParametrization *_isoParam)
+	{
+	
+		isoParam=_isoParam;
+
+		///COUNT THE NUMBER OF EDGES
+		num_diamonds=0;
+		for (unsigned int i=0;i<isoParam->AbsMesh()->face.size();i++)
+		{
+			AbstractFace *f=&isoParam->AbsMesh()->face[i];
+			for (int j=0;j<3;j++)
+				if (f->FFp(j)<f)
+					num_diamonds++;
+		}
+
+		colorDiam.resize(num_diamonds);
+		srand(clock());
+		for (unsigned int i=0;i<colorDiam.size();i++)
+			colorDiam[i]=vcg::Color4b(rand()%255,rand()%255,rand()%255,255);
+
+	}
+
+	//void Draw()
+	//{
+	//	ParamMesh *to_param=isoParam->ParaMesh();
+	//	//vcg::tri::UpdateNormals<ParamMesh>::PerFaceNormalized(*to_param);
+	//	glDepthRange(0.01,1.0);
+	//	glEnable(GL_LIGHTING);
+	//	glEnable(GL_LIGHT0);
+	//	glEnable(GL_NORMALIZE);
+	//	glBegin(GL_TRIANGLES);
+	//	for (int i=0;i<to_param->face.size();i++)
+	//	{
+
+	//		/*vcg::glColor(to_param->face[i].C());*/
+
+	//		CoordType p0=to_param->face[i].V(0)->P();
+	//		CoordType p1=to_param->face[i].V(1)->P();
+	//		CoordType p2=to_param->face[i].V(2)->P();
+	//		CoordType norm=(p1-p0)^(p2-p0);
+	//		norm.Normalize();
+	//		vcg::glNormal(norm);
+	//		vcg::Point2f t0=to_param->face[i].WT(0).P();
+	//		vcg::Point2f t1=to_param->face[i].WT(1).P();
+	//		vcg::Point2f t2=to_param->face[i].WT(2).P();
+	//		vcg::Color4b c0,c1,c2;
+	//		if ((t0.X()< 0)||(t0.Y()< 0)||(t0.X()>1.0)||(t0.Y()>1.0))
+	//		c0=vcg::Color4b(0,0,255,255);
+	//		else
+	//		c0=vcg::Color4b(t0.X()*255.0,t0.Y()*255.0,0,255);
+	//		if ((t1.X()< 0)||(t1.Y()< 0)||(t1.X()>1.0)||(t1.Y()>1.0))
+	//		c1=vcg::Color4b(0,0,255,255);
+	//		else
+	//		c1=vcg::Color4b(t1.X()*255.0,t1.Y()*255.0,0,255);
+	//		if ((t2.X()< 0)||(t2.Y()< 0)||(t2.X()>1.0)||(t2.Y()>1.0))
+	//		c2=vcg::Color4b(0,0,255,255);
+	//		else
+	//		c2=vcg::Color4b(t2.X()*255.0,t2.Y()*255.0,0,255);
+	//		vcg::glColor(c0);
+	//		vcg::glVertex(to_param->face[i].V(0)->P());
+	//		vcg::glColor(c1);
+	//		vcg::glVertex(to_param->face[i].V(1)->P());
+	//		vcg::glColor(c2);
+	//		vcg::glVertex(to_param->face[i].V(2)->P());
+	//	}
+	//	glEnd();
+
+	//	/*glDepthRange(0,0.99999);
+	//	glDisable(GL_LIGHTING);
+	//	glDisable(GL_LIGHT0);
+	//	glDisable(GL_NORMALIZE);
+	//	glLineWidth(1);
+	//	glColor3d(0,0,0);
+	//	for (int i=0;i<to_param->face.size();i++)
+	//	{
+	//		glBegin(GL_LINE_LOOP);
+	//		CoordType p0=to_param->face[i].V(0)->P();
+	//		CoordType p1=to_param->face[i].V(1)->P();
+	//		CoordType p2=to_param->face[i].V(2)->P();
+	//		vcg::glVertex(to_param->face[i].V(0)->P());
+	//		vcg::glVertex(to_param->face[i].V(1)->P());
+	//		vcg::glVertex(to_param->face[i].V(2)->P());
+	//		glEnd();
+	//	}*/
+	//	
+	//	glDepthRange(0.0,1.0);
+	//}
+
+	
+
+	///set the vertex coordinates
+	template <class MeshType>
+	void SetCoordinates(MeshType &mesh,const ScalarType &border=0.01)
+	{
+		std::vector<vcg::Color4b > colorDiam;
+		
+		//ParamMesh *to_param=isoParam->ParaMesh();
+
+		typedef ParamMesh::FaceType FaceType;
+		typedef ParamMesh::VertexType VertexType;
+
+		bool done=true;
+		/*int n0=to_param->fn;*/
+		int step=0;
+		while (done)
+		{
+			#ifndef _MESHLAB
+				printf("step %d \n",step);
+			#endif
+			AssociateDiamond();
+			done=Split(border);
+			isoParam->Update();
+			step++;
+		}
+
+		AssociateDiamond();
+		SetWedgeCoords(border);
+
+		///copy parametrization to the new mesh
+		mesh.Clear();
+		vcg::tri::Append<MeshType,ParamMesh>::Mesh(mesh,*isoParam->ParaMesh());
+		
+	}
+
+};
+#endif
diff --git a/src/meshlabplugins/filter_isoparametrization/diam_topology.h b/src/meshlabplugins/filter_isoparametrization/diam_topology.h
index ec53251dc..5563736f1 100644
--- a/src/meshlabplugins/filter_isoparametrization/diam_topology.h
+++ b/src/meshlabplugins/filter_isoparametrization/diam_topology.h
@@ -1,175 +1,175 @@
-#include <algorithm>
-#include <time.h>
-#include <vcg/complex/trimesh/refine.h>
-#include <vcg/simplex/face/pos.h>
-#include <vcg/space/color4.h>
-#include <vcg/space/intersection2.h>
-
-#ifndef _DIAMONDTOPOLOGY
-#define _DIAMONDTOPOLOGY
-
-class DiamTopology
-{
-	typedef struct DiamondPatch
-	{
-		int FFp[4];
-		int FFi[4];
-
-		AbstractFace *f;
-		int edgeInd;
-
-		DiamondPatch(){
-			FFp[0]=-1;
-			FFp[1]=-1;
-			FFp[2]=-1;
-			FFp[3]=-1;
-			FFi[0]=-1;
-			FFi[1]=-1;
-			FFi[2]=-1;
-			FFi[3]=-1;
-		}
-	};
-
-	std::vector<DiamondPatch> patches;
-	IsoParametrization *isoParam;
-	typedef std::pair<AbstractFace*,int> TriEdge;
-
-	std::vector<DiamondPatch> DDAdiacency;
-	std::map<TriEdge,int> edgeMap;
-	
-	void InsertEdges()
-	{
-		//insert all the edges
-		AbstractMesh *domain=isoParam->AbsMesh();
-		int index=0;
-		for (int i=0;i<domain->fn;i++)
-		{
-			AbstractFace *f0=&(domain->face[i]);
-			if (!f0->IsD())
-			{
-				for(int j=0;j<3;j++)
-				{
-					AbstractFace * f1=f0->FFp(j);
-					if (f1>f0)
-					{
-						DDAdiacency.push_back(DiamondPatch());
-						DDAdiacency[index].f=f0;
-						DDAdiacency[index].edgeInd=j;
-						TriEdge key=TriEdge(f0,j);
-						edgeMap.insert(std::pair<TriEdge,int>(key,index));
-						index++;
-					}
-				}
-			}
-
-		}
-	}
-
-
-
-	void SetTopology()
-	{
-
-		///data used to calculate topology
-		typedef std::pair<AbstractVertex*,AbstractFace*> DiamEdge;
-		struct InfoAdiacency
-		{
-			int index_global;
-			int index_local;
-		};
-
-		std::map<DiamEdge,InfoAdiacency> EdgeDiamMap;
-
-		for (unsigned int i=0;i<DDAdiacency.size();i++)
-		{
-			int indexEdge=DDAdiacency[i].edgeInd;
-			AbstractFace* face=DDAdiacency[i].f;
-			AbstractVertex *v0=face->V0(indexEdge);
-			AbstractVertex *v1=face->V1(indexEdge);
-			AbstractFace *f0=face;
-			AbstractFace *f1=face->FFp(indexEdge);
-
-			///set right order
-			if (v1<v0)
-				std::swap(v0,v1);
-			if (f1<f0)
-				std::swap(f0,f1);
-
-			///then put in the map the variuos edge
-			DiamEdge de[4];
-			de[0]=DiamEdge(v0,f0);
-			de[1]=DiamEdge(v1,f0);
-			de[2]=DiamEdge(v1,f1);
-			de[3]=DiamEdge(v0,f1);
-
-			for (int j=0;j<4;j++)
-			{
-				///find if already exist
-				std::map<DiamEdge,InfoAdiacency>::iterator ItMap=EdgeDiamMap.find(de[j]);
-
-				///first time insert in the table
-				if (ItMap==EdgeDiamMap.end())
-				{
-					InfoAdiacency InfAd;
-					InfAd.index_global=i;
-					InfAd.index_local=j;
-					EdgeDiamMap.insert(std::pair<DiamEdge,InfoAdiacency>(de[j],InfAd));
-				}
-				else
-				{
-					int index_global=(*ItMap).second.index_global;
-					int index_local =(*ItMap).second.index_local;
-					DDAdiacency[index_global].FFp[index_local]=i;
-					DDAdiacency[index_global].FFi[index_local]=j;
-					DDAdiacency[i].FFp[j]=index_global;
-					DDAdiacency[i].FFi[j]=index_local;
-				}
-			}
-		}
-	}
-
-	bool TestTopology()
-	{
-		for (unsigned int i=0;i<DDAdiacency.size();i++)
-		{
-			for (int j=0;j<4;j++)
-			{
-				int index_global=DDAdiacency[i].FFp[j];
-				int index_local=DDAdiacency[i].FFi[j];
-				if ((index_global==-1)||(index_local==-1))
-					return false;
-
-				int opposite0=DDAdiacency[index_global].FFp[index_local];
-				int index_local1=DDAdiacency[index_global].FFi[index_local];
-				///int opposite1=DDAdiacency[i].FFp[index_local];
-				if (opposite0!=i)
-					return false;
-				if (index_local1!=j)
-					return false;
-			}
-		}
-		return true;
-	}
-	
-
-public:
-	
-
-	///initialize the parameterization
-	void Init(IsoParametrization *_isoParam)
-	{
-	
-		isoParam=_isoParam;
-
-		///initialize edges
-		InsertEdges();
-
-		///then set topology
-		SetTopology();
-
-		assert(TestTopology());
-
-	}
-
-};
+#include <algorithm>
+#include <time.h>
+#include <vcg/complex/algorithms/refine.h>
+#include <vcg/simplex/face/pos.h>
+#include <vcg/space/color4.h>
+#include <vcg/space/intersection2.h>
+
+#ifndef _DIAMONDTOPOLOGY
+#define _DIAMONDTOPOLOGY
+
+class DiamTopology
+{
+	typedef struct DiamondPatch
+	{
+		int FFp[4];
+		int FFi[4];
+
+		AbstractFace *f;
+		int edgeInd;
+
+		DiamondPatch(){
+			FFp[0]=-1;
+			FFp[1]=-1;
+			FFp[2]=-1;
+			FFp[3]=-1;
+			FFi[0]=-1;
+			FFi[1]=-1;
+			FFi[2]=-1;
+			FFi[3]=-1;
+		}
+	};
+
+	std::vector<DiamondPatch> patches;
+	IsoParametrization *isoParam;
+	typedef std::pair<AbstractFace*,int> TriEdge;
+
+	std::vector<DiamondPatch> DDAdiacency;
+	std::map<TriEdge,int> edgeMap;
+	
+	void InsertEdges()
+	{
+		//insert all the edges
+		AbstractMesh *domain=isoParam->AbsMesh();
+		int index=0;
+		for (int i=0;i<domain->fn;i++)
+		{
+			AbstractFace *f0=&(domain->face[i]);
+			if (!f0->IsD())
+			{
+				for(int j=0;j<3;j++)
+				{
+					AbstractFace * f1=f0->FFp(j);
+					if (f1>f0)
+					{
+						DDAdiacency.push_back(DiamondPatch());
+						DDAdiacency[index].f=f0;
+						DDAdiacency[index].edgeInd=j;
+						TriEdge key=TriEdge(f0,j);
+						edgeMap.insert(std::pair<TriEdge,int>(key,index));
+						index++;
+					}
+				}
+			}
+
+		}
+	}
+
+
+
+	void SetTopology()
+	{
+
+		///data used to calculate topology
+		typedef std::pair<AbstractVertex*,AbstractFace*> DiamEdge;
+		struct InfoAdiacency
+		{
+			int index_global;
+			int index_local;
+		};
+
+		std::map<DiamEdge,InfoAdiacency> EdgeDiamMap;
+
+		for (unsigned int i=0;i<DDAdiacency.size();i++)
+		{
+			int indexEdge=DDAdiacency[i].edgeInd;
+			AbstractFace* face=DDAdiacency[i].f;
+			AbstractVertex *v0=face->V0(indexEdge);
+			AbstractVertex *v1=face->V1(indexEdge);
+			AbstractFace *f0=face;
+			AbstractFace *f1=face->FFp(indexEdge);
+
+			///set right order
+			if (v1<v0)
+				std::swap(v0,v1);
+			if (f1<f0)
+				std::swap(f0,f1);
+
+			///then put in the map the variuos edge
+			DiamEdge de[4];
+			de[0]=DiamEdge(v0,f0);
+			de[1]=DiamEdge(v1,f0);
+			de[2]=DiamEdge(v1,f1);
+			de[3]=DiamEdge(v0,f1);
+
+			for (int j=0;j<4;j++)
+			{
+				///find if already exist
+				std::map<DiamEdge,InfoAdiacency>::iterator ItMap=EdgeDiamMap.find(de[j]);
+
+				///first time insert in the table
+				if (ItMap==EdgeDiamMap.end())
+				{
+					InfoAdiacency InfAd;
+					InfAd.index_global=i;
+					InfAd.index_local=j;
+					EdgeDiamMap.insert(std::pair<DiamEdge,InfoAdiacency>(de[j],InfAd));
+				}
+				else
+				{
+					int index_global=(*ItMap).second.index_global;
+					int index_local =(*ItMap).second.index_local;
+					DDAdiacency[index_global].FFp[index_local]=i;
+					DDAdiacency[index_global].FFi[index_local]=j;
+					DDAdiacency[i].FFp[j]=index_global;
+					DDAdiacency[i].FFi[j]=index_local;
+				}
+			}
+		}
+	}
+
+	bool TestTopology()
+	{
+		for (unsigned int i=0;i<DDAdiacency.size();i++)
+		{
+			for (int j=0;j<4;j++)
+			{
+				int index_global=DDAdiacency[i].FFp[j];
+				int index_local=DDAdiacency[i].FFi[j];
+				if ((index_global==-1)||(index_local==-1))
+					return false;
+
+				int opposite0=DDAdiacency[index_global].FFp[index_local];
+				int index_local1=DDAdiacency[index_global].FFi[index_local];
+				///int opposite1=DDAdiacency[i].FFp[index_local];
+				if (opposite0!=i)
+					return false;
+				if (index_local1!=j)
+					return false;
+			}
+		}
+		return true;
+	}
+	
+
+public:
+	
+
+	///initialize the parameterization
+	void Init(IsoParametrization *_isoParam)
+	{
+	
+		isoParam=_isoParam;
+
+		///initialize edges
+		InsertEdges();
+
+		///then set topology
+		SetTopology();
+
+		assert(TestTopology());
+
+	}
+
+};
 #endif
\ No newline at end of file
diff --git a/src/meshlabplugins/filter_isoparametrization/diamond_sampler.h b/src/meshlabplugins/filter_isoparametrization/diamond_sampler.h
index c6f120261..a4eb744d6 100644
--- a/src/meshlabplugins/filter_isoparametrization/diamond_sampler.h
+++ b/src/meshlabplugins/filter_isoparametrization/diamond_sampler.h
@@ -1,237 +1,237 @@
-#ifndef _DIAMSAMPLER
-#define _DIAMSAMPLER
-#include <stat_remeshing.h>
-#include <vcg/complex/trimesh/clean.h>
-
-class DiamSampler{
-	typedef IsoParametrization::CoordType CoordType;
-	typedef IsoParametrization::ScalarType ScalarType;
-
-	std::vector<std::vector<std::vector<CoordType> > > SampledPos;
-	IsoParametrization *isoParam;
-	unsigned int sampleSize;
-
-	void DeAllocatePos()
-	{
-		///positions
-		for (unsigned int i=0;i<SampledPos.size();i++)
-		{
-			for (unsigned int j=0;j<SampledPos[i].size();j++)
-				SampledPos[i][j].clear();
-			SampledPos[i].clear();
-		}
-		SampledPos.clear();
-	}
-
-	void AllocatePos(const int & sizeSampl)
-	{
-		///positions
-		AbstractMesh *domain=isoParam->AbsMesh();
-		int num_edges=0;
-		for (unsigned int i=0;i<domain->face.size();i++)
-		{
-			AbstractFace *f=&domain->face[i];
-			for (int j=0;j<3;j++)
-				if (f->FFp(j)>f)
-					num_edges++;
-		}
-
-		SampledPos.resize(num_edges);
-		for (unsigned int i=0;i<SampledPos.size();i++)
-		{
-			SampledPos[i].resize(sizeSampl);
-			for (unsigned int j=0;j<SampledPos[i].size();j++)
-				SampledPos[i][j].resize(sizeSampl);
-		}
-	}
-
-	CoordType AveragePos(const std::vector<ParamFace*> &faces,
-		std::vector<CoordType> &barys)
-	{
-		CoordType pos=CoordType(0,0,0);
-		for (unsigned int i=0;i<faces.size();i++)
-		{
-			pos+=(faces[i]->V(0)->P()*barys[i].X()+
-				faces[i]->V(1)->P()*barys[i].Y()+
-				faces[i]->V(2)->P()*barys[i].Z());
-		}
-		pos/=(ScalarType)faces.size();
-		return pos;
-	}
-
-	int n_diamonds;
-	int inFace;
-	int inEdge;
-	int inStar;
-	int n_merged;
-public:
-
-	///initialize the sampler 
-	void Init(IsoParametrization *_isoParam)
-	{
-		isoParam=_isoParam;
-	}
-
-	template <class OutputMesh>
-	void GetMesh(OutputMesh &SaveMesh)
-	{
-
-		typedef typename OutputMesh::FaceType MyFace;
-		typedef typename OutputMesh::VertexType MyVertex;
-
-		SaveMesh.Clear();
-
-		SaveMesh.vert.reserve(SampledPos.size()*
-			sampleSize*
-			sampleSize);
-
-		SaveMesh.face.reserve(SampledPos.size()*
-			(sampleSize-1)*
-			(sampleSize-1)*2);
-
-		SaveMesh.vn=0;
-		SaveMesh.fn=0;
-
-		///suposed to be the same everywhere
-		///allocate space
-		std::vector<std::vector<MyVertex*> > vertMatrix;
-		vertMatrix.resize(sampleSize);
-		for (unsigned int i=0;i<sampleSize;i++)
-			vertMatrix[i].resize(sampleSize);
-
-		///add vertices
-		for (unsigned int i=0;i<SampledPos.size();i++)
-		//for (unsigned int i=11;i<12;i++)
-		{		
-			///add vertices & positions
-			for (unsigned int j=0;j<sampleSize;j++)
-				for (unsigned int k=0;k<sampleSize;k++)
-				{
-
-					SaveMesh.vert.push_back(MyVertex());
-					SaveMesh.vert.back().P()=SampledPos[i][j][k];
-					vertMatrix[j][k]=&SaveMesh.vert.back();
-					SaveMesh.vn++;
-				}
-				/*printf("samppling %d\n",i);*/
-				///add faces
-				for (unsigned int j=0;j<sampleSize-1;j++)
-					for (unsigned int k=0;k<sampleSize-1;k++)
-					{
-
-
-						MyVertex *v0=vertMatrix[j][k];
-						MyVertex *v1=vertMatrix[j+1][k];
-						MyVertex *v2=vertMatrix[j+1][k+1];
-						MyVertex *v3=vertMatrix[j][k+1];
-
-						SaveMesh.face.push_back(MyFace());
-						SaveMesh.face.back().V(0)=v0;
-						SaveMesh.face.back().V(1)=v1;
-						SaveMesh.face.back().V(2)=v3;
-
-						SaveMesh.face.push_back(MyFace());
-						SaveMesh.face.back().V(0)=v1;
-						SaveMesh.face.back().V(1)=v2;
-						SaveMesh.face.back().V(2)=v3;
-
-						SaveMesh.fn+=2;
-					}
-
-		}
-		///get minimum edge size
-		ScalarType minE,maxE;
-		MaxMinEdge<OutputMesh>(SaveMesh,minE,maxE);
-		/*int num_tri=SampledPos.size()*sampleSize*sampleSize*2;
-		ScalarType Area_mesh=Area<OutputMesh>(SaveMesh);
-		ScalarType Edge=sqrt((((Area_mesh/(ScalarType)num_tri)*4.0)/(ScalarType)sqrt(3.0)));*/
-		n_merged=vcg::tri::Clean<OutputMesh>::MergeCloseVertex(SaveMesh,(ScalarType)minE*(ScalarType)0.9);
-		vcg::tri::UpdateNormals<OutputMesh>::PerVertexNormalized(SaveMesh);
-		/*Log("Merged %d vertices\n",merged);*/
-	}
-
-	//typedef enum SampleAttr{SMNormal, SMColor, SMPosition};
-
-	///sample the parametrization
-	bool SamplePos(const int &size)
-	{
-		if (size<2)
-			return false;
-		sampleSize=size;
-		DeAllocatePos();//clear old data
-		AllocatePos(size);	///allocate for new one
-		inFace=0;
-		inEdge=0;
-		inStar=0;
-		int global=0;
-
-		///start sampling values
-		/*Log("Num Diamonds: %d \n",SampledPos.size());*/
-		
-		
-		for (unsigned int diam=0;diam<SampledPos.size();diam++)
-			for (unsigned int j=0;j<sampleSize;j++)
-				for (unsigned int k=0;k<sampleSize;k++)
-				{
-					vcg::Point2<ScalarType> UVQuad,UV;
-					UVQuad.X()=(ScalarType)j/(ScalarType)(sampleSize-1);
-					UVQuad.Y()=(ScalarType)k/(ScalarType)(sampleSize-1);
-					int I;
-					//printf("Quad: %d,%f,%f \n",diam,UV.X(),UV.Y());
-					///get coordinate in parametric space
-					isoParam->inv_GE1Quad(diam,UVQuad,I,UV);
-					//printf("Alfabeta: %d,%f,%f \n",I,UV.X(),UV.Y());
-					///and sample
-					std::vector<ParamFace*> faces;
-					std::vector<CoordType> barys;
-					int domain=isoParam->Theta(I,UV,faces,barys);
-
-					if (domain==0)
-						inFace++;
-					else
-						if (domain==1)
-							inEdge++;
-						else
-							if (domain==2)
-								inStar++;
-
-					global++;
-					//printf("Find in domain: %d \n",domain);
-					///store value
-					CoordType val=AveragePos(faces,barys);
-					/*if (domain==2)
-					val=CoordType(0,0,0);*/
-					SampledPos[diam][j][k]=val;
-				}
-				return true;
-				/*#ifndef _MESHLAB
-				printf("In Face: %f \n",(ScalarType)inFace/(ScalarType)global);
-				printf("In Diamond: %f \n",(ScalarType)inEdge/(ScalarType)global);
-				printf("In Star: %f \n",(ScalarType)inStar/(ScalarType)global);
-				#endif*/
-				/*Log("In Face: %f \n",(ScalarType)inFace/(ScalarType)global);
-				Log("In Diamond: %f \n",(ScalarType)inEdge/(ScalarType)global);
-				Log("In Star: %f \n",(ScalarType)inStar/(ScalarType)global);*/
-	}
-
-	void getResData(int &_n_diamonds,int &_inFace,
-					int &_inEdge,int &_inStar,int &_n_merged)
-	{
-		_n_diamonds=n_diamonds;
-		_inFace=inFace;
-		_inEdge=inEdge;
-		_inStar=inStar;
-		_n_merged=n_merged;
-	}
-
-	void GetCoords(std::vector<CoordType> &positions)
-	{
-		for (unsigned int diam=0;diam<SampledPos.size();diam++)
-			for (unsigned int j=0;j<sampleSize;j++)
-				for (unsigned int k=0;k<sampleSize;k++)
-					positions.push_back(SampledPos[diam][j][k]);
-	}
-
-
-};
+#ifndef _DIAMSAMPLER
+#define _DIAMSAMPLER
+#include <stat_remeshing.h>
+#include <vcg/complex/algorithms/clean.h>
+
+class DiamSampler{
+	typedef IsoParametrization::CoordType CoordType;
+	typedef IsoParametrization::ScalarType ScalarType;
+
+	std::vector<std::vector<std::vector<CoordType> > > SampledPos;
+	IsoParametrization *isoParam;
+	unsigned int sampleSize;
+
+	void DeAllocatePos()
+	{
+		///positions
+		for (unsigned int i=0;i<SampledPos.size();i++)
+		{
+			for (unsigned int j=0;j<SampledPos[i].size();j++)
+				SampledPos[i][j].clear();
+			SampledPos[i].clear();
+		}
+		SampledPos.clear();
+	}
+
+	void AllocatePos(const int & sizeSampl)
+	{
+		///positions
+		AbstractMesh *domain=isoParam->AbsMesh();
+		int num_edges=0;
+		for (unsigned int i=0;i<domain->face.size();i++)
+		{
+			AbstractFace *f=&domain->face[i];
+			for (int j=0;j<3;j++)
+				if (f->FFp(j)>f)
+					num_edges++;
+		}
+
+		SampledPos.resize(num_edges);
+		for (unsigned int i=0;i<SampledPos.size();i++)
+		{
+			SampledPos[i].resize(sizeSampl);
+			for (unsigned int j=0;j<SampledPos[i].size();j++)
+				SampledPos[i][j].resize(sizeSampl);
+		}
+	}
+
+	CoordType AveragePos(const std::vector<ParamFace*> &faces,
+		std::vector<CoordType> &barys)
+	{
+		CoordType pos=CoordType(0,0,0);
+		for (unsigned int i=0;i<faces.size();i++)
+		{
+			pos+=(faces[i]->V(0)->P()*barys[i].X()+
+				faces[i]->V(1)->P()*barys[i].Y()+
+				faces[i]->V(2)->P()*barys[i].Z());
+		}
+		pos/=(ScalarType)faces.size();
+		return pos;
+	}
+
+	int n_diamonds;
+	int inFace;
+	int inEdge;
+	int inStar;
+	int n_merged;
+public:
+
+	///initialize the sampler 
+	void Init(IsoParametrization *_isoParam)
+	{
+		isoParam=_isoParam;
+	}
+
+	template <class OutputMesh>
+	void GetMesh(OutputMesh &SaveMesh)
+	{
+
+		typedef typename OutputMesh::FaceType MyFace;
+		typedef typename OutputMesh::VertexType MyVertex;
+
+		SaveMesh.Clear();
+
+		SaveMesh.vert.reserve(SampledPos.size()*
+			sampleSize*
+			sampleSize);
+
+		SaveMesh.face.reserve(SampledPos.size()*
+			(sampleSize-1)*
+			(sampleSize-1)*2);
+
+		SaveMesh.vn=0;
+		SaveMesh.fn=0;
+
+		///suposed to be the same everywhere
+		///allocate space
+		std::vector<std::vector<MyVertex*> > vertMatrix;
+		vertMatrix.resize(sampleSize);
+		for (unsigned int i=0;i<sampleSize;i++)
+			vertMatrix[i].resize(sampleSize);
+
+		///add vertices
+		for (unsigned int i=0;i<SampledPos.size();i++)
+		//for (unsigned int i=11;i<12;i++)
+		{		
+			///add vertices & positions
+			for (unsigned int j=0;j<sampleSize;j++)
+				for (unsigned int k=0;k<sampleSize;k++)
+				{
+
+					SaveMesh.vert.push_back(MyVertex());
+					SaveMesh.vert.back().P()=SampledPos[i][j][k];
+					vertMatrix[j][k]=&SaveMesh.vert.back();
+					SaveMesh.vn++;
+				}
+				/*printf("samppling %d\n",i);*/
+				///add faces
+				for (unsigned int j=0;j<sampleSize-1;j++)
+					for (unsigned int k=0;k<sampleSize-1;k++)
+					{
+
+
+						MyVertex *v0=vertMatrix[j][k];
+						MyVertex *v1=vertMatrix[j+1][k];
+						MyVertex *v2=vertMatrix[j+1][k+1];
+						MyVertex *v3=vertMatrix[j][k+1];
+
+						SaveMesh.face.push_back(MyFace());
+						SaveMesh.face.back().V(0)=v0;
+						SaveMesh.face.back().V(1)=v1;
+						SaveMesh.face.back().V(2)=v3;
+
+						SaveMesh.face.push_back(MyFace());
+						SaveMesh.face.back().V(0)=v1;
+						SaveMesh.face.back().V(1)=v2;
+						SaveMesh.face.back().V(2)=v3;
+
+						SaveMesh.fn+=2;
+					}
+
+		}
+		///get minimum edge size
+		ScalarType minE,maxE;
+		MaxMinEdge<OutputMesh>(SaveMesh,minE,maxE);
+		/*int num_tri=SampledPos.size()*sampleSize*sampleSize*2;
+		ScalarType Area_mesh=Area<OutputMesh>(SaveMesh);
+		ScalarType Edge=sqrt((((Area_mesh/(ScalarType)num_tri)*4.0)/(ScalarType)sqrt(3.0)));*/
+		n_merged=vcg::tri::Clean<OutputMesh>::MergeCloseVertex(SaveMesh,(ScalarType)minE*(ScalarType)0.9);
+		vcg::tri::UpdateNormals<OutputMesh>::PerVertexNormalized(SaveMesh);
+		/*Log("Merged %d vertices\n",merged);*/
+	}
+
+	//typedef enum SampleAttr{SMNormal, SMColor, SMPosition};
+
+	///sample the parametrization
+	bool SamplePos(const int &size)
+	{
+		if (size<2)
+			return false;
+		sampleSize=size;
+		DeAllocatePos();//clear old data
+		AllocatePos(size);	///allocate for new one
+		inFace=0;
+		inEdge=0;
+		inStar=0;
+		int global=0;
+
+		///start sampling values
+		/*Log("Num Diamonds: %d \n",SampledPos.size());*/
+		
+		
+		for (unsigned int diam=0;diam<SampledPos.size();diam++)
+			for (unsigned int j=0;j<sampleSize;j++)
+				for (unsigned int k=0;k<sampleSize;k++)
+				{
+					vcg::Point2<ScalarType> UVQuad,UV;
+					UVQuad.X()=(ScalarType)j/(ScalarType)(sampleSize-1);
+					UVQuad.Y()=(ScalarType)k/(ScalarType)(sampleSize-1);
+					int I;
+					//printf("Quad: %d,%f,%f \n",diam,UV.X(),UV.Y());
+					///get coordinate in parametric space
+					isoParam->inv_GE1Quad(diam,UVQuad,I,UV);
+					//printf("Alfabeta: %d,%f,%f \n",I,UV.X(),UV.Y());
+					///and sample
+					std::vector<ParamFace*> faces;
+					std::vector<CoordType> barys;
+					int domain=isoParam->Theta(I,UV,faces,barys);
+
+					if (domain==0)
+						inFace++;
+					else
+						if (domain==1)
+							inEdge++;
+						else
+							if (domain==2)
+								inStar++;
+
+					global++;
+					//printf("Find in domain: %d \n",domain);
+					///store value
+					CoordType val=AveragePos(faces,barys);
+					/*if (domain==2)
+					val=CoordType(0,0,0);*/
+					SampledPos[diam][j][k]=val;
+				}
+				return true;
+				/*#ifndef _MESHLAB
+				printf("In Face: %f \n",(ScalarType)inFace/(ScalarType)global);
+				printf("In Diamond: %f \n",(ScalarType)inEdge/(ScalarType)global);
+				printf("In Star: %f \n",(ScalarType)inStar/(ScalarType)global);
+				#endif*/
+				/*Log("In Face: %f \n",(ScalarType)inFace/(ScalarType)global);
+				Log("In Diamond: %f \n",(ScalarType)inEdge/(ScalarType)global);
+				Log("In Star: %f \n",(ScalarType)inStar/(ScalarType)global);*/
+	}
+
+	void getResData(int &_n_diamonds,int &_inFace,
+					int &_inEdge,int &_inStar,int &_n_merged)
+	{
+		_n_diamonds=n_diamonds;
+		_inFace=inFace;
+		_inEdge=inEdge;
+		_inStar=inStar;
+		_n_merged=n_merged;
+	}
+
+	void GetCoords(std::vector<CoordType> &positions)
+	{
+		for (unsigned int diam=0;diam<SampledPos.size();diam++)
+			for (unsigned int j=0;j<sampleSize;j++)
+				for (unsigned int k=0;k<sampleSize;k++)
+					positions.push_back(SampledPos[diam][j][k]);
+	}
+
+
+};
 #endif
\ No newline at end of file
diff --git a/src/meshlabplugins/filter_isoparametrization/filter_isoparametrization.cpp b/src/meshlabplugins/filter_isoparametrization/filter_isoparametrization.cpp
index 721ce3779..f107d8bfa 100644
--- a/src/meshlabplugins/filter_isoparametrization/filter_isoparametrization.cpp
+++ b/src/meshlabplugins/filter_isoparametrization/filter_isoparametrization.cpp
@@ -1,532 +1,531 @@
-/****************************************************************************
-* MeshLab                                                           o o     *
-* An extendible mesh processor                                    o     o   *
-*                                                                _   O  _   *
-* Copyright(C) 2005, 2006                                          \/)\/    *
-* Visual Computing Lab                                            /\/|      *
-* ISTI - Italian National Research Council                           |      *
-*                                                                    \      *
-* All rights reserved.                                                      *
-*                                                                           *
-* This program is free software; you can redistribute it and/or modify      *
-* it under the terms of the GNU General Public License as published by      *
-* the Free Software Foundation; either version 2 of the License, or         *
-* (at your option) any later version.                                       *
-*                                                                           *
-* This program is distributed in the hope that it will be useful,           *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
-* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
-* for more details.                                                         *
-*                                                                           *
-****************************************************************************/
-
-#include <Qt>
-#include <QtGui>
-#include "defines.h"
-
-#include "../../common/meshmodel.h"
-#include <filter_isoparametrization.h>
-#include <iso_transfer.h>
-#include <vcg/complex/trimesh/update/normal.h>
-
-
-#include <stdlib.h>
-#include <time.h>
-
-using namespace std;
-using namespace vcg;
-
-FilterIsoParametrization::FilterIsoParametrization()
-{
-	typeList << ISOP_PARAM
-		<< ISOP_REMESHING
-		<< ISOP_DIAMPARAM
-		<< ISOP_LOAD
-		<< ISOP_SAVE
-		<< ISOP_TRANSFER;
-
-	FilterIDType tt;
-	foreach(tt , types())
-		actionList << new QAction(filterName(tt), this);
-
-}
-
-FilterIsoParametrization::~FilterIsoParametrization()
-{
-	for (int i = 0; i < actionList.count() ; i++ )
-		delete actionList.at(i);
-}
-
-QString FilterIsoParametrization::filterName(FilterIDType filter) const
-{
-	switch(filter)
-	{
-	case ISOP_PARAM :			return "Iso Parametrization";
-	case ISOP_REMESHING : return "Iso Parametrization Remeshing";
-  case ISOP_DIAMPARAM : return "Iso Parametrization Build Atlased Mesh";
-	case ISOP_LOAD :			return "Iso Parametrization Load Abstract Domain";
-	case ISOP_SAVE :			return "Iso Parametrization Save Abstract Domain";
-	case ISOP_TRANSFER:		return "Iso Parametrization transfer between meshes";
-	default: assert(0);
-	}
-	return QString("error!");
-}
-
-QString FilterIsoParametrization::filterInfo(FilterIDType filterId) const
-{
-	switch(filterId)
-	{
-  case ISOP_PARAM : return "The filter build the abstract Isoparameterization of a two-manifold triangular mesh   <br>"
-											"An adaptively chosen abstract domain of the parameterization is built. For more details see: <br>"
-											"Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
-                      "IEEE Transaction of Visualization and Computer Graphics 2010";
-  case ISOP_REMESHING : return "Remeshing based on an Abstract Isoparameterization, each triangle of the domain is recursively subdivided. <br>"
-													"For more details see: <br>"
-													"Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
-                          "IEEE Transaction of Visualization and Computer Graphics 2010";
-  case ISOP_DIAMPARAM : return "The filter build a new mesh with a standard atlased per wedge texture. The atlas is simply done by "
-                         "splitting each triangle of the abstract domain<br>"
-													"For more details see: <br>"
-													"Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
-                          "IEEE Transaction of Visualization and Computer Graphics 2010";
-  case ISOP_LOAD : return "Load the Isoparameterization from a saved Abstract Mesh  <br>"
-										 "For more details see: <br>"
-										 "Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
-                     "IEEE Transaction of Visualization and Computer Graphics 2010";
-  case ISOP_SAVE : return "Save the Isoparameterization on an Abstract Mesh  <br>"
-										 "For more details see: <br>"
-										 "Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
-                     "IEEE Transaction of Visualization and Computer Graphics 2010";
-  case ISOP_TRANSFER:return "Transfer the Isoparametrization between two meshes, the two meshes must be reasonably similar and well aligned."
-                    " It is useful to transfer back an isoparam onto the original mesh after having computed it on a dummy, clean watertight model.<br>"
-											 "For more details see: <br>"
-											 "Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
-                       "IEEE Transaction of Visualization and Computer Graphics 2010";
-	default: assert(0);
-	}
-	return QString("error!");
-}
-
-int FilterIsoParametrization::getRequirements(QAction *action)
-{
-	(void) action;
-	/*switch(ID(action))
-	{
-	case CP_SCATTER_PER_MESH : return MeshModel::MM_COLOR;
-	default : return MeshModel::MM_VERTCOLOR;
-	}*/
-	return MeshModel::MM_UNKNOWN;
-}
-
-void FilterIsoParametrization::initParameterSet(QAction *a, MeshDocument& md, RichParameterSet & par)
-{
-
-	switch(ID(a))
-	{
-	case ISOP_PARAM:
-		{
-			par.addParam(new RichInt("targetAbstractMinFaceNum",140,"Abstract Min Mesh Size",
-				"This number and the following one indicate the range face number of the abstract mesh that is used for the parametrization process.<br>"
-        "The algorithm will choose the best abstract mesh with the number of triangles within the specified interval.<br>"
-				"If the mesh has a very simple structure this range can be very low and strict;"
-        "for a roughly spherical object if you can specify a range of [8,8] faces you get a octahedral abstract mesh, e.g. a geometry image.<br>"
-				"Large numbers (greater than 400) are usually not of practical use."));
-			par.addParam(new RichInt("targetAbstractMaxFaceNum",180,"Abstract Max Mesh Size", "Please notice that a large interval requires huge amount of memory to be allocated, in order save the intermediate results. <br>"
-				"An interval of 40 should be fine."));
-			QStringList stopCriteriaList;
-			stopCriteriaList.push_back("Best Heuristic");
-			stopCriteriaList.push_back("Area + Angle");
-			stopCriteriaList.push_back("Regularity");
-			stopCriteriaList.push_back("L2");
-
-      par.addParam(new RichEnum("stopCriteria", 1, stopCriteriaList, tr("Optimization Criteria"),
-        tr(//"<p style=\'white-space:pre\'>"
-				"Choose a metric to stop the parametrization within the interval<br>"
-				"1: Best Heuristic : stop considering both isometry and number of faces of base domain<br>"
-				"2: Area + Angle : stop at minimum area and angle distorsion<br>"
-				"3: Regularity : stop at minimum number of irregular vertices<br>"
-				"4: L2 : stop at minimum OneWay L2 Stretch Eff")));
-
-      par.addParam(new RichInt("convergenceSpeed",1, "Convergence Precision", "This parameter controls the convergence speed/precision of the optimization of the texture coordinates. Larger the number slower the processing and ,eventually, slighly better results"));
-			par.addParam(new RichBool("DoubleStep",true,"Double Step","Use this bool to divide the parameterization in 2 steps. Double step makes the overall process faster and robust."
-				"<br> Consider to disable this bool in case the object has topologycal noise or small handles."));
-			break;
-		}
-	case ISOP_REMESHING :
-		{
-			par.addParam(new RichInt("SamplingRate",10,"Sampling Rate", "This specify the sampling rate for remeshing."));
-			break;
-		}
-	case ISOP_DIAMPARAM :
-		{
-      par.addParam(new RichDynamicFloat("BorderSize",0.1f,0.01f,0.5f,"BorderSize ratio",
-          "This parameter controls the amount of space that must be left between each diamond when building the atlas."
-          "It directly affects how many triangle are splitted during this conversion. <br>"
-          "In abstract parametrization mesh triangles can naturally cross the triangles of the abstract domain, so when converting "
-          "to a standard parametrization we must cut all the triangles that protrudes outside each diamond more than the specified threshold."
-          "The unit of the threshold is in percentage of the size of the diamond,"
-          "The bigger the threshold the less triangles are splitted, but the more UV space is used (wasted)."));
-			break;										
-		}
-	case ISOP_LOAD : 
-		{
-			QFileInfo fi(md.mm()->fullName());
-			QString fileName = fi.baseName();
-
-			fileName = fileName.append(".abs");
-      par.addParam(new RichString("AbsName", fileName, "Abstract Mesh file", "The filename of the abstract mesh that has to be loaded"));
-			break;
-		}
-	case ISOP_SAVE : 
-		{
-			QFileInfo fi(md.mm()->fullName());
-			QString fileName = fi.baseName();
-
-			fileName = fileName.append(".abs");
-      par.addParam(new RichString("AbsName", fileName, "Abstract Mesh file", "The filename where the abstract mesh has to be saved"));
-			break;
-		}
-	case ISOP_TRANSFER:
-		{
-      par.addParam(new RichMesh ("sourceMesh",md.mm(),&md, "Source Mesh",	"The mesh already having an Isoparameterization"));
-      par.addParam(new RichMesh ("targetMesh",md.mm(),&md, "Target Mesh",	"The mesh to be Isoparameterized"));
-    }
-	}
-}
-
-void FilterIsoParametrization::PrintStats(CMeshO *mesh)
-{
-  tri::UpdateTopology<CMeshO>::FaceFace(*mesh);
-  tri::UpdateTopology<CMeshO>::VertexFace(*mesh);
-	int non_reg=NumRegular<CMeshO>(*mesh);
-	float minE,maxE,avE,stdE;
-	float minAr,maxAr,avAr,stdAr;
-	float minAn,maxAn,avAn,stdAn;
-	int minEi,maxEi,stdEi;
-	int minAri,maxAri,stdAri;
-	int minAni,maxAni,stdAni;
-
-	StatEdge<CMeshO>(*mesh,minE,maxE,avE,stdE);
-	StatArea<CMeshO>(*mesh,minAr,maxAr,avAr,stdAr);
-	StatAngle<CMeshO>(*mesh,minAn,maxAn,avAn,stdAn);
-	minE/=avE;
-	minE*=100.f;
-	maxE/=avE;
-	maxE*=100.f;
-	stdE/=avE;
-	stdE*=100.f;
-
-	minAn/=avAn;
-	minAn*=100.f;
-	maxAn/=avAn;
-	maxAn*=100.f;
-	stdAn/=avAn;
-	stdAn*=100.f;
-
-	minAr/=avAr;
-	minAr*=100.f;
-	maxAr/=avAr;
-	maxAr*=100.f;
-	stdAr/=avAr;
-	stdAr*=100.f;
-
-	minEi=(int)minE;
-	maxEi=(int)maxE;
-	stdEi=(int)stdE;
-
-	minAni=(int)minAn;
-	maxAni=(int)maxAn;
-	stdAni=(int)stdAn;
-
-	minAri=(int)minAr;
-	maxAri=(int)maxAr;
-	stdAri=(int)stdAr;
-
-	Log(" REMESHED ");
-	Log("Irregular Vertices:%d ",non_reg);
-	Log("stdDev Area:%d",stdAri);
-	Log("stdDev Angle:%d",stdAni);
-	Log("stdDev Edge:%d",stdEi);
-}
-
-bool FilterIsoParametrization::applyFilter(QAction *filter, MeshDocument& md, RichParameterSet & par, vcg::CallBackPos  *cb)
-{
-	MeshModel* m = md.mm();  //get current mesh from document
-	CMeshO *mesh=&m->cm;
-	switch(ID(filter))
-	{
-	case ISOP_PARAM :
-		{
-			int targetAbstractMinFaceNum = par.getInt("targetAbstractMinFaceNum");
-			int targetAbstractMaxFaceNum = par.getInt("targetAbstractMaxFaceNum");
-			int convergenceSpeed = par.getInt("convergenceSpeed");
-			int stopCriteria=par.getEnum("stopCriteria");
-			bool doublestep=par.getBool("DoubleStep");
-			IsoParametrizator Parametrizator;
-
-			m->updateDataMask(MeshModel::MM_FACEFACETOPO);
-      m->updateDataMask(MeshModel::MM_VERTQUALITY); // needed to store patch index
-
-			bool isTXTenabled=m->hasDataMask(MeshModel::MM_VERTTEXCOORD);
-			if (!isTXTenabled)
-				m->updateDataMask(MeshModel::MM_VERTTEXCOORD);
-
-			bool isVMarkenabled=m->hasDataMask(MeshModel::MM_VERTMARK);
-			if (!isVMarkenabled)
-				m->updateDataMask(MeshModel::MM_VERTMARK);
-
-			bool isFMarkenabled=m->hasDataMask(MeshModel::MM_FACEMARK);
-			if (!isFMarkenabled)
-				m->updateDataMask(MeshModel::MM_FACEMARK);
-
-			bool isVColorenabled=m->hasDataMask(MeshModel::MM_VERTCOLOR);
-			if (!isVColorenabled)
-				m->updateDataMask(MeshModel::MM_VERTCOLOR);
-
-			bool isFColorenabled=m->hasDataMask(MeshModel::MM_FACECOLOR);
-			if (!isFColorenabled)
-				m->updateDataMask(MeshModel::MM_FACECOLOR);
-			int tolerance = targetAbstractMaxFaceNum-targetAbstractMinFaceNum;
-			switch (stopCriteria)
-			{
-			case 0:Parametrizator.SetParameters(cb,targetAbstractMinFaceNum,tolerance,IsoParametrizator::SM_Euristic,convergenceSpeed);break;
-			case 1:Parametrizator.SetParameters(cb,targetAbstractMinFaceNum,tolerance,IsoParametrizator::SM_Corr,convergenceSpeed);break;
-			case 2:Parametrizator.SetParameters(cb,targetAbstractMinFaceNum,tolerance,IsoParametrizator::SM_Reg,convergenceSpeed);break;
-			case 3:Parametrizator.SetParameters(cb,targetAbstractMinFaceNum,tolerance,IsoParametrizator::SM_L2,convergenceSpeed);break;
-			default:Parametrizator.SetParameters(cb,targetAbstractMinFaceNum,tolerance,IsoParametrizator::SM_Euristic,convergenceSpeed);break;
-			}
-			IsoParametrizator::ReturnCode ret=Parametrizator.Parametrize<CMeshO>(mesh,doublestep);
-
-			if (ret==IsoParametrizator::Done)
-			{
-				Parametrizator.PrintAttributes();
-				float aggregate,L2;
-				int n_faces;
-				Parametrizator.getValues(aggregate,L2,n_faces);
-				Log("Num Faces of Abstract Domain: %d, One way stretch efficiency: %.4f, Area+Angle Distorsion %.4f  ",n_faces,L2,aggregate*100.f);
-			}
-			else
-			{
-        if (!isTXTenabled)    m->clearDataMask(MeshModel::MM_VERTTEXCOORD);
-        if (!isFMarkenabled)  m->clearDataMask(MeshModel::MM_FACEMARK);
-        if (!isVMarkenabled)  m->clearDataMask(MeshModel::MM_VERTMARK);
-        if (!isVColorenabled) m->clearDataMask(MeshModel::MM_VERTCOLOR);
-        if (!isFColorenabled) m->clearDataMask(MeshModel::MM_FACECOLOR);
-        switch(ret)
-        {
-        case IsoParametrizator::MultiComponent:
-          this->errorMessage="non possible parameterization because of multi componet mesh"; return false;
-        case IsoParametrizator::NonSizeCons:
-          this->errorMessage="non possible parameterization because of non size consistent mesh"; return false;
-        case IsoParametrizator::NonManifoldE:
-          this->errorMessage="non possible parameterization because of non manifold edges"; return false;
-        case IsoParametrizator::NonManifoldV:
-          this->errorMessage="non possible parameterization because of non manifold vertices";return false;
-        case IsoParametrizator::NonWatertigh:
-          this->errorMessage="non possible parameterization because of non watertight mesh"; return false;
-        case IsoParametrizator::FailParam:
-          this->errorMessage="non possible parameterization cause one of the following reasons:\n Topologycal noise \n Too Low resolution mesh \n Too Bad triangulation \n"; return false;
-        default:
-          this->errorMessage="unknown error"; return false;
-        }
-			}
-      // At this point we are sure that everithing went ok so we can allocate surely the abstract
-      AbstractMesh *abs_mesh = new AbstractMesh();
-      ParamMesh *para_mesh = new ParamMesh();
-      Parametrizator.ExportMeshes(*para_mesh,*abs_mesh);
-      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle;
-      isoPHandle=tri::Allocator<CMeshO>::AddPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
-
-      bool isOK=isoPHandle().Init(abs_mesh,para_mesh);
-
-			///copy back to original mesh
-			isoPHandle().CopyParametrization<CMeshO>(mesh);
-
-			if (!isOK)
-			{
-        this->errorMessage="Problems gathering parameterization \n";
-				return false;
-			}
-			if (!isVMarkenabled)
-				m->clearDataMask(MeshModel::MM_VERTMARK);
-			if (!isFMarkenabled)
-				m->clearDataMask(MeshModel::MM_FACEMARK);
-			return true;
-		}
-	case ISOP_REMESHING :
-		{
-      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle =
-          tri::Allocator<CMeshO>::GetPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
-
-      bool b=tri::Allocator<CMeshO>::IsValidHandle<IsoParametrization>(*mesh,isoPHandle);
-			if (!b)
-			{
-				this->errorMessage="You must compute the Base domain before remeshing. Use the Isoparametrization command.";
-				return false;
-			}
-			
-
-			int SamplingRate=par.getInt("SamplingRate");
-			if (!SamplingRate>2)
-			{
-				this->errorMessage="Sampling rate must be >1";
-				return false;
-			}
-      MeshModel* mm=md.addNewMesh("","Re-meshed");
-
-			CMeshO *rem=&mm->cm;
-      DiamSampler DiamSampl;
-			DiamSampl.Init(&isoPHandle());
-			bool done=DiamSampl.SamplePos(SamplingRate);
-			assert(done);
-			DiamSampl.GetMesh<CMeshO>(*rem);
-
-			int n_diamonds,inFace,inEdge,inStar,n_merged;
-			DiamSampl.getResData(n_diamonds,inFace,inEdge,inStar,n_merged);
-
-			Log("INTERPOLATION DOMAINS");
-			Log("In Face: %d \n",inFace);
-			Log("In Diamond: %d \n",inEdge);
-			Log("In Star: %d \n",inStar);
-			Log("Merged %d vertices\n",n_merged);
-			mm->updateDataMask(MeshModel::MM_FACEFACETOPO);
-			mm->updateDataMask(MeshModel::MM_VERTFACETOPO);
-			PrintStats(rem);
-      tri::UpdateNormals<CMeshO>::PerFace(*rem);
-			return true;
-		}
-	case ISOP_DIAMPARAM :
-		{
-      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle =
-          tri::Allocator<CMeshO>::GetPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
-      bool b=tri::Allocator<CMeshO>::IsValidHandle<IsoParametrization>(*mesh,isoPHandle);
-			if (!b)
-			{
-				this->errorMessage="You must compute the Base domain before remeshing. Use the Isoparametrization command.";
-				return false;
-			}
-
-			float border_size=par.getDynamicFloat("BorderSize");
-      MeshModel* mm=md.addNewMesh("","Diam-Parameterized");
-			mm->updateDataMask(MeshModel::MM_WEDGTEXCOORD);
-			mm->updateDataMask(MeshModel::MM_VERTCOLOR);
-			CMeshO *rem=&mm->cm;
-			DiamondParametrizator DiaPara;
-			DiaPara.Init(&isoPHandle());
-			DiaPara.SetCoordinates<CMeshO>(*rem,border_size);
-      tri::UpdateNormals<CMeshO>::PerFace(*rem);
-			return true;
-		}
-	case ISOP_LOAD : 
-		{
-			QString AbsName = par.getString("AbsName");
-			m->updateDataMask(MeshModel::MM_WEDGTEXCOORD);
-			m->updateDataMask(MeshModel::MM_VERTTEXCOORD);
-			m->updateDataMask(MeshModel::MM_FACECOLOR);
-			m->updateDataMask(MeshModel::MM_VERTQUALITY);
-			m->updateDataMask(MeshModel::MM_FACEMARK);
-			if(!QFile(m->fullName()).exists())
-			{
-				this->errorMessage="File not exists";
-				return false;
-			}
-      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle =
-          tri::Allocator<CMeshO>::GetPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
-
-      bool b=tri::Allocator<CMeshO>::IsValidHandle<IsoParametrization>(*mesh,isoPHandle);
-			if (!b)
-        isoPHandle=tri::Allocator<CMeshO>::AddPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
-
-			QByteArray ba = AbsName.toLatin1();
-			char *path=ba.data();
-      AbstractMesh *abs_mesh = new AbstractMesh();
-      ParamMesh *para_mesh = new ParamMesh();
-      bool Done=isoPHandle().LoadBaseDomain<CMeshO>(path,mesh,para_mesh,abs_mesh,true);
-			if (!Done)
-			{
-				this->errorMessage="Abstract domain doesnt fit well with the parametrized mesh";
-        delete para_mesh;
-        delete abs_mesh;
-				return false;
-			}
-			return true;
-		}
-	case ISOP_SAVE : 
-		{
-			m->updateDataMask(MeshModel::MM_VERTQUALITY);
-      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle =
-          tri::Allocator<CMeshO>::GetPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
-
-      bool b=tri::Allocator<CMeshO>::IsValidHandle<IsoParametrization>(*mesh,isoPHandle);
-			if (!b)
-			{
-				this->errorMessage="You must compute the Base domain before remeshing. Use the Isoparametrization command.";
-				return false;
-			}
-			/*QString Qpath=m->fullName();*/
-
-			QString AbsName = par.getString("AbsName");
-
-			QByteArray ba = AbsName.toLatin1();
-			char *path=ba.data();
-			isoPHandle().SaveBaseDomain(path);
-			return true;
-		}
-	case ISOP_TRANSFER:
-		{
-      MeshModel *mmtrg = par.getMesh("targetMesh");
-      MeshModel *mmsrc = par.getMesh("targetMesh");
-      CMeshO *trgMesh=&mmtrg->cm;
-      CMeshO *srcMesh=&mmsrc->cm;
-
-      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle =
-          tri::Allocator<CMeshO>::GetPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
-
-      bool b=tri::Allocator<CMeshO>::IsValidHandle<IsoParametrization>(*srcMesh,isoPHandle);
-			if (!b)
-			{
-        this->errorMessage="Your source mesh must have the abstract isoparametrization. Use the Isoparametrization command.";
-				return false;
-			}
-			IsoTransfer IsoTr;
-      AbstractMesh *abs_mesh = isoPHandle().AbsMesh();
-      ParamMesh *para_mesh = isoPHandle().ParaMesh();
-
-      mmtrg->updateDataMask(MeshModel::MM_WEDGTEXCOORD);
-      mmtrg->updateDataMask(MeshModel::MM_VERTTEXCOORD);
-      mmtrg->updateDataMask(MeshModel::MM_FACECOLOR);
-      mmtrg->updateDataMask(MeshModel::MM_VERTQUALITY);
-      mmtrg->updateDataMask(MeshModel::MM_FACEMARK);
-      IsoTr.Transfer<CMeshO>(isoPHandle(),*trgMesh);
-			
-			isoPHandle().Clear();
-      tri::Allocator<CMeshO>::DeletePerMeshAttribute(*srcMesh,isoPHandle);
-			
-      isoPHandle=tri::Allocator<CMeshO>::AddPerMeshAttribute<IsoParametrization>(*trgMesh,"isoparametrization");
-      isoPHandle().AbsMesh()=abs_mesh;
-      isoPHandle().SetParamMesh<CMeshO>(trgMesh,para_mesh);
-			
-			return true;
-		}
-	}
-	return false;
-}
-
-MeshFilterInterface::FilterClass FilterIsoParametrization::getClass(QAction *a)
-{
-	switch(ID(a))
-	{
-	case ISOP_PARAM : return MeshFilterInterface::Remeshing;
-	case ISOP_REMESHING : return MeshFilterInterface::Remeshing;
-	case ISOP_DIAMPARAM : return MeshFilterInterface::Remeshing;
-	default: return MeshFilterInterface::Remeshing;
-	}
-}
-
-int FilterIsoParametrization::postCondition( QAction* /*filter*/ ) const
-{
-	return MeshModel::MM_UNKNOWN;
-}
-
-Q_EXPORT_PLUGIN(FilterIsoParametrization)
+/****************************************************************************
+* MeshLab                                                           o o     *
+* An extendible mesh processor                                    o     o   *
+*                                                                _   O  _   *
+* Copyright(C) 2005, 2006                                          \/)\/    *
+* Visual Computing Lab                                            /\/|      *
+* ISTI - Italian National Research Council                           |      *
+*                                                                    \      *
+* All rights reserved.                                                      *
+*                                                                           *
+* This program is free software; you can redistribute it and/or modify      *
+* it under the terms of the GNU General Public License as published by      *
+* the Free Software Foundation; either version 2 of the License, or         *
+* (at your option) any later version.                                       *
+*                                                                           *
+* This program is distributed in the hope that it will be useful,           *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
+* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
+* for more details.                                                         *
+*                                                                           *
+****************************************************************************/
+
+#include <Qt>
+#include <QtGui>
+#include "defines.h"
+
+#include "../../common/meshmodel.h"
+#include <filter_isoparametrization.h>
+#include <iso_transfer.h>
+
+
+#include <stdlib.h>
+#include <time.h>
+
+using namespace std;
+using namespace vcg;
+
+FilterIsoParametrization::FilterIsoParametrization()
+{
+	typeList << ISOP_PARAM
+		<< ISOP_REMESHING
+		<< ISOP_DIAMPARAM
+		<< ISOP_LOAD
+		<< ISOP_SAVE
+		<< ISOP_TRANSFER;
+
+	FilterIDType tt;
+	foreach(tt , types())
+		actionList << new QAction(filterName(tt), this);
+
+}
+
+FilterIsoParametrization::~FilterIsoParametrization()
+{
+	for (int i = 0; i < actionList.count() ; i++ )
+		delete actionList.at(i);
+}
+
+QString FilterIsoParametrization::filterName(FilterIDType filter) const
+{
+	switch(filter)
+	{
+	case ISOP_PARAM :			return "Iso Parametrization";
+	case ISOP_REMESHING : return "Iso Parametrization Remeshing";
+  case ISOP_DIAMPARAM : return "Iso Parametrization Build Atlased Mesh";
+	case ISOP_LOAD :			return "Iso Parametrization Load Abstract Domain";
+	case ISOP_SAVE :			return "Iso Parametrization Save Abstract Domain";
+	case ISOP_TRANSFER:		return "Iso Parametrization transfer between meshes";
+	default: assert(0);
+	}
+	return QString("error!");
+}
+
+QString FilterIsoParametrization::filterInfo(FilterIDType filterId) const
+{
+	switch(filterId)
+	{
+  case ISOP_PARAM : return "The filter build the abstract Isoparameterization of a two-manifold triangular mesh   <br>"
+											"An adaptively chosen abstract domain of the parameterization is built. For more details see: <br>"
+											"Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
+                      "IEEE Transaction of Visualization and Computer Graphics 2010";
+  case ISOP_REMESHING : return "Remeshing based on an Abstract Isoparameterization, each triangle of the domain is recursively subdivided. <br>"
+													"For more details see: <br>"
+													"Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
+                          "IEEE Transaction of Visualization and Computer Graphics 2010";
+  case ISOP_DIAMPARAM : return "The filter build a new mesh with a standard atlased per wedge texture. The atlas is simply done by "
+                         "splitting each triangle of the abstract domain<br>"
+													"For more details see: <br>"
+													"Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
+                          "IEEE Transaction of Visualization and Computer Graphics 2010";
+  case ISOP_LOAD : return "Load the Isoparameterization from a saved Abstract Mesh  <br>"
+										 "For more details see: <br>"
+										 "Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
+                     "IEEE Transaction of Visualization and Computer Graphics 2010";
+  case ISOP_SAVE : return "Save the Isoparameterization on an Abstract Mesh  <br>"
+										 "For more details see: <br>"
+										 "Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
+                     "IEEE Transaction of Visualization and Computer Graphics 2010";
+  case ISOP_TRANSFER:return "Transfer the Isoparametrization between two meshes, the two meshes must be reasonably similar and well aligned."
+                    " It is useful to transfer back an isoparam onto the original mesh after having computed it on a dummy, clean watertight model.<br>"
+											 "For more details see: <br>"
+											 "Pietroni, Tarini and Cignoni, 'Almost isometric mesh parameterization through abstract domains' <br>"
+                       "IEEE Transaction of Visualization and Computer Graphics 2010";
+	default: assert(0);
+	}
+	return QString("error!");
+}
+
+int FilterIsoParametrization::getRequirements(QAction *action)
+{
+	(void) action;
+	/*switch(ID(action))
+	{
+	case CP_SCATTER_PER_MESH : return MeshModel::MM_COLOR;
+	default : return MeshModel::MM_VERTCOLOR;
+	}*/
+	return MeshModel::MM_UNKNOWN;
+}
+
+void FilterIsoParametrization::initParameterSet(QAction *a, MeshDocument& md, RichParameterSet & par)
+{
+
+	switch(ID(a))
+	{
+	case ISOP_PARAM:
+		{
+			par.addParam(new RichInt("targetAbstractMinFaceNum",140,"Abstract Min Mesh Size",
+				"This number and the following one indicate the range face number of the abstract mesh that is used for the parametrization process.<br>"
+        "The algorithm will choose the best abstract mesh with the number of triangles within the specified interval.<br>"
+				"If the mesh has a very simple structure this range can be very low and strict;"
+        "for a roughly spherical object if you can specify a range of [8,8] faces you get a octahedral abstract mesh, e.g. a geometry image.<br>"
+				"Large numbers (greater than 400) are usually not of practical use."));
+			par.addParam(new RichInt("targetAbstractMaxFaceNum",180,"Abstract Max Mesh Size", "Please notice that a large interval requires huge amount of memory to be allocated, in order save the intermediate results. <br>"
+				"An interval of 40 should be fine."));
+			QStringList stopCriteriaList;
+			stopCriteriaList.push_back("Best Heuristic");
+			stopCriteriaList.push_back("Area + Angle");
+			stopCriteriaList.push_back("Regularity");
+			stopCriteriaList.push_back("L2");
+
+      par.addParam(new RichEnum("stopCriteria", 1, stopCriteriaList, tr("Optimization Criteria"),
+        tr(//"<p style=\'white-space:pre\'>"
+				"Choose a metric to stop the parametrization within the interval<br>"
+				"1: Best Heuristic : stop considering both isometry and number of faces of base domain<br>"
+				"2: Area + Angle : stop at minimum area and angle distorsion<br>"
+				"3: Regularity : stop at minimum number of irregular vertices<br>"
+				"4: L2 : stop at minimum OneWay L2 Stretch Eff")));
+
+      par.addParam(new RichInt("convergenceSpeed",1, "Convergence Precision", "This parameter controls the convergence speed/precision of the optimization of the texture coordinates. Larger the number slower the processing and ,eventually, slighly better results"));
+			par.addParam(new RichBool("DoubleStep",true,"Double Step","Use this bool to divide the parameterization in 2 steps. Double step makes the overall process faster and robust."
+				"<br> Consider to disable this bool in case the object has topologycal noise or small handles."));
+			break;
+		}
+	case ISOP_REMESHING :
+		{
+			par.addParam(new RichInt("SamplingRate",10,"Sampling Rate", "This specify the sampling rate for remeshing."));
+			break;
+		}
+	case ISOP_DIAMPARAM :
+		{
+      par.addParam(new RichDynamicFloat("BorderSize",0.1f,0.01f,0.5f,"BorderSize ratio",
+          "This parameter controls the amount of space that must be left between each diamond when building the atlas."
+          "It directly affects how many triangle are splitted during this conversion. <br>"
+          "In abstract parametrization mesh triangles can naturally cross the triangles of the abstract domain, so when converting "
+          "to a standard parametrization we must cut all the triangles that protrudes outside each diamond more than the specified threshold."
+          "The unit of the threshold is in percentage of the size of the diamond,"
+          "The bigger the threshold the less triangles are splitted, but the more UV space is used (wasted)."));
+			break;										
+		}
+	case ISOP_LOAD : 
+		{
+			QFileInfo fi(md.mm()->fullName());
+			QString fileName = fi.baseName();
+
+			fileName = fileName.append(".abs");
+      par.addParam(new RichString("AbsName", fileName, "Abstract Mesh file", "The filename of the abstract mesh that has to be loaded"));
+			break;
+		}
+	case ISOP_SAVE : 
+		{
+			QFileInfo fi(md.mm()->fullName());
+			QString fileName = fi.baseName();
+
+			fileName = fileName.append(".abs");
+      par.addParam(new RichString("AbsName", fileName, "Abstract Mesh file", "The filename where the abstract mesh has to be saved"));
+			break;
+		}
+	case ISOP_TRANSFER:
+		{
+      par.addParam(new RichMesh ("sourceMesh",md.mm(),&md, "Source Mesh",	"The mesh already having an Isoparameterization"));
+      par.addParam(new RichMesh ("targetMesh",md.mm(),&md, "Target Mesh",	"The mesh to be Isoparameterized"));
+    }
+	}
+}
+
+void FilterIsoParametrization::PrintStats(CMeshO *mesh)
+{
+  tri::UpdateTopology<CMeshO>::FaceFace(*mesh);
+  tri::UpdateTopology<CMeshO>::VertexFace(*mesh);
+	int non_reg=NumRegular<CMeshO>(*mesh);
+	float minE,maxE,avE,stdE;
+	float minAr,maxAr,avAr,stdAr;
+	float minAn,maxAn,avAn,stdAn;
+	int minEi,maxEi,stdEi;
+	int minAri,maxAri,stdAri;
+	int minAni,maxAni,stdAni;
+
+	StatEdge<CMeshO>(*mesh,minE,maxE,avE,stdE);
+	StatArea<CMeshO>(*mesh,minAr,maxAr,avAr,stdAr);
+	StatAngle<CMeshO>(*mesh,minAn,maxAn,avAn,stdAn);
+	minE/=avE;
+	minE*=100.f;
+	maxE/=avE;
+	maxE*=100.f;
+	stdE/=avE;
+	stdE*=100.f;
+
+	minAn/=avAn;
+	minAn*=100.f;
+	maxAn/=avAn;
+	maxAn*=100.f;
+	stdAn/=avAn;
+	stdAn*=100.f;
+
+	minAr/=avAr;
+	minAr*=100.f;
+	maxAr/=avAr;
+	maxAr*=100.f;
+	stdAr/=avAr;
+	stdAr*=100.f;
+
+	minEi=(int)minE;
+	maxEi=(int)maxE;
+	stdEi=(int)stdE;
+
+	minAni=(int)minAn;
+	maxAni=(int)maxAn;
+	stdAni=(int)stdAn;
+
+	minAri=(int)minAr;
+	maxAri=(int)maxAr;
+	stdAri=(int)stdAr;
+
+	Log(" REMESHED ");
+	Log("Irregular Vertices:%d ",non_reg);
+	Log("stdDev Area:%d",stdAri);
+	Log("stdDev Angle:%d",stdAni);
+	Log("stdDev Edge:%d",stdEi);
+}
+
+bool FilterIsoParametrization::applyFilter(QAction *filter, MeshDocument& md, RichParameterSet & par, vcg::CallBackPos  *cb)
+{
+	MeshModel* m = md.mm();  //get current mesh from document
+	CMeshO *mesh=&m->cm;
+	switch(ID(filter))
+	{
+	case ISOP_PARAM :
+		{
+			int targetAbstractMinFaceNum = par.getInt("targetAbstractMinFaceNum");
+			int targetAbstractMaxFaceNum = par.getInt("targetAbstractMaxFaceNum");
+			int convergenceSpeed = par.getInt("convergenceSpeed");
+			int stopCriteria=par.getEnum("stopCriteria");
+			bool doublestep=par.getBool("DoubleStep");
+			IsoParametrizator Parametrizator;
+
+			m->updateDataMask(MeshModel::MM_FACEFACETOPO);
+      m->updateDataMask(MeshModel::MM_VERTQUALITY); // needed to store patch index
+
+			bool isTXTenabled=m->hasDataMask(MeshModel::MM_VERTTEXCOORD);
+			if (!isTXTenabled)
+				m->updateDataMask(MeshModel::MM_VERTTEXCOORD);
+
+			bool isVMarkenabled=m->hasDataMask(MeshModel::MM_VERTMARK);
+			if (!isVMarkenabled)
+				m->updateDataMask(MeshModel::MM_VERTMARK);
+
+			bool isFMarkenabled=m->hasDataMask(MeshModel::MM_FACEMARK);
+			if (!isFMarkenabled)
+				m->updateDataMask(MeshModel::MM_FACEMARK);
+
+			bool isVColorenabled=m->hasDataMask(MeshModel::MM_VERTCOLOR);
+			if (!isVColorenabled)
+				m->updateDataMask(MeshModel::MM_VERTCOLOR);
+
+			bool isFColorenabled=m->hasDataMask(MeshModel::MM_FACECOLOR);
+			if (!isFColorenabled)
+				m->updateDataMask(MeshModel::MM_FACECOLOR);
+			int tolerance = targetAbstractMaxFaceNum-targetAbstractMinFaceNum;
+			switch (stopCriteria)
+			{
+			case 0:Parametrizator.SetParameters(cb,targetAbstractMinFaceNum,tolerance,IsoParametrizator::SM_Euristic,convergenceSpeed);break;
+			case 1:Parametrizator.SetParameters(cb,targetAbstractMinFaceNum,tolerance,IsoParametrizator::SM_Corr,convergenceSpeed);break;
+			case 2:Parametrizator.SetParameters(cb,targetAbstractMinFaceNum,tolerance,IsoParametrizator::SM_Reg,convergenceSpeed);break;
+			case 3:Parametrizator.SetParameters(cb,targetAbstractMinFaceNum,tolerance,IsoParametrizator::SM_L2,convergenceSpeed);break;
+			default:Parametrizator.SetParameters(cb,targetAbstractMinFaceNum,tolerance,IsoParametrizator::SM_Euristic,convergenceSpeed);break;
+			}
+			IsoParametrizator::ReturnCode ret=Parametrizator.Parametrize<CMeshO>(mesh,doublestep);
+
+			if (ret==IsoParametrizator::Done)
+			{
+				Parametrizator.PrintAttributes();
+				float aggregate,L2;
+				int n_faces;
+				Parametrizator.getValues(aggregate,L2,n_faces);
+				Log("Num Faces of Abstract Domain: %d, One way stretch efficiency: %.4f, Area+Angle Distorsion %.4f  ",n_faces,L2,aggregate*100.f);
+			}
+			else
+			{
+        if (!isTXTenabled)    m->clearDataMask(MeshModel::MM_VERTTEXCOORD);
+        if (!isFMarkenabled)  m->clearDataMask(MeshModel::MM_FACEMARK);
+        if (!isVMarkenabled)  m->clearDataMask(MeshModel::MM_VERTMARK);
+        if (!isVColorenabled) m->clearDataMask(MeshModel::MM_VERTCOLOR);
+        if (!isFColorenabled) m->clearDataMask(MeshModel::MM_FACECOLOR);
+        switch(ret)
+        {
+        case IsoParametrizator::MultiComponent:
+          this->errorMessage="non possible parameterization because of multi componet mesh"; return false;
+        case IsoParametrizator::NonSizeCons:
+          this->errorMessage="non possible parameterization because of non size consistent mesh"; return false;
+        case IsoParametrizator::NonManifoldE:
+          this->errorMessage="non possible parameterization because of non manifold edges"; return false;
+        case IsoParametrizator::NonManifoldV:
+          this->errorMessage="non possible parameterization because of non manifold vertices";return false;
+        case IsoParametrizator::NonWatertigh:
+          this->errorMessage="non possible parameterization because of non watertight mesh"; return false;
+        case IsoParametrizator::FailParam:
+          this->errorMessage="non possible parameterization cause one of the following reasons:\n Topologycal noise \n Too Low resolution mesh \n Too Bad triangulation \n"; return false;
+        default:
+          this->errorMessage="unknown error"; return false;
+        }
+			}
+      // At this point we are sure that everithing went ok so we can allocate surely the abstract
+      AbstractMesh *abs_mesh = new AbstractMesh();
+      ParamMesh *para_mesh = new ParamMesh();
+      Parametrizator.ExportMeshes(*para_mesh,*abs_mesh);
+      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle;
+      isoPHandle=tri::Allocator<CMeshO>::AddPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
+
+      bool isOK=isoPHandle().Init(abs_mesh,para_mesh);
+
+			///copy back to original mesh
+			isoPHandle().CopyParametrization<CMeshO>(mesh);
+
+			if (!isOK)
+			{
+        this->errorMessage="Problems gathering parameterization \n";
+				return false;
+			}
+			if (!isVMarkenabled)
+				m->clearDataMask(MeshModel::MM_VERTMARK);
+			if (!isFMarkenabled)
+				m->clearDataMask(MeshModel::MM_FACEMARK);
+			return true;
+		}
+	case ISOP_REMESHING :
+		{
+      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle =
+          tri::Allocator<CMeshO>::GetPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
+
+      bool b=tri::Allocator<CMeshO>::IsValidHandle<IsoParametrization>(*mesh,isoPHandle);
+			if (!b)
+			{
+				this->errorMessage="You must compute the Base domain before remeshing. Use the Isoparametrization command.";
+				return false;
+			}
+			
+
+			int SamplingRate=par.getInt("SamplingRate");
+			if (!SamplingRate>2)
+			{
+				this->errorMessage="Sampling rate must be >1";
+				return false;
+			}
+      MeshModel* mm=md.addNewMesh("","Re-meshed");
+
+			CMeshO *rem=&mm->cm;
+      DiamSampler DiamSampl;
+			DiamSampl.Init(&isoPHandle());
+			bool done=DiamSampl.SamplePos(SamplingRate);
+			assert(done);
+			DiamSampl.GetMesh<CMeshO>(*rem);
+
+			int n_diamonds,inFace,inEdge,inStar,n_merged;
+			DiamSampl.getResData(n_diamonds,inFace,inEdge,inStar,n_merged);
+
+			Log("INTERPOLATION DOMAINS");
+			Log("In Face: %d \n",inFace);
+			Log("In Diamond: %d \n",inEdge);
+			Log("In Star: %d \n",inStar);
+			Log("Merged %d vertices\n",n_merged);
+			mm->updateDataMask(MeshModel::MM_FACEFACETOPO);
+			mm->updateDataMask(MeshModel::MM_VERTFACETOPO);
+			PrintStats(rem);
+      tri::UpdateNormals<CMeshO>::PerFace(*rem);
+			return true;
+		}
+	case ISOP_DIAMPARAM :
+		{
+      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle =
+          tri::Allocator<CMeshO>::GetPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
+      bool b=tri::Allocator<CMeshO>::IsValidHandle<IsoParametrization>(*mesh,isoPHandle);
+			if (!b)
+			{
+				this->errorMessage="You must compute the Base domain before remeshing. Use the Isoparametrization command.";
+				return false;
+			}
+
+			float border_size=par.getDynamicFloat("BorderSize");
+      MeshModel* mm=md.addNewMesh("","Diam-Parameterized");
+			mm->updateDataMask(MeshModel::MM_WEDGTEXCOORD);
+			mm->updateDataMask(MeshModel::MM_VERTCOLOR);
+			CMeshO *rem=&mm->cm;
+			DiamondParametrizator DiaPara;
+			DiaPara.Init(&isoPHandle());
+			DiaPara.SetCoordinates<CMeshO>(*rem,border_size);
+      tri::UpdateNormals<CMeshO>::PerFace(*rem);
+			return true;
+		}
+	case ISOP_LOAD : 
+		{
+			QString AbsName = par.getString("AbsName");
+			m->updateDataMask(MeshModel::MM_WEDGTEXCOORD);
+			m->updateDataMask(MeshModel::MM_VERTTEXCOORD);
+			m->updateDataMask(MeshModel::MM_FACECOLOR);
+			m->updateDataMask(MeshModel::MM_VERTQUALITY);
+			m->updateDataMask(MeshModel::MM_FACEMARK);
+			if(!QFile(m->fullName()).exists())
+			{
+				this->errorMessage="File not exists";
+				return false;
+			}
+      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle =
+          tri::Allocator<CMeshO>::GetPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
+
+      bool b=tri::Allocator<CMeshO>::IsValidHandle<IsoParametrization>(*mesh,isoPHandle);
+			if (!b)
+        isoPHandle=tri::Allocator<CMeshO>::AddPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
+
+			QByteArray ba = AbsName.toLatin1();
+			char *path=ba.data();
+      AbstractMesh *abs_mesh = new AbstractMesh();
+      ParamMesh *para_mesh = new ParamMesh();
+      bool Done=isoPHandle().LoadBaseDomain<CMeshO>(path,mesh,para_mesh,abs_mesh,true);
+			if (!Done)
+			{
+				this->errorMessage="Abstract domain doesnt fit well with the parametrized mesh";
+        delete para_mesh;
+        delete abs_mesh;
+				return false;
+			}
+			return true;
+		}
+	case ISOP_SAVE : 
+		{
+			m->updateDataMask(MeshModel::MM_VERTQUALITY);
+      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle =
+          tri::Allocator<CMeshO>::GetPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
+
+      bool b=tri::Allocator<CMeshO>::IsValidHandle<IsoParametrization>(*mesh,isoPHandle);
+			if (!b)
+			{
+				this->errorMessage="You must compute the Base domain before remeshing. Use the Isoparametrization command.";
+				return false;
+			}
+			/*QString Qpath=m->fullName();*/
+
+			QString AbsName = par.getString("AbsName");
+
+			QByteArray ba = AbsName.toLatin1();
+			char *path=ba.data();
+			isoPHandle().SaveBaseDomain(path);
+			return true;
+		}
+	case ISOP_TRANSFER:
+		{
+      MeshModel *mmtrg = par.getMesh("targetMesh");
+      MeshModel *mmsrc = par.getMesh("targetMesh");
+      CMeshO *trgMesh=&mmtrg->cm;
+      CMeshO *srcMesh=&mmsrc->cm;
+
+      CMeshO::PerMeshAttributeHandle<IsoParametrization> isoPHandle =
+          tri::Allocator<CMeshO>::GetPerMeshAttribute<IsoParametrization>(*mesh,"isoparametrization");
+
+      bool b=tri::Allocator<CMeshO>::IsValidHandle<IsoParametrization>(*srcMesh,isoPHandle);
+			if (!b)
+			{
+        this->errorMessage="Your source mesh must have the abstract isoparametrization. Use the Isoparametrization command.";
+				return false;
+			}
+			IsoTransfer IsoTr;
+      AbstractMesh *abs_mesh = isoPHandle().AbsMesh();
+      ParamMesh *para_mesh = isoPHandle().ParaMesh();
+
+      mmtrg->updateDataMask(MeshModel::MM_WEDGTEXCOORD);
+      mmtrg->updateDataMask(MeshModel::MM_VERTTEXCOORD);
+      mmtrg->updateDataMask(MeshModel::MM_FACECOLOR);
+      mmtrg->updateDataMask(MeshModel::MM_VERTQUALITY);
+      mmtrg->updateDataMask(MeshModel::MM_FACEMARK);
+      IsoTr.Transfer<CMeshO>(isoPHandle(),*trgMesh);
+			
+			isoPHandle().Clear();
+      tri::Allocator<CMeshO>::DeletePerMeshAttribute(*srcMesh,isoPHandle);
+			
+      isoPHandle=tri::Allocator<CMeshO>::AddPerMeshAttribute<IsoParametrization>(*trgMesh,"isoparametrization");
+      isoPHandle().AbsMesh()=abs_mesh;
+      isoPHandle().SetParamMesh<CMeshO>(trgMesh,para_mesh);
+			
+			return true;
+		}
+	}
+	return false;
+}
+
+MeshFilterInterface::FilterClass FilterIsoParametrization::getClass(QAction *a)
+{
+	switch(ID(a))
+	{
+	case ISOP_PARAM : return MeshFilterInterface::Remeshing;
+	case ISOP_REMESHING : return MeshFilterInterface::Remeshing;
+	case ISOP_DIAMPARAM : return MeshFilterInterface::Remeshing;
+	default: return MeshFilterInterface::Remeshing;
+	}
+}
+
+int FilterIsoParametrization::postCondition( QAction* /*filter*/ ) const
+{
+	return MeshModel::MM_UNKNOWN;
+}
+
+Q_EXPORT_PLUGIN(FilterIsoParametrization)
diff --git a/src/meshlabplugins/filter_isoparametrization/iso_parametrization.h b/src/meshlabplugins/filter_isoparametrization/iso_parametrization.h
index 48683ec24..bd6707c78 100644
--- a/src/meshlabplugins/filter_isoparametrization/iso_parametrization.h
+++ b/src/meshlabplugins/filter_isoparametrization/iso_parametrization.h
@@ -1,2015 +1,2015 @@
-#ifndef TRI_PARAMETRIZATION
-#define TRI_PARAMETRIZATION	
-
-// stuff to define the mesh
- #include <wrap/io_trimesh/export_ply.h>
-#include <wrap/io_trimesh/import_ply.h>
-#include <vcg/space/triangle3.h>
-#include <vcg/simplex/face/component_rt.h>
-#include <vcg/complex/trimesh/base.h>
-#include "local_parametrization.h"
-#include "uv_grid.h"
-#include <vcg/complex/trimesh/stat.h>
-#include "param_mesh.h"
-
-///ABSTRACT MESH THAT MAINTAINS THE WHOLE PARAMETERIZATION
-class AbstractVertex;
-class AbstractFace;
-
-class AbstractUsedTypes: public vcg::UsedTypes < vcg::Use<AbstractVertex>::AsVertexType,
-                                          vcg::Use<AbstractFace  >::AsFaceType >{};
-
-
-class AbstractVertex  : public vcg::Vertex< AbstractUsedTypes,
-	vcg::vertex::VFAdj, 
-	vcg::vertex::Coord3f,
-	vcg::vertex::TexCoord2f,
-	vcg::vertex::BitFlags>
-  //vcg::face::Normal3f>
-{
-public:
-	CoordType RPos;
-
-  template < class LeftV>
-	void ImportData(const LeftV  & left )
-  {
-			vcg::Vertex< AbstractUsedTypes, vcg::vertex::VFAdj, vcg::vertex::Coord3f,vcg::vertex::TexCoord2f,vcg::vertex::BitFlags>::ImportData( left);
-      this->RPos = left.RPos;
-  }
-};
-
-class AbstractFace    : public vcg::Face  < AbstractUsedTypes,
-	vcg::face::VFAdj, 
-	vcg::face::FFAdj,
-	vcg::face::VertexRef,
-	vcg::face::Color4b,
-	vcg::face::BitFlags>
-//vcg::face::Normal3f>
-{};
-
-class AbstractMesh: public vcg::tri::TriMesh<std::vector<AbstractVertex>, std::vector<AbstractFace> > {
-//public:
-//	static const bool Has_Auxiliary(){return false;}
-};
-
-///HIGH RESOLUTION MESH THAT HAS TO BE PARAMETERIZED
-class ParamVertex;
-class ParamFace;
-
-
-class ParamUsedTypes: public vcg::UsedTypes < vcg::Use<ParamVertex>::AsVertexType,
-                                          vcg::Use<ParamFace  >::AsFaceType >{};
-
-
-class ParamVertex: public vcg::Vertex< ParamUsedTypes,
-											vcg::vertex::Normal3f, vcg::vertex::VFAdj, 
-											vcg::vertex::Coord3f,vcg::vertex::Color4b,
-											vcg::vertex::TexCoord2f,vcg::vertex::BitFlags,
-											vcg::vertex::CurvatureDirf,
-											vcg::vertex::Qualityf>
-{
-public:
-    template < class LeftV>
-		void ImportData(const LeftV  & left )
-    {
-				vcg::Vertex< ParamUsedTypes, vcg::vertex::Normal3f, vcg::vertex::VFAdj, vcg::vertex::Coord3f,vcg::vertex::Color4b, vcg::vertex::TexCoord2f,vcg::vertex::BitFlags, vcg::vertex::CurvatureDirf,vcg::vertex::Qualityf >::ImportData( left);
-    }
-	
-	
-		void ImportData(const ParamVertex  & left )
-    {
-				vcg::Vertex< ParamUsedTypes, vcg::vertex::Normal3f, vcg::vertex::VFAdj, vcg::vertex::Coord3f,vcg::vertex::Color4b, vcg::vertex::TexCoord2f,vcg::vertex::BitFlags, vcg::vertex::CurvatureDirf,vcg::vertex::Qualityf >::ImportData( left);
-        this->RPos = left.RPos;
-    }
-	
-	void ImportData(const BaseVertex  & left )
-    {
-				vcg::Vertex< ParamUsedTypes, vcg::vertex::Normal3f, vcg::vertex::VFAdj, vcg::vertex::Coord3f,vcg::vertex::Color4b, vcg::vertex::TexCoord2f,vcg::vertex::BitFlags, vcg::vertex::CurvatureDirf,vcg::vertex::Qualityf >::ImportData( left);
-        this->RPos = left.RPos;
-    }
-
-	CoordType RPos;
-	static const bool Has_Auxiliary(){return false;}
-};
-
-class ParamFace: public vcg::Face <  ParamUsedTypes,
-	vcg::face::VFAdj,vcg::face::FFAdj,vcg::face::VertexRef,
-  vcg::face::Color4b,vcg::face::BitFlags,
-  vcg::face::Normal3f,
-	vcg::face::WedgeTexCoord2f,
-	vcg::face::Mark,
-	vcg::face::EdgePlane
-  //,
-  //vcg::face::Qualityf // not really needed
-  >
-{
-public:
-	/*template < class LeftV>
-		void ImportData(const LeftV  & left )
-    {
-       vcg::FaceSimp2  <  ParamVertex, ParamEdge, ParamFace, 
-	vcg::face::VFAdj,vcg::face::FFAdj,vcg::face::VertexRef,
-  vcg::face::Color4b,vcg::face::BitFlags,
-  vcg::face::WedgeTexCoord2f,vcg::face::Normal3f,
-	vcg::face::Qualityf>::ImportData( left);
-    }*/
-};
-class ParamMesh: public vcg::tri::TriMesh<std::vector<ParamVertex>, std::vector<ParamFace> > 
-{
-//public:
-	//static const bool Has_Auxiliary(){return false;}
-};
-
-template <class MeshType>
-void CopyMeshFromFacesAbs(const std::vector<typename MeshType::FaceType*> &faces,
-						  std::vector<typename MeshType::VertexType*> &orderedVertex,
-						  MeshType & new_mesh)
-{
-	typedef typename MeshType::CoordType CoordType;
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::VertexType VertexType;
-	typedef typename MeshType::FaceType FaceType;
-
-	///get set of faces
-	std::map<VertexType*,VertexType*> vertexmap;
-        std::vector<VertexType*> vertices;
-	FindVertices(faces,vertices);
-
-	///initialization of new mesh
-	new_mesh.Clear();
-	new_mesh.vn=0;
-	new_mesh.fn=0;
-	new_mesh.face.resize(faces.size());
-	new_mesh.vert.resize(vertices.size());
-	new_mesh.vn=vertices.size();
-	new_mesh.fn=faces.size();
-
-	///add new vertices
-        typename std::vector<VertexType*>::const_iterator iteV;
-	int i=0;
-	for (iteV=vertices.begin();iteV!=vertices.end();iteV++)
-	{
-		///copy position
-		assert(!(*iteV)->IsD());
-		new_mesh.vert[i].P()=(*iteV)->P();
-		new_mesh.vert[i].RPos=(*iteV)->RPos;
-		new_mesh.vert[i].T().P()=(*iteV)->T().P();
-		new_mesh.vert[i].T().N()=(*iteV)->T().N();
-		//new_mesh.vert[i].N()=(*iteV)->N();
-		///*assert(new_mesh.vert[i].brother!=NULL);*/
-		////if (MeshType::Has_Auxiliary())
-		//new_mesh.vert[i].brother=(*iteV)->brother;
-		new_mesh.vert[i].ClearFlags();
-		
-		orderedVertex.push_back((*iteV));
-		vertexmap.insert(std::pair<VertexType*,VertexType*>((*iteV),&new_mesh.vert[i]));
-		i++;
-	}
-
-	///setting of new faces
-        typename std::vector<FaceType*>::const_iterator iteF;
-        typename std::vector<FaceType>::iterator iteF1;
-	for (iteF=faces.begin(),iteF1=new_mesh.face.begin()
-		;iteF!=faces.end();iteF++,iteF1++)
-	{
-		//(*iteF1).areadelta=(*iteF)->areadelta;
-	/*	if ((*iteF1).areadelta>1)
-			assert(0);*/
-		///for each vertex get new reference
-		///and associate face-vertex
-		for (int j=0;j<3;j++)
-		{
-			VertexType* v=(*iteF)->V(j);
-                        typename std::map<VertexType*,VertexType*>::iterator iteMap=vertexmap.find(v);
-			assert(iteMap!=vertexmap.end());
-			(*iteF1).V(j)=(*iteMap).second;
-		}
-	}
-}
-
-///create a mesh considering just the faces that share all three vertex
-template <class MeshType>
-void CopyMeshFromVerticesAbs(std::vector<typename MeshType::VertexType*> &vertices,
-						  std::vector<typename MeshType::VertexType*> &OrderedVertices,
-						  std::vector<typename MeshType::FaceType*> &OrderedFaces,
-					      MeshType & new_mesh)
-{
-        typedef typename MeshType::CoordType CoordType;
-        typedef typename MeshType::ScalarType ScalarType;
-        typedef typename MeshType::VertexType VertexType;
-        typedef typename MeshType::FaceType FaceType;
-
-        typename std::vector<VertexType*>::const_iterator iteV;
-	for (iteV=vertices.begin();iteV!=vertices.end();iteV++)
-		(*iteV)->ClearV();
-
-
-
-	OrderedVertices.clear();
-
-	///vertex-vertex reference
-	std::map<VertexType*,VertexType*> vertexmap;
-
-	///get set of faces
-	std::vector<typename MeshType::FaceType*> faces;
-
-	getSharedFace<MeshType>(vertices,faces);
-	
-	///initialization of new mesh
-	new_mesh.Clear();
-	new_mesh.vn=0;
-	new_mesh.fn=0;
-
-	///set vertices as selected
-	
-	for (iteV=vertices.begin();iteV!=vertices.end();iteV++)
-		(*iteV)->SetV();
-
-	///getting inside faces
-        typename std::vector<FaceType*>::const_iterator iteF;
-	for (iteF=faces.begin();iteF!=faces.end();iteF++)
-	{
-		///for each vertex get new reference
-		///if there isn't one reference means the face does not appartain to group
-		VertexType* v0=(*iteF)->V(0);
-		VertexType* v1=(*iteF)->V(1);
-		VertexType* v2=(*iteF)->V(2);
-		bool inside=((*v0).IsV()&&(*v1).IsV()&&(*v2).IsV());
-		if (inside)
-			OrderedFaces.push_back((*iteF));
-	}
-	
-	///find internal vertices
-	FindVertices(OrderedFaces,OrderedVertices);
-
-	///setting size
-	new_mesh.face.resize(OrderedFaces.size());
-	new_mesh.vert.resize(OrderedVertices.size());
-	new_mesh.vn=OrderedVertices.size();
-	new_mesh.fn=OrderedFaces.size();
-
-	///setting of internal vertices
-	int i=0;
-        typename std::vector<typename MeshType::VertexType*>::iterator iteVI;
-	for (iteVI=OrderedVertices.begin();iteVI!=OrderedVertices.end();iteVI++)
-	{
-		///copy position
-		assert(!(*iteVI)->IsD());
-		new_mesh.vert[i].P()=(*iteVI)->P();
-		new_mesh.vert[i].RPos=(*iteVI)->RPos;
-		new_mesh.vert[i].T().P()=(*iteVI)->T().P();
-		new_mesh.vert[i].T().N()=(*iteVI)->T().N();
-		new_mesh.vert[i].C()=(*iteVI)->C();
-		/*new_mesh.vert[i].father=(*iteVI)->father;
-		new_mesh.vert[i].Bary=(*iteVI)->Bary;*/
-		//new_mesh.vert[i].Damp=(*iteVI)->Damp;
-		/*new_mesh.vert[i].RestUV=(*iteVI)->RestUV;*/
-		//new_mesh.vert[i].N()=(*iteVI)->N();
-		//new_mesh.vert[i].C()=(*iteVI)->C();
-		/*new_mesh.vert[i].OriginalCol=(*iteVI)->OriginalCol;*/
-		new_mesh.vert[i].ClearFlags();
-		///map setting
-		vertexmap.insert(std::pair<VertexType*,VertexType*>((*iteVI),&new_mesh.vert[i]));
-		i++;
-	}
-
-	///setting of new faces
-        typename std::vector<FaceType>::iterator iteF1;
-	for (iteF=OrderedFaces.begin(),iteF1=new_mesh.face.begin()
-		;iteF!=OrderedFaces.end();iteF++,iteF1++)
-	{
-		///for each vertex get new reference
-		///and associate face-vertex
-		for (int j=0;j<3;j++)
-		{
-			VertexType* v=(*iteF)->V(j);
-                        typename std::map<VertexType*,VertexType*>::iterator iteMap=vertexmap.find(v);
-			assert(iteMap!=vertexmap.end());
-			(*iteF1).V(j)=(*iteMap).second;
-		}
-	}
-
-	///clear flags
-	for (iteV=vertices.begin();iteV!=vertices.end();iteV++)
-		(*iteV)->ClearV();
-
-}
-
-
-
-
-//template <class InputMesh>
-//static int Parametrize(InputMesh &to_param,
-//					   AbstractMesh &AbsMesh,
-//					   InputMesh &Parametrized,
-//					   int &approx_face_num)
-//{
-//	vcg::tri::UpdateTopology<InputMesh>::FaceFace(to_param);
-//
-//	///test input conditions
-//	bool b=vcg::tri::Clean<InputMesh>::IsTwoManifoldFace(to_param);
-//	b&=vcg::tri::Clean<InputMesh>::IsTwoManifoldVertexFF(to_param);
-//	int n=vcg::tri::Clean<InputMesh>::BorderEdges(to_param);
-//	b&=(n==0);
-//	int num=vcg::tri::Clean<InputMesh>::ConnectedComponents(to_param);
-//	b&=(num==1);
-//	if (!b)
-//		return -1;
-//
-//	///then parameteterize
-//	IsoParametrizator TrImage;
-//	TrImage.Parametrize<MyMesh>(&mesh,num1,num2);
-//	TrImage.ExportMeshes(to_param,AbsMesh);
-//	return 0;
-//}
-
-///class that maintains the whole meh parametrerization with relitive operators
-class IsoParametrization
-{
-	AbstractMesh * abstract_mesh;
-	ParamMesh	 * param_mesh;
-
-public:
-	typedef ParamMesh::ScalarType ScalarType;
-	typedef ParamMesh::CoordType CoordType;
-
-private:
-
-	///this class maintains submeshes and hresolution meshes
-	///for the selected parametrization domain
-	struct param_domain{
-		AbstractMesh *domain;
-		std::vector<int> local_to_global;
-
-		ParamMesh *HresDomain;
-		UVGrid<ParamMesh> grid;
-		std::vector<ParamFace*> ordered_faces;
-
-		int Local2Global(const int &localFace)
-		{return local_to_global[localFace];}
-
-		int Global2Local(const int &GlobalFace)
-		{
-			int ret=-1;
-			for (unsigned int i=0;i<local_to_global.size();i++)
-				if (local_to_global[i]==GlobalFace)
-					return i;
-			return ret;
-		}
-
-		void InitGrid()
-		{grid.Init(*HresDomain);}
-
-		bool Project(vcg::Point2<ScalarType> UV,
-					std::vector<ParamFace*> &face,
-					std::vector<CoordType> &baryVal)
-		{
-			std::vector<ParamFace*> faceParam;
-			bool found=grid.ProjectPoint(UV,faceParam,baryVal);
-			if (!found)
-				return false;
-			///calculate the index corresponding to the face
-			for (unsigned int i=0;i<faceParam.size();i++)
-			{
-				ParamFace* f=faceParam[i];
-				int index=f-&(*HresDomain->face.begin());
-				assert(index<HresDomain->fn);
-				face.push_back(ordered_faces[index]);
-			}
-			return true;
-		}
-
-		bool getClosest(vcg::Point2<ScalarType> UV,
-						std::vector<ParamFace*> &face,
-						std::vector<CoordType> &baryVal)
-		{
-			face.resize(1);
-			baryVal.resize(1);
-			bool found=grid.getClosest(UV,face[0],baryVal[0]);
-			int index=face[0]-&(*HresDomain->face.begin());
-			assert(index<HresDomain->fn);
-			face[0]=ordered_faces[index];
-			return found;
-		}
-	};
-
-	///summeshes and subdomains
-	std::vector<param_domain> star_meshes;
-	std::vector<param_domain> diamond_meshes;
-	std::vector<param_domain> face_meshes;
-
-	typedef std::pair<AbstractVertex*,AbstractVertex*> keyEdgeType;
-	std::map<keyEdgeType,int> EdgeTab;
-
-	///temporary structure for face_to_vert adjacency
-	std::vector<std::vector<ParamVertex*> > face_to_vert;
-
-	void InitFaceToVert()
-	{
-		face_to_vert.resize(abstract_mesh->face.size());
-		for (unsigned int i=0;i<param_mesh->vert.size();i++)
-		{
-			int I=param_mesh->vert[i].T().N();
-			face_to_vert[I].push_back(&param_mesh->vert[i]);
-		}
-	}
-
-
-	void GetHresVert(int &I,std::vector<ParamVertex*> &HresVert)
-	{
-		for (unsigned int k=0;k<face_to_vert[I].size();k++)
-		{
-			ParamVertex* v=face_to_vert[I][k];
-			HresVert.push_back(v);
-		}
-	}
-
-	///initialize star parametrization
-	void InitStar()
-	{
-		///for each vertex
-		int index=0;
-		for (unsigned int i=0;i<abstract_mesh->vert.size();i++)
-		{
-			if (!(abstract_mesh->vert[i].IsD()))
-			{
-				std::vector<AbstractVertex*> starCenter;
-				starCenter.push_back(&abstract_mesh->vert[i]);
-
-				star_meshes[index].domain=new AbstractMesh();
-				star_meshes[index].HresDomain=new ParamMesh();
-
-				///create star
-				std::vector<AbstractFace*> ordered_faces;
-				std::vector<AbstractVertex*> ordered_vert;
-				//CreateMeshVertexStar(starCenter,ordered_faces,*star_meshes[index].domain);
-				///get faces referenced by vertices
-				getSharedFace<AbstractMesh>(starCenter,ordered_faces);
-				
-				CopyMeshFromFacesAbs<AbstractMesh>(ordered_faces,ordered_vert,*star_meshes[index].domain);
-
-				UpdateTopologies(star_meshes[index].domain);
-
-				///and parametrize it
-				ParametrizeStarEquilateral<AbstractMesh>(*star_meshes[index].domain,1.0);
-				
-				///set other components as reefrence to original faces
-				star_meshes[index].local_to_global.resize(star_meshes[index].domain->face.size());
-				std::vector<ParamVertex*> HresVert;
-				for (unsigned int k=0;k<star_meshes[index].domain->face.size();k++)
-				{
-					int IndexF;
-					getFaceIndexFromPointer(ordered_faces[k],IndexF);
-					star_meshes[index].local_to_global[k]=IndexF;
-					///get H res vertex
-					GetHresVert(IndexF,HresVert);
-				}
-				
-				///copy Hres mesh
-				std::vector<ParamVertex*> OrderedVertices;
-				CopyMeshFromVerticesAbs(HresVert,OrderedVertices,star_meshes[index].ordered_faces,*star_meshes[index].HresDomain);
-				///set new parametrization values
-				for (unsigned int k=0;k<star_meshes[index].HresDomain->vert.size();k++)
-				{
-					ParamVertex * v=&star_meshes[index].HresDomain->vert[k];
-					CoordType bary=CoordType(v->T().U(),v->T().V(),1-v->T().U()-v->T().V());
-					AbstractMesh *paramDomain=star_meshes[index].domain;
-					///get the right face on the parametrized domain
-					int Father=v->T().N();
-					int faceNum=-1;
-					for (unsigned int i=0;i<star_meshes[index].local_to_global.size();i++)
-					{
-						if (star_meshes[index].local_to_global[i]==Father)
-							faceNum=i;
-					}
-					AbstractFace *faceDom=&paramDomain->face[faceNum];
-					v->T().P()=(faceDom->V(0)->T().P())*bary.X()+(faceDom->V(1)->T().P())*bary.Y()+(faceDom->V(2)->T().P())*bary.Z();
-					assert(faceNum!=-1);
-				}
-				star_meshes[index].InitGrid();
-				index++;
-				
-			}
-		}		
-	}
-
-
-
-	void InitDiamond(const ScalarType &edge_len=1.0)
-	{
-		
-		///for each face
-		int index=0;
-		EdgeTab.clear();
-		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
-		{
-			if (!(abstract_mesh->face[i].IsD()))
-			{
-				AbstractFace *f0=&abstract_mesh->face[i];
-				//for each edge
-				for (int j=0;j<3;j++)
-				{
-					AbstractFace * f1=f0->FFp(j);
-					if (f1>f0)
-					{
-						
-						int num0=j;
-						int num1=f0->FFi(j);
-
-						///add to domain map
-						AbstractVertex *v0,*v1;
-						v0=f0->V(j);
-						v1=f0->V1(j);
-						keyEdgeType k;
-						if (v0<v1)
-							k=keyEdgeType(v0,v1);
-						else
-							k=keyEdgeType(v1,v0);
-
-						std::pair<keyEdgeType,int> entry=std::pair<keyEdgeType,int>(k,index);
-						EdgeTab.insert(entry);
-
-
-
-						///copy the mesh
-						std::vector<AbstractFace*> faces;
-						faces.push_back(f0);
-						faces.push_back(f1);
-
-						diamond_meshes[index].domain=new AbstractMesh();
-						diamond_meshes[index].HresDomain=new ParamMesh();
-
-						///create a copy of the mesh
-						std::vector<AbstractVertex*> orderedVertex;
-						CopyMeshFromFacesAbs<AbstractMesh>(faces,orderedVertex,*diamond_meshes[index].domain);
-						UpdateTopologies<AbstractMesh>(diamond_meshes[index].domain);
-
-						///set other components
-						int index0,index1;
-						getFaceIndexFromPointer(f0,index0);
-						getFaceIndexFromPointer(f1,index1);
-						diamond_meshes[index].local_to_global.resize(2);
-						diamond_meshes[index].local_to_global[0]=index0;
-						diamond_meshes[index].local_to_global[1]=index1;
-
-						///parametrize locally
-						ParametrizeDiamondEquilateral<AbstractMesh>(*diamond_meshes[index].domain,num0,num1,edge_len);
-						///add h resolution vertices 
-						std::vector<ParamVertex*> HresVert;
-						GetHresVert(index0,HresVert);
-						GetHresVert(index1,HresVert);
-						std::vector<ParamVertex*> OrderedVertices;
-						CopyMeshFromVerticesAbs(HresVert,OrderedVertices,diamond_meshes[index].ordered_faces,*diamond_meshes[index].HresDomain);
-						///set new parametrization values
-						for (unsigned int k=0;k<diamond_meshes[index].HresDomain->vert.size();k++)
-						{
-							ParamVertex * v=&diamond_meshes[index].HresDomain->vert[k];
-							CoordType bary=CoordType(v->T().U(),v->T().V(),1-v->T().U()-v->T().V());
-							AbstractMesh *paramDomain=diamond_meshes[index].domain;
-							///get the rigth face on the parametrized domain
-							int Father=v->T().N();
-							int faceNum=-1;
-							for (unsigned int i=0;i<diamond_meshes[index].local_to_global.size();i++)
-							{
-								if (diamond_meshes[index].local_to_global[i]==Father)
-									faceNum=i;
-							}
-							assert(faceNum!=-1);
-							AbstractFace *faceDom=&paramDomain->face[faceNum];
-							v->T().P()=(faceDom->V(0)->T().P())*bary.X()+(faceDom->V(1)->T().P())*bary.Y()+(faceDom->V(2)->T().P())*bary.Z();
-							
-							
-						}
-						diamond_meshes[index].InitGrid();
-						index++;
-					}
-				}
-			}
-		}
-	}
-
-
-	void InitFace(const ScalarType &edge_len=1)
-	{
-		///for each face
-		int index=0;
-		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
-		{
-			if (!(abstract_mesh->face[i].IsD()))
-			{
-				AbstractFace *f0=&abstract_mesh->face[i];
-
-				std::vector<AbstractFace*> faces;
-				faces.push_back(f0);
-
-				///create the mesh
-				face_meshes[index].domain=new AbstractMesh();
-				face_meshes[index].HresDomain=new ParamMesh();
-
-				std::vector<AbstractVertex*> orderedVertex;
-				CopyMeshFromFacesAbs<AbstractMesh>(faces,orderedVertex,*face_meshes[index].domain);
-
-				assert(face_meshes[index].domain->vn==3);
-				assert(face_meshes[index].domain->fn==1);
-
-				///initialize auxiliary structures
-				face_meshes[index].local_to_global.resize(1);
-				face_meshes[index].local_to_global[0]=i;
-
-				///parametrize it
-				ParametrizeFaceEquilateral<AbstractMesh>(*face_meshes[index].domain,edge_len);
-
-				///add h resolution vertices 
-				std::vector<ParamVertex*> HresVert;
-				GetHresVert(index,HresVert);
-				std::vector<ParamVertex*> OrderedVertices;
-				CopyMeshFromVerticesAbs(HresVert,OrderedVertices,face_meshes[index].ordered_faces,*face_meshes[index].HresDomain);
-				///set new parametrization values
-				for (unsigned int k=0;k<face_meshes[index].HresDomain->vert.size();k++)
-				{
-					ParamVertex * v=&face_meshes[index].HresDomain->vert[k];
-					CoordType bary=CoordType(v->T().U(),v->T().V(),1-v->T().U()-v->T().V());
-					AbstractMesh *paramDomain=face_meshes[index].domain;
-					AbstractFace *faceDom=&paramDomain->face[0];
-					v->T().P()=(faceDom->V(0)->T().P())*bary.X()+(faceDom->V(1)->T().P())*bary.Y()+(faceDom->V(2)->T().P())*bary.Z();
-				}
-
-				face_meshes[index].InitGrid();
-				index++;
-			}
-		}
-	}
-
-	void getFaceIndexFromPointer(AbstractFace * f,int &index)
-	{
-		index=f-&(*abstract_mesh->face.begin());
-	}
-
-	void getStarFromPointer(AbstractVertex * center,int &index)
-	{
-		index=center-&(*abstract_mesh->vert.begin());
-	}
-
-	void getDiamondFromPointer(AbstractVertex * v0,AbstractVertex * v1,int &index)
-	{
-		assert(v0!=v1);
-		keyEdgeType key;
-		if (v0<v1)
-			key=keyEdgeType(v0,v1);
-		else
-			key=keyEdgeType(v1,v0);
-
-		std::map<keyEdgeType,int>::iterator k=EdgeTab.find(key);
-		assert(k!=EdgeTab.end());
-		index=((*k).second);
-	}
-	
-	
-	bool Test()
-	{
-		/*int index=0;*/
-		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
-		{
-			if (!(abstract_mesh->face[i].IsD()))
-			{
-				AbstractFace *f0=&abstract_mesh->face[i];
-				//for each edge
-				for (int j=0;j<3;j++)
-				{
-					AbstractFace * f1=f0->FFp(j);
-					if (f1>f0)
-					{
-						///add to domain map
-						AbstractVertex *v0,*v1;
-						v0=f0->V(j);
-						v1=f0->V1(j);
-						keyEdgeType k;
-						if (v0<v1)
-							k=keyEdgeType(v0,v1);
-						else
-							k=keyEdgeType(v1,v0);
-
-						//std::pair<keyEdgeType,int> entry=std::pair<keyEdgeType,int>(k,index);
-						std::map<keyEdgeType,int>::iterator iteE=EdgeTab.find(k);
-						
-						int index0F,index1F;
-						getFaceIndexFromPointer(f0,index0F);
-						getFaceIndexFromPointer(f1,index1F);
-#ifndef NDEBUG
-						int edgeIndex=(*iteE).second;
-						assert(diamond_meshes[edgeIndex].local_to_global[0]==index0F);
-						assert(diamond_meshes[edgeIndex].local_to_global[1]==index1F);
-#endif
-					}
-				}
-			}
-		}
-		///test if for each face there is a right domain
-		for (unsigned int i=0;i<param_mesh->face.size();i++)
-		{
-			ParamFace * f=&param_mesh->face[i];	
-			vcg::Point2f uvI0,uvI1,uvI2;
-			int IndexDomain=-1;
-			int ret=InterpolationSpace(f,uvI0,uvI1,uvI2,IndexDomain);
-			if (ret==-1)
-				return false;
-		}
-	return true;
-	}
-
-	int getSharedVertices(AbstractFace *f0,AbstractFace *f1,AbstractFace *f2,
-						  AbstractVertex *shared[3])
-	{
-		AbstractVertex *vert0[3],*vert1[3],*vert2[3];
-		
-		vert0[0]=f0->V(0);
-		vert0[1]=f0->V(1);
-		vert0[2]=f0->V(2);
-
-		vert1[0]=f1->V(0);
-		vert1[1]=f1->V(1);
-		vert1[2]=f1->V(2);
-
-		vert2[0]=f2->V(0);
-		vert2[1]=f2->V(1);
-		vert2[2]=f2->V(2);
-		
-		int num=0;
-		for (int i=0;i<3;i++)
-		{
-			AbstractVertex * test=vert0[i];
-			bool found0=false,found1=false;
-			if ((vert1[0]==test)||(vert1[1]==test)||(vert1[2]==test))
-					found0=true;
-			if (found0)
-			{
-				if ((vert2[0]==test)||(vert2[1]==test)||(vert2[2]==test))
-					found1=true;
-			}
-			if ((found0)&&(found1))
-			{
-				shared[num]=test;
-				num++;
-			}
-		}
-
-		return num;
-	}
-	
-	int getSharedVertices(AbstractFace *f0,AbstractFace *f1,AbstractVertex *shared[3])
-	{
-		AbstractVertex *vert0[3],*vert1[3];
-		
-		vert0[0]=f0->V(0);
-		vert0[1]=f0->V(1);
-		vert0[2]=f0->V(2);
-
-		vert1[0]=f1->V(0);
-		vert1[1]=f1->V(1);
-		vert1[2]=f1->V(2);
-
-		
-		int num=0;
-		for (int i=0;i<3;i++)
-		{
-			AbstractVertex * test=vert0[i];
-			bool found0=false;
-			if ((vert1[0]==test)||(vert1[1]==test)||(vert1[2]==test))
-					found0=true;
-			if (found0)
-			{
-				shared[num]=test;
-				num++;
-			}
-		}
-
-		return num;
-	}
-	
-	int getSharedVertices(const std::vector<int> &I,AbstractVertex *shared[3],int *_num=NULL)
-	{	
-		///else test the number of vertices shared 
-		AbstractVertex * shared_vert[3];
-		bool sharedB[3];
-		int size;
-		if (_num==NULL)
-			size=I.size();
-		else
-			size=*_num;
-
-		///quick test for 2 or 3 cases
-		if (size==2)
-			return getSharedVertices(&AbsMesh()->face[I[0]],&AbsMesh()->face[I[1]],shared);
-		else
-		if (size==3)
-			return getSharedVertices(&AbsMesh()->face[I[0]],&AbsMesh()->face[I[1]],&AbsMesh()->face[I[2]],shared);
-
-		AbstractFace* f0=&AbsMesh()->face[I[0]];
-		AbstractVertex *v0=f0->V(0);
-		AbstractVertex *v1=f0->V(1);
-		AbstractVertex *v2=f0->V(2);
-		shared_vert[0]=v0;
-		shared_vert[1]=v1;
-		shared_vert[2]=v2;
-		sharedB[0]=true;
-		sharedB[1]=true;
-		sharedB[2]=true;
-		//for each face
-		for (int i=1;i<size;i++)
-		{
-			AbstractFace* f=&AbsMesh()->face[I[i]];
-			//for each vertex
-			for (int j=0;j<3;j++)
-			{
-				if (sharedB[j])
-				{
-					AbstractVertex *v_test=shared_vert[j];
-					if (!((v_test==f->V(0))||(v_test==f->V(1))||(v_test==f->V(2))))
-						sharedB[j]=false;
-				}	
-			}
-		}
-
-		///return vertices correctly
-		int num=0;
-		for (int i=0;i<3;i++)
-			if (sharedB[i])
-			{
-				shared[num]=shared_vert[i];
-				num++;
-			}
-		return num;
-	}
-
-
-	void Clamp(vcg::Point2f &UV)
-	{
-		float eps=0.00001f;
-		if ((UV.X()<eps)&&(UV.X()>-eps))
-			UV.X()=0;
-		if ((UV.X()<1+eps)&&(UV.X()>1-eps))
-			UV.X()=1;
-		if ((UV.Y()<eps)&&(UV.Y()>-eps))
-			UV.Y()=0;
-		if ((UV.Y()<1+eps)&&(UV.Y()>1-eps))
-			UV.Y()=1;
-	}
-	
-	
-	float Area3d;
-	float AbstractArea;
-
-public:
-	
-	///return the minimum interpolation space shared by a face changing coordinates
-	///return 0 if is a face 1 is a diamaond and 2 is a star
-	int InterpolationSpace(ParamFace *f,
-		vcg::Point2f &uvI0,
-		vcg::Point2f &uvI1,
-		vcg::Point2f &uvI2,
-		int &IndexDomain)
-	{
-		ParamVertex *v0=f->V(0);
-		ParamVertex *v1=f->V(1);
-		ParamVertex *v2=f->V(2);
-
-		int I0=v0->T().N();
-		int I1=v1->T().N();
-		int I2=v2->T().N();
-
-		vcg::Point2f UV0=v0->T().P();
-		vcg::Point2f UV1=v1->T().P();
-		vcg::Point2f UV2=v2->T().P();
-
-		///if they are equal it's is triavially the interpolation of UV coords
-		///and the same face I as the domain
-		if ((I0==I1)&&(I1==I2))
-		{
-			GE2(I0,UV0,uvI0);
-			GE2(I1,UV1,uvI1);
-			GE2(I2,UV2,uvI2);
-			IndexDomain=I0;
-			return 0;
-		}
-
-		///else find the right interpolation domain in which the face belongs
-		///test if they share an edge then use half diamond
-		AbstractFace *f0=&abstract_mesh->face[I0];
-		AbstractFace *f1=&abstract_mesh->face[I1];
-		AbstractFace *f2=&abstract_mesh->face[I2];
-		AbstractVertex *shared[3];
-
-		int num=getSharedVertices(f0,f1,f2,shared);
-		if (num<1)
-		{
-			return -1;
-		}
-		//assert((num==1)||(num==2));
-		if (num==2)///ude diamond
-		{
-			AbstractVertex* v0=shared[0];
-			AbstractVertex* v1=shared[1];
-			int EdgeIndex;
-
-			getDiamondFromPointer(v0,v1,EdgeIndex);			
-
-			GE1(I0,UV0,EdgeIndex,uvI0);
-			GE1(I1,UV1,EdgeIndex,uvI1);
-			GE1(I2,UV2,EdgeIndex,uvI2);
-
-			IndexDomain=EdgeIndex;
-			return 1;
-		}
-
-		///use the star domain
-
-		AbstractVertex* center=shared[0];
-		int StarIndex;
-		getStarFromPointer(center,StarIndex);
-		bool b0=GE0(I0,UV0,StarIndex,uvI0);
-		bool b1=GE0(I1,UV1,StarIndex,uvI1);
-		bool b2=GE0(I2,UV2,StarIndex,uvI2);
-		IndexDomain=StarIndex;
-		if ((!b0)||(!b1)||(!b2))
-		{
-			printf("AZZZ 1\n");
-			return -1;
-		}
-		assert((uvI0.X()>=-1)&&(uvI0.Y()>=-1)&&(uvI0.X()<=1)&&(uvI0.Y()<=1));
-		assert((uvI1.X()>=-1)&&(uvI1.Y()>=-1)&&(uvI1.X()<=1)&&(uvI1.Y()<=1));
-		assert((uvI2.X()>=-1)&&(uvI2.Y()>=-1)&&(uvI2.X()<=1)&&(uvI2.Y()<=1)); 
-
-		
-
-		return 2;
-
-	}
-	
-	///return the minimum interpolation space shared by two faces of abstarct domain
-	///return 0 if is a face 1 is a diamaond and 2 is a star
-	int InterpolationSpace(const int &I0,const int &I1,int &IndexDomain)
-	{
-		///that case is the face itself
-		if (I0==I1)
-		{
-			IndexDomain=I0;
-			return 0;
-		}
-		AbstractFace* f0=&AbsMesh()->face[I0];
-		AbstractFace* f1=&AbsMesh()->face[I1];
-	/*	AbstractVertex *v0=f0->V(0);
-		AbstractVertex *v1=f0->V(1);
-		AbstractVertex *v2=f0->V(2);
-		AbstractVertex *v3=f1->V(0);
-		AbstractVertex *v4=f1->V(1);
-		AbstractVertex *v5=f1->V(2);*/
-
-		
-		AbstractVertex *shared[3];
-
-		int num=getSharedVertices(f0,f1,shared);
-		if (!((num==1)||(num==2)))
-			return -1;
-		if (num==2)///use diamond
-		{
-			AbstractVertex* v0=shared[0];
-			AbstractVertex* v1=shared[1];
-			int EdgeIndex;
-
-			getDiamondFromPointer(v0,v1,EdgeIndex);
-
-			IndexDomain=EdgeIndex;
-			return 1;
-		}
-
-		///use the star domain
-
-		AbstractVertex* center=shared[0];
-		int StarIndex;
-		getStarFromPointer(center,StarIndex);
-		IndexDomain=StarIndex;
-
-		return 2;
-
-	}
-	
-	///return 0 if is a face 1 is a diamaond and 2 is a star
-	int InterpolationSpace(const std::vector<int> &I,int &IndexDomain,int *_num=NULL)
-	{
-		int size;
-		if (_num==NULL)
-			size=I.size();
-		else
-			size=*_num;
-
-		///simple cases
-		assert(I.size()>0);
-		///1 element
-		if (size==1)
-		{
-			IndexDomain=I[0];
-			return 0;
-		}
-		///2 elements
-		if (size==2)
-			return InterpolationSpace(I[0],I[1],IndexDomain);
-
-		///test if they all are the same
-		///that case is the face itself
-		bool sameface=true;
-		int i=1;
-		int I0=I[0];
-		while ((i<size)&&(sameface))
-		{
-			sameface&=(I[i]==I0);
-			i++;
-		}
-		if (sameface)
-		{
-			IndexDomain=I0;
-			return 0;
-		}
-
-		///else test the number of vertices shared 
-		AbstractVertex *shared[3];
-		int num=getSharedVertices(I,shared,_num);
-		assert(num!=3); ///no same yet face possible
-		if (num==0)
-			return -1;  ///no interpolation space exists
-
-		if (num==2)///ude diamond
-		{
-			AbstractVertex* v0=shared[0];
-			AbstractVertex* v1=shared[1];
-			int EdgeIndex;
-
-			getDiamondFromPointer(v0,v1,EdgeIndex);
-
-			IndexDomain=EdgeIndex;
-			return 1;
-		}
-
-		///use the star domain
-
-		AbstractVertex* center=shared[0];
-		int StarIndex;
-		getStarFromPointer(center,StarIndex);
-		IndexDomain=StarIndex;
-
-		return 2;
-
-	}
-
-	int getHStarIndex(const int &I,
-		const vcg::Point2<ScalarType> &UV)
-	{
-		int vertStar=2;
-		CoordType bary=CoordType(UV.X(),UV.Y(),(ScalarType)1.0-UV.X()-UV.Y());
-
-		if ((bary.X()>bary.Y())&&(bary.X()>bary.Z()))
-			vertStar=0;
-		else
-			if ((bary.Y()>bary.X())&&(bary.Y()>bary.Z()))
-				vertStar=1;
-
-		AbstractFace *f=&abstract_mesh->face[I];
-		AbstractVertex *Center=f->V(vertStar);
-
-		int StarIndex;
-		getStarFromPointer(Center,StarIndex);
-		return StarIndex;
-	}
-
-	int getHDiamIndex(const int &I,
-		const vcg::Point2<ScalarType> &UV)
-	{
-		CoordType bary=CoordType(UV.X(),UV.Y(),1-UV.X()-UV.Y());
-		ScalarType sum0=bary.X()+bary.Y();
-		ScalarType sum1=bary.Y()+bary.Z();
-		ScalarType sum2=bary.X()+bary.Z();
-		int edge=2;
-		if ((sum0>sum1)&&(sum0>sum2))
-			edge=0;
-		else
-			if ((sum1>sum0)&&(sum1>sum2))
-				edge=1;
-
-		///get the half-diamond mesh
-		int DiamIndex;
-		getDiamondFromPointer(abstract_mesh->face[I].V(edge),abstract_mesh->face[I].V1(edge),DiamIndex);
-		return(DiamIndex);
-	}
-
-	///give the face and barycentric coordinate return I and UV coordinates
-	void Phi(const ParamFace *f,
-		const CoordType &bary3D,
-		int &I,
-		vcg::Point2<ScalarType> &UV)
-	{
-#ifndef NDEBUG
-		float eps=0.00001f;
-#endif
-		///control right domain
-		int I0=f->V(0)->T().N();
-		int I1=f->V(1)->T().N();
-		int I2=f->V(2)->T().N();
-
-		///if they are equal it's is triavially the interpolation of UV coords
-		///and the same face I as the domain
-		if ((I0==I1)&&(I1==I2))
-		{
-			UV=bary3D.X()*f->V(0)->T().P()+bary3D.Y()*f->V(1)->T().P()+bary3D.Z()*f->V(2)->T().P();
-			Clamp(UV);
-			assert((UV.X()>=0)&&(UV.Y()>=0)&&(UV.X()<=1)&&(UV.Y()<=1)&&(UV.X()+UV.Y()<=1));
-			I=I0;
-			return;
-		}
-		
-
-		///else find the right interpolation domain in which the face belongs
-		///test if they share an edge then use half diamond
-		AbstractFace *f0=&abstract_mesh->face[I0];
-		AbstractFace *f1=&abstract_mesh->face[I1];
-		AbstractFace *f2=&abstract_mesh->face[I2];
-		AbstractVertex *shared[3];
-
-		int num=getSharedVertices(f0,f1,f2,shared);
-
-		/*///if num==1
-		if (num==0)
-		{
-			float alpha=bary3D.X();
-			float beta =bary3D.Y();
-			float gamma=bary3D.Z();
-#ifndef _MESHLAB
-			printf("problems with interpolation, solved...");
-#endif
-			if ((alpha>beta)&&(alpha>gamma))
-			{
-				I=I0;
-				UV=f->V(0)->T().P();
-			}
-			else
-			if ((beta>alpha)&&(beta>gamma))
-			{
-				I=I1;
-				UV=f->V(1)->T().P();
-			}
-			else
-			{
-				I=I2;
-				UV=f->V(2)->T().P();
-			}
-			
-			return;
-		}*/
-
-		assert((num==1)||(num==2));
-		if ((num!=1)&&(num!=2))
-		{
-			printf("DOMAIN %d\n",num);
-			assert(0);
-		}
-		if (num==1)///use the star domain
-		{
-			//printf("phi 0\n");
-			AbstractVertex* center=shared[0];
-			int StarIndex;
-			getStarFromPointer(center,StarIndex);
-			vcg::Point2<ScalarType> UVs0,UVs1,UVs2;
-			vcg::Point2<ScalarType> UV0=f->V(0)->T().P();
-			vcg::Point2<ScalarType> UV1=f->V(1)->T().P();
-			vcg::Point2<ScalarType> UV2=f->V(2)->T().P();
-
-			GE0(I0,UV0,StarIndex,UVs0);
-			GE0(I1,UV1,StarIndex,UVs1);
-			GE0(I2,UV2,StarIndex,UVs2);
-			assert((UVs0.X()>=-1)&&(UVs0.Y()>=-1)&&(UVs0.X()<=1)&&(UVs0.Y()<=1));
-			assert((UVs1.X()>=-1)&&(UVs1.Y()>=-1)&&(UVs1.X()<=1)&&(UVs1.Y()<=1));
-			assert((UVs2.X()>=-1)&&(UVs2.Y()>=-1)&&(UVs2.X()<=1)&&(UVs2.Y()<=1));
-
-			///interpolate star value
-			vcg::Point2<ScalarType> UV_interp=bary3D.X()*UVs0+bary3D.Y()*UVs1+bary3D.Z()*UVs2;
-			inv_GE0(StarIndex,UV_interp,I,UV);
-			Clamp(UV);
-			assert((UV.X()>=0)&&(UV.Y()>=0)&&(UV.X()<=1)&&(UV.Y()<=1)&&(UV.X()+UV.Y()<=1+eps));
-			return;
-		}
-		else			///use the diamond domain
-		{
-			//printf("phi 1\n");
-			//std::set<AbstractVertex*>::iterator it=temp2.begin();
-			//std::vector<AbstractVertex*>::iterator it=shared[0];
-			AbstractVertex* v0=shared[0];
-			//it++;
-			AbstractVertex* v1=shared[1];
-			int EdgeIndex;
-			getDiamondFromPointer(v0,v1,EdgeIndex);
-
-			vcg::Point2<ScalarType> UVd0,UVd1,UVd2;
-			vcg::Point2<ScalarType> UV0=f->V(0)->T().P();
-			vcg::Point2<ScalarType> UV1=f->V(1)->T().P();
-			vcg::Point2<ScalarType> UV2=f->V(2)->T().P();
-
-			GE1(I0,UV0,EdgeIndex,UVd0);
-			GE1(I1,UV1,EdgeIndex,UVd1);
-			GE1(I2,UV2,EdgeIndex,UVd2);
-
-			///interpolate star value
-			vcg::Point2<ScalarType> UV_interp=bary3D.X()*UVd0+bary3D.Y()*UVd1+bary3D.Z()*UVd2;
-			inv_GE1(EdgeIndex,UV_interp,I,UV);
-			Clamp(UV);
-			assert((UV.X()>=0)&&(UV.Y()>=0)&&(UV.X()<=1)&&(UV.Y()<=1)&&(UV.X()+UV.Y()<=1+eps));
-			assert((I==I0)||(I==I1)||(I==I2));
-			return;
-		}
-
-	}
-
-	///given the I and UV coordinates return the face and barycentric coords
-	///return the domain used for interpolation 0=face 1=half diam 2=half star
-	int Theta(const int &I,
-		const vcg::Point2<ScalarType> &UV, // alphaBeta
-		std::vector<ParamFace*> &face,
-		std::vector<CoordType> &baryVal)
-	{
-		#ifndef NDEBUG
-		const ScalarType eps=(ScalarType)0.0001;
-		#endif
-		assert(UV.X()<=1);
-		assert(UV.Y()<=1);
-		assert(UV.X()>=0);
-		assert(UV.Y()>=0);
-		//printf("%f,%f \n",UV.X(),UV.Y());
-		assert((UV.X()+UV.Y())<=(1+eps));
-		
-		//printf("%f,%f \n",UV.X(),UV.Y());
-		///FACE SEARCH
-		///first test if is in the face domain 
-		//printf("face\n");
-		bool found=false;
-		int indexFace=I;
-		/*if (indexFace>=face_meshes.size())
-			printf("B");*/
-
-		vcg::Point2<ScalarType> UVFace;
-		GE2(indexFace,UV,UVFace);
-		found=face_meshes[indexFace].Project(UVFace,face,baryVal);
-		if (found)
-			return 0;
-		
-		///DIAMOND SEARCH
-		///search in the diamond domain
-		//printf("diam\n");
-		int indexDiam=getHDiamIndex(I,UV);///get diamond index
-		vcg::Point2<ScalarType> UVDiam;
-		///transform UV coordids in diamond
-		GE1(I,UV,indexDiam,UVDiam);
-		/*if (indexDiam>=diamond_meshes.size())*/
-			/*printf("C");*/
-		found=diamond_meshes[indexDiam].Project(UVDiam,face,baryVal);
-		if (found)
-			return 1;
-
-		///STAR SEARCH
-		//printf("star\n");
-		int indexStar=getHStarIndex(I,UV);///get star index
-		vcg::Point2<ScalarType> UVStar;
-		///transform UV coords in star
-		GE0(I,UV,indexStar,UVStar);
-		found=star_meshes[indexStar].Project(UVStar,face,baryVal);
-		if (!found)
-		{
-			//printf("\n problems projecting u,v:%lf,%lf (RESOLVED)\n",UV.X(),UV.Y());
-#ifndef NDEBUG
-			bool found=star_meshes[indexStar].getClosest(UVStar,face,baryVal);
-			assert(found);
-#else
-			star_meshes[indexStar].getClosest(UVStar,face,baryVal);
-			/*printf("D");*/
-#endif
-		}
-		return 2;
-	}
-	
-	///given the I and UV coordinates return the face and barycentric coords
-	///return the domain used for interpolation 0=face 1=half diam 2=half star
-	int Theta(const int &I,
-		const vcg::Point2<ScalarType> &UV, // alphaBeta
-		ParamFace* &face,
-		CoordType &baryVal)
-	{
-		std::vector<ParamFace*> faces;
-		std::vector<CoordType>  baryVals;
-		int ret=Theta(I,UV,faces,baryVals);
-		if (ret!=-1)
-		{
-			face=faces[0];
-			baryVal=baryVals[0];
-		}
-		return ret;
-	}
-
-	///given the I and UV coordinates return the face and barycentric coords
-	///return the domain used for interpolation 0=face 1=half diam 2=half star
-	///and 3D Coordinates
-	int Theta(const int &I,
-		const vcg::Point2<ScalarType> &UV,
-		CoordType &pos3D)
-	{
-		std::vector<ParamFace*> face;
-		std::vector<CoordType> baryVal;
-			
-		int ret=Theta(I,UV,face,baryVal);
-			
-		pos3D=CoordType(0,0,0);
-		for (int i=0;i<(int)face.size();i++)
-		{
-			CoordType pos=face[i]->V(0)->P()*baryVal[i].X()+
-						  face[i]->V(1)->P()*baryVal[i].Y()+
-						  face[i]->V(2)->P()*baryVal[i].Z();
-			pos3D+=pos;
-		}
-		
-		pos3D/=(ScalarType)face.size();
-		return ret;
-	}
-
-	///return the coordinate on the half star domain
-	bool GE0(const int &I,
-		const vcg::Point2<ScalarType> &UV,
-		const int &StarIndex,
-		vcg::Point2<ScalarType> &UVHstar)
-	{
-		//int vertStar=2;
-		CoordType bary=CoordType(UV.X(),UV.Y(),1-UV.X()-UV.Y());
-
-		///then transform to the star domain
-
-		///get star mesh
-		AbstractMesh* star_domain=star_meshes[StarIndex].domain;
-		int LocalIndex=star_meshes[StarIndex].Global2Local(I);
-		if (LocalIndex==-1)
-			return false;
-
-		GetUV<AbstractMesh>(&star_domain->face[LocalIndex],bary,UVHstar.X(),UVHstar.Y());
-		return true;
-	}
-
-	///return the coordinate on the half star domain
-	bool inv_GE0(int &StarIndex,
-		vcg::Point2<ScalarType> &UVHstar,
-		int &I,
-		vcg::Point2<ScalarType> &UV)
-	{
-		AbstractMesh* star_domain=star_meshes[StarIndex].domain;
-		CoordType bary;
-		int index;
-		bool done=GetBaryFaceFromUV(*star_domain,UVHstar.X(),UVHstar.Y(),bary,index);
-		if (!done)
-			return false;
-		UV.X()=bary.X();
-		UV.Y()=bary.Y();
-		I=star_meshes[StarIndex].Local2Global(index);
-		return done;
-	}
-
-
-	void InterpParam(vcg::Point2f p1,vcg::Point2f p2,vcg::Point2f p3,vcg::Point2f p_test,
-					 ScalarType &b1,ScalarType &b2,ScalarType &b3)
-	{
-		ScalarType x0=p_test.X();
-		ScalarType y0=p_test.Y();
-		ScalarType x1=p1.X();
-		ScalarType y1=p1.Y();
-		ScalarType x2=p2.X();
-		ScalarType y2=p2.Y();
-		ScalarType x3=p3.X();
-		ScalarType y3=p3.Y();
-		
-		ScalarType b0 =  (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1);
-		b1 = ((x2 - x0) * (y3 - y0) - (x3 - x0) * (y2 - y0)) / b0;
-		b2 = ((x3 - x0) * (y1 - y0) - (x1 - x0) * (y3 - y0)) / b0;
-		b3 = ((x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0)) / b0;
-	}
-
-	///return the coordinate on the half diamond domain
-	void GE1(const int &I,
-		const vcg::Point2<ScalarType> &UV,
-		const int &DiamIndex,
-		vcg::Point2<ScalarType> &UVDiam)
-	{
-		///get the right edge index
-		CoordType bary=CoordType(UV.X(),UV.Y(),1-UV.X()-UV.Y());
-		
-		///then transform to the half-diamond domain
-		///get egde mesh
-		AbstractMesh* diam_domain=diamond_meshes[DiamIndex].domain;
-		int LocalIndex=diamond_meshes[DiamIndex].Global2Local(I);
-		if(LocalIndex!=-1)
-		{
-			GetUV<AbstractMesh>(&diam_domain->face[LocalIndex],bary,UVDiam.X(),UVDiam.Y());
-			return;
-		}
-		///if ! found seach in the star space
-		else
-		{
-			AbstractFace *f_diam=&diam_domain->face[0];
-			int indexF0=diamond_meshes[DiamIndex].Local2Global(0);
-			int indexF1=diamond_meshes[DiamIndex].Local2Global(1);
-
-			//getFaceIndexFromPointer(f0,indexF0);
-			vcg::Point2<ScalarType> UVHstar;
-			//int StarIndex=getHStarIndex(I,UV);
-			int StarIndex=getHStarIndex(I,UV);
-			///get star coordinates
-#ifndef NDEBUG
-			bool found=GE0(I,UV,StarIndex,UVHstar);
-			assert(found);
-#else
-			GE0(I,UV,StarIndex,UVHstar);
-#endif
-
-			///then find which face is in the star
-			int indexParam;
-			int indexParam0=star_meshes[StarIndex].Global2Local(indexF0);
-			int indexParam1=star_meshes[StarIndex].Global2Local(indexF1);
-			if(indexParam0==-1)
-				indexParam=indexParam1;
-			else
-				indexParam=indexParam0;
-			
-			AbstractFace *f_param=&star_meshes[StarIndex].domain->face[indexParam];
-			vcg::Point2f p0=f_param->V(0)->T().P();
-			vcg::Point2f p1=f_param->V(1)->T().P();
-			vcg::Point2f p2=f_param->V(2)->T().P();
-			
-			vcg::Point3f coord;
-			//bool inside=vcg::InterpolationParameters2<float>(p0,p1,p2,UVHstar,coord);
-			InterpParam(p0,p1,p2,UVHstar,coord.X(),coord.Y(),coord.Z());
-			///finally reinterpolate in diamond space
-			UVDiam=coord.X()*f_diam->V(0)->T().P()+coord.Y()*f_diam->V(1)->T().P()+coord.Z()*f_diam->V(2)->T().P();
-			return;
-		}
-		//CoordType bary=CoordType(UV.X(),UV.Y(),1-UV.X()-UV.Y());
-		
-	}
-
-	///given the diamond coordinates return the coordinates in the parametrization space
-	void inv_GE1(const int &DiamIndex,
-		const vcg::Point2<ScalarType> &UVDiam,
-		int &I,
-		vcg::Point2<ScalarType> &UV)
-	{
-		AbstractMesh* diam_domain=diamond_meshes[DiamIndex].domain;
-		CoordType bary;
-		int index;
-#ifndef NDEBUG
-		bool done=GetBaryFaceFromUV(*diam_domain,UVDiam.X(),UVDiam.Y(),bary,index);
-		assert(done);
-#else
-		GetBaryFaceFromUV(*diam_domain,UVDiam.X(),UVDiam.Y(),bary,index);
-#endif
-		UV.X()=bary.X();
-		UV.Y()=bary.Y();
-		I=diamond_meshes[DiamIndex].Local2Global(index);
-		
-	}
-	
-	///given the diamond coordinates return the coordinates in the parametrization space
-	///in this case I is fixed and should falls also outside the face I
-	void inv_GE1_fixedI(const int &DiamIndex,
-		const vcg::Point2<ScalarType> &UVDiam,
-		const int &I,
-		vcg::Point2<ScalarType> &bary)
-	{
-		/*AbstractMesh* diam_domain=diamond_meshes[DiamIndex].domain;*/
-		//int index;
-		CoordType bary3d;
-		///then find barycentryc coordinates with respect to such face
-		int local_face=diamond_meshes[DiamIndex].Global2Local(I);
-		AbstractFace* f=&diamond_meshes[DiamIndex].domain->face[local_face];
-		vcg::Point2<ScalarType> p0=f->V(0)->T().P();
-		vcg::Point2<ScalarType> p1=f->V(1)->T().P();
-		vcg::Point2<ScalarType> p2=f->V(2)->T().P();
-		InterpParam(p0,p1,p2,UVDiam,bary3d.X(),bary3d.Y(),bary3d.Z());
-		bary.X()=bary3d.X();
-		bary.Y()=bary3d.Y();
-	}
-	
-	///given the star return the coordinates in the parametrization space
-	///in this case I is fixed and should falls also outside the face I
-	void inv_GE0_fixedI(const int &StarIndex,
-		const vcg::Point2<ScalarType> &UVStar,
-		const int &I,
-		vcg::Point2<ScalarType> &bary)
-	{
-		//AbstractMesh* star_domain=star_meshes[StarIndex].domain;
-		/*int index;*/
-		CoordType bary3d;
-		///then find barycentryc coordinates with respect to such face
-		int local_face=star_meshes[StarIndex].Global2Local(I);
-		AbstractFace* f=&star_meshes[StarIndex].domain->face[local_face];
-		vcg::Point2<ScalarType> p0=f->V(0)->T().P();
-		vcg::Point2<ScalarType> p1=f->V(1)->T().P();
-		vcg::Point2<ScalarType> p2=f->V(2)->T().P();
-		InterpParam(p0,p1,p2,UVStar,bary3d.X(),bary3d.Y(),bary3d.Z());
-		bary.X()=bary3d.X();
-		bary.Y()=bary3d.Y();
-	}
-
-	///given the diamond coordinates AS A QUAD return the coordinates in the parametrization space
-	void inv_GE1Quad(const int &DiamIndex,
-					const vcg::Point2<ScalarType> &UVQuad,
-					int &I,
-					vcg::Point2<ScalarType> &UV)
-	{
-		assert((UVQuad.X()>=0)&&(UVQuad.X()<=1));
-		assert((UVQuad.Y()>=0)&&(UVQuad.Y()<=1));
-
-		///get the abstract mesh
-		AbstractMesh* diam_domain=diamond_meshes[DiamIndex].domain;
-		///get the 4 vertices on the full diamond
-
-		///transform in diamond coordinates
-		vcg::Point2<ScalarType> c0=vcg::Point2<ScalarType>(0,(ScalarType)-0.5);
-		vcg::Point2<ScalarType> c1=vcg::Point2<ScalarType>((sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
-		vcg::Point2<ScalarType> c2=vcg::Point2<ScalarType>(0,(ScalarType)0.5);
-		vcg::Point2<ScalarType> c3=vcg::Point2<ScalarType>(-(sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
-
-		///get 2 directions
-		vcg::Point2<ScalarType> v0=c1-c0;
-		//v0.Normalize();
-		vcg::Point2<ScalarType> v1=c3-c0;
-		//v1.Normalize();
-		
-		///value in diamond coordinates
-		vcg::Point2<ScalarType> UVDiam=c0+UVQuad.X()*v0;
-		vcg::Point2<ScalarType> diry=UVQuad.Y()*v1;
-		UVDiam=UVDiam+diry;
-		
-		//printf("Diamond: %d,%f,%f \n",DiamIndex,UVDiam.X(),UVDiam.Y());
-
-		int index;
-		CoordType bary;
-#ifndef NDEBUG
-		bool done=GetBaryFaceFromUV(*diam_domain,UVDiam.X(),UVDiam.Y(),bary,index);
-#else
-		GetBaryFaceFromUV(*diam_domain,UVDiam.X(),UVDiam.Y(),bary,index);
-#endif
-		UV.X()=bary.X();
-		UV.Y()=bary.Y();
-
-		I=diamond_meshes[DiamIndex].Local2Global(index);
-		assert(done);
-	}
-	
-	///TO RESCALE?
-	///given the coordinates in the parametrization space return return the coordinates AS A QUAD 
-	void GE1Quad(const int &I,
-				 const vcg::Point2<ScalarType> &UV,
-				 int &DiamIndex,
-				 vcg::Point2<ScalarType> &UVQuad)
-	{
-		///first get the right half diamond index
-		DiamIndex=getHDiamIndex(I,UV);
-		
-		///transform in diamond space
-		vcg::Point2<ScalarType> UVDiam;
-		GE1(I,UV,DiamIndex,UVDiam);
-		
-		///transform in diamond coordinates
-		vcg::Point2<ScalarType> c0=vcg::Point2<ScalarType>(0,(ScalarType)-0.5);
-		vcg::Point2<ScalarType> c1=vcg::Point2<ScalarType>((sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
-		vcg::Point2<ScalarType> c2=vcg::Point2<ScalarType>(0,(ScalarType)0.5);
-		vcg::Point2<ScalarType> c3=vcg::Point2<ScalarType>(-(sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
-
-		///get 2 directions
-		vcg::Point2<ScalarType> v0=c1-c0;
-		//v0.Normalize();
-		vcg::Point2<ScalarType> v1=c3-c0;
-		//v1.Normalize();
-		
-		///translate respect to zero
-		UVDiam-=c0;
-
-		///then transform in new coordspace
-		UVQuad.X()=v0.X()*UVDiam.X()+v0.Y()*UVDiam.Y();
-		UVQuad.Y()=v1.X()*UVDiam.X()+v1.Y()*UVDiam.Y();
-
-	}
-	
-	///given the diamond coordinates return return the coordinates AS A QUAD 
-	void GE1Quad(const int &/*DiamIndex*/,
-				 const vcg::Point2<ScalarType> &UVDiam,
-				 vcg::Point2<ScalarType> &UVQuad)
-	{
-		//assert(UVDiam.Y()<0);
-		///transform in diamond coordinates
-		vcg::Point2<ScalarType> c0=vcg::Point2<ScalarType>(0,(ScalarType)-0.5);
-		vcg::Point2<ScalarType> c1=vcg::Point2<ScalarType>((sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
-		vcg::Point2<ScalarType> c2=vcg::Point2<ScalarType>(0,(ScalarType)0.5);
-		vcg::Point2<ScalarType> c3=vcg::Point2<ScalarType>(-(sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
-		
-		///get 2 directions
-		vcg::Point2<ScalarType> v0=c1-c0;
-		vcg::Point2<ScalarType> v1=c3-c0;
-		
-		///translate respect to zero
-		vcg::Point2<ScalarType> temp=UVDiam;
-		//temp=c3;
-		temp-=c0;
-		ScalarType det=(ScalarType)1.0/(v0.X()*v1.Y()-v1.X()*v0.Y());
-		///then transform in new coordspace
-		UVQuad.X()=v1.Y()*temp.X()-v1.X()*temp.Y();
-		UVQuad.Y()=-v0.Y()*temp.X()+v0.X()*temp.Y();
-		UVQuad.X()*=det;
-		UVQuad.Y()*=det;
-	/*	printf("UVtr1=%f, %f \n",UVQuad.X(),UVQuad.Y());
-		system("pause");*/
-	}
-
-	///return the coordinate on the face domain
-	void GE2(const int &I,
-		const vcg::Point2<ScalarType> &UV,
-		vcg::Point2<ScalarType> &UVFace)
-	{
-		///get the right edge index
-		CoordType bary=CoordType(UV.X(),UV.Y(),1-UV.X()-UV.Y());
-		
-		///then transform to the face domain
-		///get face mesh
-		AbstractMesh* face_domain=face_meshes[I].domain;
-		AbstractFace* f=&(face_domain->face[0]);
-
-		UVFace=bary.X()*f->V(0)->T().P()+bary.Y()*f->V(1)->T().P()+bary.Z()*f->V(2)->T().P();
-	}
-
-	///given the face coordinates return the coordinates in the parametrization space
-	void inv_GE2(const int &FaceIndex,
-		const vcg::Point2<ScalarType> &UVFace,
-		vcg::Point2<ScalarType> &UV)
-	{
-		AbstractMesh* face_domain=face_meshes[FaceIndex].domain;
-		CoordType bary;
-		int index;
-#ifndef NDEBUG
-		bool done=GetBaryFaceFromUV(*face_domain,UVFace.X(),UVFace.Y(),bary,index);
-		assert(done);
-#else
-		GetBaryFaceFromUV(*face_domain,UVFace.X(),UVFace.Y(),bary,index);
-#endif
-		UV.X()=bary.X();
-		UV.Y()=bary.Y();
-
-	}
-
-	void Clear()
-	{
-		face_to_vert.clear();
-		star_meshes.clear();
-		face_meshes.clear();
-		diamond_meshes.clear();
-	}
-
-	bool Update(bool test=true)
-	{
-		UpdateTopologies(abstract_mesh);
-		UpdateTopologies(param_mesh);
-		float fix_num=sqrt((ScalarType)3.0)/(ScalarType)4.0;
-
-		int edge_count=0;
-		///cont number of edges
-		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
-		{
-			if (!(abstract_mesh->face[i].IsD()))
-			{
-				AbstractFace *f0=&abstract_mesh->face[i];
-				//for each edge
-				for (int j=0;j<3;j++)
-				{
-					AbstractFace * f1=f0->FFp(j);
-					if (f1>f0)
-						edge_count++;
-				}
-			}
-		}
-
-		///test param mesh
-		for (unsigned int i=0;i<param_mesh->vert.size();i++)
-		{
-			if (!(param_mesh->vert[i].IsD()))
-			{
-				ParamVertex *v0=&param_mesh->vert[i];
-				ParamMesh::CoordType bary=ParamMesh::CoordType(v0->T().U(),v0->T().V(),1-v0->T().U()-v0->T().V());
-				int patchNum=v0->T().N();
-				if (!testBaryCoords(bary))
-					return false;
-				if (patchNum<0)
-					return false;
-				if (patchNum>AbsMesh()->fn)
-					return false;
-			}
-		}
-		Area3d=vcg::tri::Stat<ParamMesh>::ComputeMeshArea(*param_mesh);
-		AbstractArea=(ScalarType)abstract_mesh->fn*fix_num;
-		
-		face_to_vert.clear();
-		star_meshes.clear();
-		face_meshes.clear();
-		diamond_meshes.clear();
-		star_meshes.resize(abstract_mesh->vn);
-		face_meshes.resize(abstract_mesh->fn);
-		diamond_meshes.resize(edge_count);
-		InitFaceToVert();
-		InitFace();
-		InitDiamond();
-		InitStar();
-		if (test)
-			return (Test());
-		return true;
-	}
-
-	bool Init(AbstractMesh * _abstract_mesh,
-			  ParamMesh	 * _param_mesh,bool test=true)
-	{
-		
-		abstract_mesh=_abstract_mesh;
-		param_mesh=_param_mesh;
-
-		UpdateTopologies(abstract_mesh);
-		UpdateTopologies(param_mesh);
-		
-		return (Update(test));
-	}
-	
-	AbstractMesh *&AbsMesh(){return abstract_mesh;} 
-	ParamMesh	 *&ParaMesh(){return param_mesh;} 
-
-	///given the index of face and the index of the edge return the 
-	///index of diamond
-	int GetDiamond(const int &I,const int & edge)
-	{
-		AbstractVertex *v0=AbsMesh()->face[I].V0(edge);
-		AbstractVertex *v1=AbsMesh()->face[I].V1(edge);
-		int index;
-		getDiamondFromPointer(v0,v1,index);
-		return index;
-	}
-
-	int GetStarIndex(const int &I,const int & indexV)
-	{
-		AbstractVertex *v=AbsMesh()->face[I].V(indexV);
-		int index;
-		getStarFromPointer(v,index);
-		return index;
-	}
-
-	void SaveBaseDomain(char *pathname)
-	{
-		/*vcg::tri::io::ExporterPLY<AbstractMesh>::Save(*AbsMesh(),pathname);*/
-		/*Warp(0);*/
-		FILE *f;
-		f=fopen(pathname,"w+");
-	
-		std::map<AbstractVertex*,int> vertexmap;
-		typedef std::map<AbstractVertex*,int>::iterator iteMapVert;
-
-		///add vertices
-		fprintf(f,"%d,%d \n",AbsMesh()->fn,AbsMesh()->vn);
-		int index=0;
-		for (unsigned int i=0;i<AbsMesh()->vert.size();i++)
-		{
-			AbstractVertex* vert=&AbsMesh()->vert[i];
-			if (!vert->IsD())
-			{
-				vertexmap.insert(std::pair<AbstractVertex*,int>(vert,index));
-				CoordType pos=vert->P();
-				CoordType RPos=vert->RPos;
-				fprintf(f,"%f,%f,%f;\n",pos.X(),pos.Y(),pos.Z());
-				index++;
-			}
-		}
-
-		///add faces
-		for (unsigned int i=0;i<AbsMesh()->face.size();i++)
-		{
-			AbstractFace* face=&AbsMesh()->face[i];
-			if (!face->IsD())
-			{
-				AbstractVertex* v0=face->V(0);
-				AbstractVertex* v1=face->V(1);
-				AbstractVertex* v2=face->V(2);
-				iteMapVert vertIte;
-				vertIte=vertexmap.find(v0);
-				assert(vertIte!=vertexmap.end());
-				int index0=(*vertIte).second;
-				vertIte=vertexmap.find(v1);
-				assert(vertIte!=vertexmap.end());
-				int index1=(*vertIte).second;
-				vertIte=vertexmap.find(v2);
-				assert(vertIte!=vertexmap.end());
-				int index2=(*vertIte).second;
-				assert((index0!=index1)&&(index1!=index2));
-				fprintf(f,"%d,%d,%d \n",index0,index1,index2);
-			}
-		}
-		fclose(f);
-	}
-
-	template <class MeshType>
-	bool SetParamMesh(MeshType	*_input_mesh,
-										ParamMesh	 * _param_mesh)
-	{
-		param_mesh=_param_mesh;
-		param_mesh->Clear();
-		vcg::tri::Append<ParamMesh,MeshType>::Mesh(*param_mesh,*_input_mesh);
-		return(Update(true));
-	}
-
-	template <class MeshType>
-	bool LoadBaseDomain(char *pathname,
-						MeshType	*_input_mesh,
-						ParamMesh	 * _param_mesh,
-						AbstractMesh *_absMesh,
-            bool test=true)
-//						bool use_quality=true)
-	{
-		param_mesh=_param_mesh;
-		param_mesh->Clear();
-		/*vcg::tri::Allocator<MeshType>::CompactVertexVector(*_input_mesh);
-		vcg::tri::Allocator<MeshType>::CompactFaceVector(*_input_mesh);*/
-		vcg::tri::Append<ParamMesh,MeshType>::Mesh(*param_mesh,*_input_mesh);
-		/*UpdateStructures<ParamMesh>(param_mesh);*/
-
-		///quality copy to index of texture
-    for (size_t i=0;i<param_mesh->vert.size();i++)
-		{
-			int val0=(int)param_mesh->vert[i].Q();
-			//int val1=param_mesh->vert[i].T().N();*/
-			param_mesh->vert[i].T().N()=val0;
-			assert(param_mesh->vert[i].T().N()>=0);
-		}
-		/*if (AbsMesh()!=NULL)
-			delete(AbsMesh());*/
-
-		//AbsMesh()=new AbstractMesh();
-		AbsMesh()=_absMesh;
-		AbsMesh()->Clear();
-
-		FILE *f=NULL;              
-		f=fopen(pathname,"r");
-		if (f==NULL)
-			return -1;
-		
-		///read vertices
-		fscanf(f,"%d,%d \n",&abstract_mesh->fn,&abstract_mesh->vn);
-		abstract_mesh->vert.resize(abstract_mesh->vn);
-		abstract_mesh->face.resize(abstract_mesh->fn);
-
-		for (unsigned int i=0;i<abstract_mesh->vert.size();i++)
-		{
-			AbstractVertex* vert=&abstract_mesh->vert[i];
-			CoordType pos;
-			fscanf(f,"%f,%f,%f;\n",&pos.X(),&pos.Y(),&pos.Z());
-			vert->P()=pos;
-		}
-
-		///add faces
-		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
-		{
-			AbstractFace* face=&abstract_mesh->face[i];
-			if (!face->IsD())
-			{
-				int index0,index1,index2;
-				fscanf(f,"%d,%d,%d \n",&index0,&index1,&index2);
-				abstract_mesh->face[i].V(0)=&abstract_mesh->vert[index0];
-				abstract_mesh->face[i].V(1)=&abstract_mesh->vert[index1];
-				abstract_mesh->face[i].V(2)=&abstract_mesh->vert[index2];
-			}
-		}
-		UpdateTopologies<AbstractMesh>(AbsMesh());
-		fclose(f);
-		
-		return (Update(test));
-	}
-	
-	template <class MeshType>
-	void CopyParametrization(MeshType	* _param_mesh)
-	{
-    for (size_t i=0;i<_param_mesh->vert.size();i++)
-		{
-			_param_mesh->vert[i].T().P()=ParaMesh()->vert[i].T().P();
-			_param_mesh->vert[i].T().N()=ParaMesh()->vert[i].T().N();
-      _param_mesh->vert[i].Q()=(typename MeshType::ScalarType)ParaMesh()->vert[i].T().N();
-		}
-	}
-
-	template <class MeshType>
-	int LoadMCP(AbstractMesh * _abstract_mesh,
-			  ParamMesh	 * _param_mesh,
-				char* filename,MeshType *coloredMesh=NULL)
-	{
-		abstract_mesh=_abstract_mesh;
-		param_mesh=_param_mesh;
-
-		FILE *f=NULL;              
-		f=fopen(filename,"r");
-		if (f==NULL)
-			return -1;
-		
-
-		///add vertices
-		abstract_mesh->Clear();
-		fscanf(f,"%d,%d \n",&abstract_mesh->fn,&abstract_mesh->vn);
-		abstract_mesh->vert.resize(abstract_mesh->vn);
-		abstract_mesh->face.resize(abstract_mesh->fn);
-
-		for (unsigned int i=0;i<abstract_mesh->vert.size();i++)
-		{
-			AbstractVertex* vert=&abstract_mesh->vert[i];
-			CoordType pos;
-			CoordType RPos;
-			fscanf(f,"%f,%f,%f;%f,%f,%f \n",&pos.X(),&pos.Y(),&pos.Z(),&RPos.X(),&RPos.Y(),&RPos.Z());
-			vert->P()=pos;
-			//vert->RPos=RPos;
-		}
-
-		
-
-		///add faces
-		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
-		{
-			AbstractFace* face=&abstract_mesh->face[i];
-			if (!face->IsD())
-			{
-				int index0,index1,index2;
-				fscanf(f,"%d,%d,%d \n",&index0,&index1,&index2);
-				abstract_mesh->face[i].V(0)=&abstract_mesh->vert[index0];
-				abstract_mesh->face[i].V(1)=&abstract_mesh->vert[index1];
-				abstract_mesh->face[i].V(2)=&abstract_mesh->vert[index2];
-			}
-		}
-		
-		///high resolution mesh
-		fscanf(f,"%d,%d \n",&param_mesh->fn,&param_mesh->vn);
-		param_mesh->vert.resize(param_mesh->vn);
-		param_mesh->face.resize(param_mesh->fn);
-
-		///add vertices
-		for (unsigned int i=0;i<param_mesh->vert.size();i++)
-		{
-			ParamVertex* vert=&param_mesh->vert[i];
-			CoordType pos;
-			CoordType bary;
-			vcg::Color4b col;
-			int index_face;
-			int col0,col1,col2;
-			fscanf(f,"%f,%f,%f;%f,%f,%f;%d,%d,%d;%d \n",
-				  &pos.X(),&pos.Y(),&pos.Z(),
-				  &bary.X(),&bary.Y(),&bary.Z(),
-				  &col0,&col1,&col2,
-				  &index_face);
-			vert->P()=pos;
-			//vert->RPos=pos;
-			vert->T().P()=vcg::Point2<ScalarType>(bary.X(),bary.Y());
-			vert->T().N()=index_face;
-			if (coloredMesh!=NULL)
-			{
-				vcg::Color4b col=coloredMesh->vert[i].C();
-				vert->C()=col;
-			}
-		}
-
-		///add faces
-		for (unsigned int i=0;i<param_mesh->face.size();i++)
-		{
-			//BaseFace* face=&final_mesh.face[i];
-			
-			int index0,index1,index2;
-			fscanf(f,"%d,%d,%d \n",&index0,&index1,&index2);
-			param_mesh->face[i].V(0)=&param_mesh->vert[index0];
-			param_mesh->face[i].V(1)=&param_mesh->vert[index1];
-			param_mesh->face[i].V(2)=&param_mesh->vert[index2];
-			
-		}
-		fclose(f);
-		
-		///update structures
-		vcg::tri::UpdateBounding<AbstractMesh>::Box(*abstract_mesh);
-		vcg::tri::UpdateTopology<AbstractMesh>::FaceFace(*abstract_mesh);
-		vcg::tri::UpdateTopology<AbstractMesh>::VertexFace(*abstract_mesh);
-
-		vcg::tri::UpdateBounding<ParamMesh>::Box(*param_mesh);
-		vcg::tri::UpdateTopology<ParamMesh>::FaceFace(*param_mesh);
-		vcg::tri::UpdateTopology<ParamMesh>::VertexFace(*param_mesh);
-
-		
-		Update();
-
-		return 0;
-	}
-};
-
-
-#endif
+#ifndef TRI_PARAMETRIZATION
+#define TRI_PARAMETRIZATION	
+
+// stuff to define the mesh
+ #include <wrap/io_trimesh/export_ply.h>
+#include <wrap/io_trimesh/import_ply.h>
+#include <vcg/space/triangle3.h>
+#include <vcg/simplex/face/component_rt.h>
+#include <vcg/complex/complex.h>
+#include "local_parametrization.h"
+#include "uv_grid.h"
+#include <vcg/complex/algorithms/stat.h>
+#include "param_mesh.h"
+
+///ABSTRACT MESH THAT MAINTAINS THE WHOLE PARAMETERIZATION
+class AbstractVertex;
+class AbstractFace;
+
+class AbstractUsedTypes: public vcg::UsedTypes < vcg::Use<AbstractVertex>::AsVertexType,
+                                          vcg::Use<AbstractFace  >::AsFaceType >{};
+
+
+class AbstractVertex  : public vcg::Vertex< AbstractUsedTypes,
+	vcg::vertex::VFAdj, 
+	vcg::vertex::Coord3f,
+	vcg::vertex::TexCoord2f,
+	vcg::vertex::BitFlags>
+  //vcg::face::Normal3f>
+{
+public:
+	CoordType RPos;
+
+  template < class LeftV>
+	void ImportData(const LeftV  & left )
+  {
+			vcg::Vertex< AbstractUsedTypes, vcg::vertex::VFAdj, vcg::vertex::Coord3f,vcg::vertex::TexCoord2f,vcg::vertex::BitFlags>::ImportData( left);
+      this->RPos = left.RPos;
+  }
+};
+
+class AbstractFace    : public vcg::Face  < AbstractUsedTypes,
+	vcg::face::VFAdj, 
+	vcg::face::FFAdj,
+	vcg::face::VertexRef,
+	vcg::face::Color4b,
+	vcg::face::BitFlags>
+//vcg::face::Normal3f>
+{};
+
+class AbstractMesh: public vcg::tri::TriMesh<std::vector<AbstractVertex>, std::vector<AbstractFace> > {
+//public:
+//	static const bool Has_Auxiliary(){return false;}
+};
+
+///HIGH RESOLUTION MESH THAT HAS TO BE PARAMETERIZED
+class ParamVertex;
+class ParamFace;
+
+
+class ParamUsedTypes: public vcg::UsedTypes < vcg::Use<ParamVertex>::AsVertexType,
+                                          vcg::Use<ParamFace  >::AsFaceType >{};
+
+
+class ParamVertex: public vcg::Vertex< ParamUsedTypes,
+											vcg::vertex::Normal3f, vcg::vertex::VFAdj, 
+											vcg::vertex::Coord3f,vcg::vertex::Color4b,
+											vcg::vertex::TexCoord2f,vcg::vertex::BitFlags,
+											vcg::vertex::CurvatureDirf,
+											vcg::vertex::Qualityf>
+{
+public:
+    template < class LeftV>
+		void ImportData(const LeftV  & left )
+    {
+				vcg::Vertex< ParamUsedTypes, vcg::vertex::Normal3f, vcg::vertex::VFAdj, vcg::vertex::Coord3f,vcg::vertex::Color4b, vcg::vertex::TexCoord2f,vcg::vertex::BitFlags, vcg::vertex::CurvatureDirf,vcg::vertex::Qualityf >::ImportData( left);
+    }
+	
+	
+		void ImportData(const ParamVertex  & left )
+    {
+				vcg::Vertex< ParamUsedTypes, vcg::vertex::Normal3f, vcg::vertex::VFAdj, vcg::vertex::Coord3f,vcg::vertex::Color4b, vcg::vertex::TexCoord2f,vcg::vertex::BitFlags, vcg::vertex::CurvatureDirf,vcg::vertex::Qualityf >::ImportData( left);
+        this->RPos = left.RPos;
+    }
+	
+	void ImportData(const BaseVertex  & left )
+    {
+				vcg::Vertex< ParamUsedTypes, vcg::vertex::Normal3f, vcg::vertex::VFAdj, vcg::vertex::Coord3f,vcg::vertex::Color4b, vcg::vertex::TexCoord2f,vcg::vertex::BitFlags, vcg::vertex::CurvatureDirf,vcg::vertex::Qualityf >::ImportData( left);
+        this->RPos = left.RPos;
+    }
+
+	CoordType RPos;
+	static const bool Has_Auxiliary(){return false;}
+};
+
+class ParamFace: public vcg::Face <  ParamUsedTypes,
+	vcg::face::VFAdj,vcg::face::FFAdj,vcg::face::VertexRef,
+  vcg::face::Color4b,vcg::face::BitFlags,
+  vcg::face::Normal3f,
+	vcg::face::WedgeTexCoord2f,
+	vcg::face::Mark,
+	vcg::face::EdgePlane
+  //,
+  //vcg::face::Qualityf // not really needed
+  >
+{
+public:
+	/*template < class LeftV>
+		void ImportData(const LeftV  & left )
+    {
+       vcg::FaceSimp2  <  ParamVertex, ParamEdge, ParamFace, 
+	vcg::face::VFAdj,vcg::face::FFAdj,vcg::face::VertexRef,
+  vcg::face::Color4b,vcg::face::BitFlags,
+  vcg::face::WedgeTexCoord2f,vcg::face::Normal3f,
+	vcg::face::Qualityf>::ImportData( left);
+    }*/
+};
+class ParamMesh: public vcg::tri::TriMesh<std::vector<ParamVertex>, std::vector<ParamFace> > 
+{
+//public:
+	//static const bool Has_Auxiliary(){return false;}
+};
+
+template <class MeshType>
+void CopyMeshFromFacesAbs(const std::vector<typename MeshType::FaceType*> &faces,
+						  std::vector<typename MeshType::VertexType*> &orderedVertex,
+						  MeshType & new_mesh)
+{
+	typedef typename MeshType::CoordType CoordType;
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::VertexType VertexType;
+	typedef typename MeshType::FaceType FaceType;
+
+	///get set of faces
+	std::map<VertexType*,VertexType*> vertexmap;
+        std::vector<VertexType*> vertices;
+	FindVertices(faces,vertices);
+
+	///initialization of new mesh
+	new_mesh.Clear();
+	new_mesh.vn=0;
+	new_mesh.fn=0;
+	new_mesh.face.resize(faces.size());
+	new_mesh.vert.resize(vertices.size());
+	new_mesh.vn=vertices.size();
+	new_mesh.fn=faces.size();
+
+	///add new vertices
+        typename std::vector<VertexType*>::const_iterator iteV;
+	int i=0;
+	for (iteV=vertices.begin();iteV!=vertices.end();iteV++)
+	{
+		///copy position
+		assert(!(*iteV)->IsD());
+		new_mesh.vert[i].P()=(*iteV)->P();
+		new_mesh.vert[i].RPos=(*iteV)->RPos;
+		new_mesh.vert[i].T().P()=(*iteV)->T().P();
+		new_mesh.vert[i].T().N()=(*iteV)->T().N();
+		//new_mesh.vert[i].N()=(*iteV)->N();
+		///*assert(new_mesh.vert[i].brother!=NULL);*/
+		////if (MeshType::Has_Auxiliary())
+		//new_mesh.vert[i].brother=(*iteV)->brother;
+		new_mesh.vert[i].ClearFlags();
+		
+		orderedVertex.push_back((*iteV));
+		vertexmap.insert(std::pair<VertexType*,VertexType*>((*iteV),&new_mesh.vert[i]));
+		i++;
+	}
+
+	///setting of new faces
+        typename std::vector<FaceType*>::const_iterator iteF;
+        typename std::vector<FaceType>::iterator iteF1;
+	for (iteF=faces.begin(),iteF1=new_mesh.face.begin()
+		;iteF!=faces.end();iteF++,iteF1++)
+	{
+		//(*iteF1).areadelta=(*iteF)->areadelta;
+	/*	if ((*iteF1).areadelta>1)
+			assert(0);*/
+		///for each vertex get new reference
+		///and associate face-vertex
+		for (int j=0;j<3;j++)
+		{
+			VertexType* v=(*iteF)->V(j);
+                        typename std::map<VertexType*,VertexType*>::iterator iteMap=vertexmap.find(v);
+			assert(iteMap!=vertexmap.end());
+			(*iteF1).V(j)=(*iteMap).second;
+		}
+	}
+}
+
+///create a mesh considering just the faces that share all three vertex
+template <class MeshType>
+void CopyMeshFromVerticesAbs(std::vector<typename MeshType::VertexType*> &vertices,
+						  std::vector<typename MeshType::VertexType*> &OrderedVertices,
+						  std::vector<typename MeshType::FaceType*> &OrderedFaces,
+					      MeshType & new_mesh)
+{
+        typedef typename MeshType::CoordType CoordType;
+        typedef typename MeshType::ScalarType ScalarType;
+        typedef typename MeshType::VertexType VertexType;
+        typedef typename MeshType::FaceType FaceType;
+
+        typename std::vector<VertexType*>::const_iterator iteV;
+	for (iteV=vertices.begin();iteV!=vertices.end();iteV++)
+		(*iteV)->ClearV();
+
+
+
+	OrderedVertices.clear();
+
+	///vertex-vertex reference
+	std::map<VertexType*,VertexType*> vertexmap;
+
+	///get set of faces
+	std::vector<typename MeshType::FaceType*> faces;
+
+	getSharedFace<MeshType>(vertices,faces);
+	
+	///initialization of new mesh
+	new_mesh.Clear();
+	new_mesh.vn=0;
+	new_mesh.fn=0;
+
+	///set vertices as selected
+	
+	for (iteV=vertices.begin();iteV!=vertices.end();iteV++)
+		(*iteV)->SetV();
+
+	///getting inside faces
+        typename std::vector<FaceType*>::const_iterator iteF;
+	for (iteF=faces.begin();iteF!=faces.end();iteF++)
+	{
+		///for each vertex get new reference
+		///if there isn't one reference means the face does not appartain to group
+		VertexType* v0=(*iteF)->V(0);
+		VertexType* v1=(*iteF)->V(1);
+		VertexType* v2=(*iteF)->V(2);
+		bool inside=((*v0).IsV()&&(*v1).IsV()&&(*v2).IsV());
+		if (inside)
+			OrderedFaces.push_back((*iteF));
+	}
+	
+	///find internal vertices
+	FindVertices(OrderedFaces,OrderedVertices);
+
+	///setting size
+	new_mesh.face.resize(OrderedFaces.size());
+	new_mesh.vert.resize(OrderedVertices.size());
+	new_mesh.vn=OrderedVertices.size();
+	new_mesh.fn=OrderedFaces.size();
+
+	///setting of internal vertices
+	int i=0;
+        typename std::vector<typename MeshType::VertexType*>::iterator iteVI;
+	for (iteVI=OrderedVertices.begin();iteVI!=OrderedVertices.end();iteVI++)
+	{
+		///copy position
+		assert(!(*iteVI)->IsD());
+		new_mesh.vert[i].P()=(*iteVI)->P();
+		new_mesh.vert[i].RPos=(*iteVI)->RPos;
+		new_mesh.vert[i].T().P()=(*iteVI)->T().P();
+		new_mesh.vert[i].T().N()=(*iteVI)->T().N();
+		new_mesh.vert[i].C()=(*iteVI)->C();
+		/*new_mesh.vert[i].father=(*iteVI)->father;
+		new_mesh.vert[i].Bary=(*iteVI)->Bary;*/
+		//new_mesh.vert[i].Damp=(*iteVI)->Damp;
+		/*new_mesh.vert[i].RestUV=(*iteVI)->RestUV;*/
+		//new_mesh.vert[i].N()=(*iteVI)->N();
+		//new_mesh.vert[i].C()=(*iteVI)->C();
+		/*new_mesh.vert[i].OriginalCol=(*iteVI)->OriginalCol;*/
+		new_mesh.vert[i].ClearFlags();
+		///map setting
+		vertexmap.insert(std::pair<VertexType*,VertexType*>((*iteVI),&new_mesh.vert[i]));
+		i++;
+	}
+
+	///setting of new faces
+        typename std::vector<FaceType>::iterator iteF1;
+	for (iteF=OrderedFaces.begin(),iteF1=new_mesh.face.begin()
+		;iteF!=OrderedFaces.end();iteF++,iteF1++)
+	{
+		///for each vertex get new reference
+		///and associate face-vertex
+		for (int j=0;j<3;j++)
+		{
+			VertexType* v=(*iteF)->V(j);
+                        typename std::map<VertexType*,VertexType*>::iterator iteMap=vertexmap.find(v);
+			assert(iteMap!=vertexmap.end());
+			(*iteF1).V(j)=(*iteMap).second;
+		}
+	}
+
+	///clear flags
+	for (iteV=vertices.begin();iteV!=vertices.end();iteV++)
+		(*iteV)->ClearV();
+
+}
+
+
+
+
+//template <class InputMesh>
+//static int Parametrize(InputMesh &to_param,
+//					   AbstractMesh &AbsMesh,
+//					   InputMesh &Parametrized,
+//					   int &approx_face_num)
+//{
+//	vcg::tri::UpdateTopology<InputMesh>::FaceFace(to_param);
+//
+//	///test input conditions
+//	bool b=vcg::tri::Clean<InputMesh>::IsTwoManifoldFace(to_param);
+//	b&=vcg::tri::Clean<InputMesh>::IsTwoManifoldVertexFF(to_param);
+//	int n=vcg::tri::Clean<InputMesh>::BorderEdges(to_param);
+//	b&=(n==0);
+//	int num=vcg::tri::Clean<InputMesh>::ConnectedComponents(to_param);
+//	b&=(num==1);
+//	if (!b)
+//		return -1;
+//
+//	///then parameteterize
+//	IsoParametrizator TrImage;
+//	TrImage.Parametrize<MyMesh>(&mesh,num1,num2);
+//	TrImage.ExportMeshes(to_param,AbsMesh);
+//	return 0;
+//}
+
+///class that maintains the whole meh parametrerization with relitive operators
+class IsoParametrization
+{
+	AbstractMesh * abstract_mesh;
+	ParamMesh	 * param_mesh;
+
+public:
+	typedef ParamMesh::ScalarType ScalarType;
+	typedef ParamMesh::CoordType CoordType;
+
+private:
+
+	///this class maintains submeshes and hresolution meshes
+	///for the selected parametrization domain
+	struct param_domain{
+		AbstractMesh *domain;
+		std::vector<int> local_to_global;
+
+		ParamMesh *HresDomain;
+		UVGrid<ParamMesh> grid;
+		std::vector<ParamFace*> ordered_faces;
+
+		int Local2Global(const int &localFace)
+		{return local_to_global[localFace];}
+
+		int Global2Local(const int &GlobalFace)
+		{
+			int ret=-1;
+			for (unsigned int i=0;i<local_to_global.size();i++)
+				if (local_to_global[i]==GlobalFace)
+					return i;
+			return ret;
+		}
+
+		void InitGrid()
+		{grid.Init(*HresDomain);}
+
+		bool Project(vcg::Point2<ScalarType> UV,
+					std::vector<ParamFace*> &face,
+					std::vector<CoordType> &baryVal)
+		{
+			std::vector<ParamFace*> faceParam;
+			bool found=grid.ProjectPoint(UV,faceParam,baryVal);
+			if (!found)
+				return false;
+			///calculate the index corresponding to the face
+			for (unsigned int i=0;i<faceParam.size();i++)
+			{
+				ParamFace* f=faceParam[i];
+				int index=f-&(*HresDomain->face.begin());
+				assert(index<HresDomain->fn);
+				face.push_back(ordered_faces[index]);
+			}
+			return true;
+		}
+
+		bool getClosest(vcg::Point2<ScalarType> UV,
+						std::vector<ParamFace*> &face,
+						std::vector<CoordType> &baryVal)
+		{
+			face.resize(1);
+			baryVal.resize(1);
+			bool found=grid.getClosest(UV,face[0],baryVal[0]);
+			int index=face[0]-&(*HresDomain->face.begin());
+			assert(index<HresDomain->fn);
+			face[0]=ordered_faces[index];
+			return found;
+		}
+	};
+
+	///summeshes and subdomains
+	std::vector<param_domain> star_meshes;
+	std::vector<param_domain> diamond_meshes;
+	std::vector<param_domain> face_meshes;
+
+	typedef std::pair<AbstractVertex*,AbstractVertex*> keyEdgeType;
+	std::map<keyEdgeType,int> EdgeTab;
+
+	///temporary structure for face_to_vert adjacency
+	std::vector<std::vector<ParamVertex*> > face_to_vert;
+
+	void InitFaceToVert()
+	{
+		face_to_vert.resize(abstract_mesh->face.size());
+		for (unsigned int i=0;i<param_mesh->vert.size();i++)
+		{
+			int I=param_mesh->vert[i].T().N();
+			face_to_vert[I].push_back(&param_mesh->vert[i]);
+		}
+	}
+
+
+	void GetHresVert(int &I,std::vector<ParamVertex*> &HresVert)
+	{
+		for (unsigned int k=0;k<face_to_vert[I].size();k++)
+		{
+			ParamVertex* v=face_to_vert[I][k];
+			HresVert.push_back(v);
+		}
+	}
+
+	///initialize star parametrization
+	void InitStar()
+	{
+		///for each vertex
+		int index=0;
+		for (unsigned int i=0;i<abstract_mesh->vert.size();i++)
+		{
+			if (!(abstract_mesh->vert[i].IsD()))
+			{
+				std::vector<AbstractVertex*> starCenter;
+				starCenter.push_back(&abstract_mesh->vert[i]);
+
+				star_meshes[index].domain=new AbstractMesh();
+				star_meshes[index].HresDomain=new ParamMesh();
+
+				///create star
+				std::vector<AbstractFace*> ordered_faces;
+				std::vector<AbstractVertex*> ordered_vert;
+				//CreateMeshVertexStar(starCenter,ordered_faces,*star_meshes[index].domain);
+				///get faces referenced by vertices
+				getSharedFace<AbstractMesh>(starCenter,ordered_faces);
+				
+				CopyMeshFromFacesAbs<AbstractMesh>(ordered_faces,ordered_vert,*star_meshes[index].domain);
+
+				UpdateTopologies(star_meshes[index].domain);
+
+				///and parametrize it
+				ParametrizeStarEquilateral<AbstractMesh>(*star_meshes[index].domain,1.0);
+				
+				///set other components as reefrence to original faces
+				star_meshes[index].local_to_global.resize(star_meshes[index].domain->face.size());
+				std::vector<ParamVertex*> HresVert;
+				for (unsigned int k=0;k<star_meshes[index].domain->face.size();k++)
+				{
+					int IndexF;
+					getFaceIndexFromPointer(ordered_faces[k],IndexF);
+					star_meshes[index].local_to_global[k]=IndexF;
+					///get H res vertex
+					GetHresVert(IndexF,HresVert);
+				}
+				
+				///copy Hres mesh
+				std::vector<ParamVertex*> OrderedVertices;
+				CopyMeshFromVerticesAbs(HresVert,OrderedVertices,star_meshes[index].ordered_faces,*star_meshes[index].HresDomain);
+				///set new parametrization values
+				for (unsigned int k=0;k<star_meshes[index].HresDomain->vert.size();k++)
+				{
+					ParamVertex * v=&star_meshes[index].HresDomain->vert[k];
+					CoordType bary=CoordType(v->T().U(),v->T().V(),1-v->T().U()-v->T().V());
+					AbstractMesh *paramDomain=star_meshes[index].domain;
+					///get the right face on the parametrized domain
+					int Father=v->T().N();
+					int faceNum=-1;
+					for (unsigned int i=0;i<star_meshes[index].local_to_global.size();i++)
+					{
+						if (star_meshes[index].local_to_global[i]==Father)
+							faceNum=i;
+					}
+					AbstractFace *faceDom=&paramDomain->face[faceNum];
+					v->T().P()=(faceDom->V(0)->T().P())*bary.X()+(faceDom->V(1)->T().P())*bary.Y()+(faceDom->V(2)->T().P())*bary.Z();
+					assert(faceNum!=-1);
+				}
+				star_meshes[index].InitGrid();
+				index++;
+				
+			}
+		}		
+	}
+
+
+
+	void InitDiamond(const ScalarType &edge_len=1.0)
+	{
+		
+		///for each face
+		int index=0;
+		EdgeTab.clear();
+		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
+		{
+			if (!(abstract_mesh->face[i].IsD()))
+			{
+				AbstractFace *f0=&abstract_mesh->face[i];
+				//for each edge
+				for (int j=0;j<3;j++)
+				{
+					AbstractFace * f1=f0->FFp(j);
+					if (f1>f0)
+					{
+						
+						int num0=j;
+						int num1=f0->FFi(j);
+
+						///add to domain map
+						AbstractVertex *v0,*v1;
+						v0=f0->V(j);
+						v1=f0->V1(j);
+						keyEdgeType k;
+						if (v0<v1)
+							k=keyEdgeType(v0,v1);
+						else
+							k=keyEdgeType(v1,v0);
+
+						std::pair<keyEdgeType,int> entry=std::pair<keyEdgeType,int>(k,index);
+						EdgeTab.insert(entry);
+
+
+
+						///copy the mesh
+						std::vector<AbstractFace*> faces;
+						faces.push_back(f0);
+						faces.push_back(f1);
+
+						diamond_meshes[index].domain=new AbstractMesh();
+						diamond_meshes[index].HresDomain=new ParamMesh();
+
+						///create a copy of the mesh
+						std::vector<AbstractVertex*> orderedVertex;
+						CopyMeshFromFacesAbs<AbstractMesh>(faces,orderedVertex,*diamond_meshes[index].domain);
+						UpdateTopologies<AbstractMesh>(diamond_meshes[index].domain);
+
+						///set other components
+						int index0,index1;
+						getFaceIndexFromPointer(f0,index0);
+						getFaceIndexFromPointer(f1,index1);
+						diamond_meshes[index].local_to_global.resize(2);
+						diamond_meshes[index].local_to_global[0]=index0;
+						diamond_meshes[index].local_to_global[1]=index1;
+
+						///parametrize locally
+						ParametrizeDiamondEquilateral<AbstractMesh>(*diamond_meshes[index].domain,num0,num1,edge_len);
+						///add h resolution vertices 
+						std::vector<ParamVertex*> HresVert;
+						GetHresVert(index0,HresVert);
+						GetHresVert(index1,HresVert);
+						std::vector<ParamVertex*> OrderedVertices;
+						CopyMeshFromVerticesAbs(HresVert,OrderedVertices,diamond_meshes[index].ordered_faces,*diamond_meshes[index].HresDomain);
+						///set new parametrization values
+						for (unsigned int k=0;k<diamond_meshes[index].HresDomain->vert.size();k++)
+						{
+							ParamVertex * v=&diamond_meshes[index].HresDomain->vert[k];
+							CoordType bary=CoordType(v->T().U(),v->T().V(),1-v->T().U()-v->T().V());
+							AbstractMesh *paramDomain=diamond_meshes[index].domain;
+							///get the rigth face on the parametrized domain
+							int Father=v->T().N();
+							int faceNum=-1;
+							for (unsigned int i=0;i<diamond_meshes[index].local_to_global.size();i++)
+							{
+								if (diamond_meshes[index].local_to_global[i]==Father)
+									faceNum=i;
+							}
+							assert(faceNum!=-1);
+							AbstractFace *faceDom=&paramDomain->face[faceNum];
+							v->T().P()=(faceDom->V(0)->T().P())*bary.X()+(faceDom->V(1)->T().P())*bary.Y()+(faceDom->V(2)->T().P())*bary.Z();
+							
+							
+						}
+						diamond_meshes[index].InitGrid();
+						index++;
+					}
+				}
+			}
+		}
+	}
+
+
+	void InitFace(const ScalarType &edge_len=1)
+	{
+		///for each face
+		int index=0;
+		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
+		{
+			if (!(abstract_mesh->face[i].IsD()))
+			{
+				AbstractFace *f0=&abstract_mesh->face[i];
+
+				std::vector<AbstractFace*> faces;
+				faces.push_back(f0);
+
+				///create the mesh
+				face_meshes[index].domain=new AbstractMesh();
+				face_meshes[index].HresDomain=new ParamMesh();
+
+				std::vector<AbstractVertex*> orderedVertex;
+				CopyMeshFromFacesAbs<AbstractMesh>(faces,orderedVertex,*face_meshes[index].domain);
+
+				assert(face_meshes[index].domain->vn==3);
+				assert(face_meshes[index].domain->fn==1);
+
+				///initialize auxiliary structures
+				face_meshes[index].local_to_global.resize(1);
+				face_meshes[index].local_to_global[0]=i;
+
+				///parametrize it
+				ParametrizeFaceEquilateral<AbstractMesh>(*face_meshes[index].domain,edge_len);
+
+				///add h resolution vertices 
+				std::vector<ParamVertex*> HresVert;
+				GetHresVert(index,HresVert);
+				std::vector<ParamVertex*> OrderedVertices;
+				CopyMeshFromVerticesAbs(HresVert,OrderedVertices,face_meshes[index].ordered_faces,*face_meshes[index].HresDomain);
+				///set new parametrization values
+				for (unsigned int k=0;k<face_meshes[index].HresDomain->vert.size();k++)
+				{
+					ParamVertex * v=&face_meshes[index].HresDomain->vert[k];
+					CoordType bary=CoordType(v->T().U(),v->T().V(),1-v->T().U()-v->T().V());
+					AbstractMesh *paramDomain=face_meshes[index].domain;
+					AbstractFace *faceDom=&paramDomain->face[0];
+					v->T().P()=(faceDom->V(0)->T().P())*bary.X()+(faceDom->V(1)->T().P())*bary.Y()+(faceDom->V(2)->T().P())*bary.Z();
+				}
+
+				face_meshes[index].InitGrid();
+				index++;
+			}
+		}
+	}
+
+	void getFaceIndexFromPointer(AbstractFace * f,int &index)
+	{
+		index=f-&(*abstract_mesh->face.begin());
+	}
+
+	void getStarFromPointer(AbstractVertex * center,int &index)
+	{
+		index=center-&(*abstract_mesh->vert.begin());
+	}
+
+	void getDiamondFromPointer(AbstractVertex * v0,AbstractVertex * v1,int &index)
+	{
+		assert(v0!=v1);
+		keyEdgeType key;
+		if (v0<v1)
+			key=keyEdgeType(v0,v1);
+		else
+			key=keyEdgeType(v1,v0);
+
+		std::map<keyEdgeType,int>::iterator k=EdgeTab.find(key);
+		assert(k!=EdgeTab.end());
+		index=((*k).second);
+	}
+	
+	
+	bool Test()
+	{
+		/*int index=0;*/
+		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
+		{
+			if (!(abstract_mesh->face[i].IsD()))
+			{
+				AbstractFace *f0=&abstract_mesh->face[i];
+				//for each edge
+				for (int j=0;j<3;j++)
+				{
+					AbstractFace * f1=f0->FFp(j);
+					if (f1>f0)
+					{
+						///add to domain map
+						AbstractVertex *v0,*v1;
+						v0=f0->V(j);
+						v1=f0->V1(j);
+						keyEdgeType k;
+						if (v0<v1)
+							k=keyEdgeType(v0,v1);
+						else
+							k=keyEdgeType(v1,v0);
+
+						//std::pair<keyEdgeType,int> entry=std::pair<keyEdgeType,int>(k,index);
+						std::map<keyEdgeType,int>::iterator iteE=EdgeTab.find(k);
+						
+						int index0F,index1F;
+						getFaceIndexFromPointer(f0,index0F);
+						getFaceIndexFromPointer(f1,index1F);
+#ifndef NDEBUG
+						int edgeIndex=(*iteE).second;
+						assert(diamond_meshes[edgeIndex].local_to_global[0]==index0F);
+						assert(diamond_meshes[edgeIndex].local_to_global[1]==index1F);
+#endif
+					}
+				}
+			}
+		}
+		///test if for each face there is a right domain
+		for (unsigned int i=0;i<param_mesh->face.size();i++)
+		{
+			ParamFace * f=&param_mesh->face[i];	
+			vcg::Point2f uvI0,uvI1,uvI2;
+			int IndexDomain=-1;
+			int ret=InterpolationSpace(f,uvI0,uvI1,uvI2,IndexDomain);
+			if (ret==-1)
+				return false;
+		}
+	return true;
+	}
+
+	int getSharedVertices(AbstractFace *f0,AbstractFace *f1,AbstractFace *f2,
+						  AbstractVertex *shared[3])
+	{
+		AbstractVertex *vert0[3],*vert1[3],*vert2[3];
+		
+		vert0[0]=f0->V(0);
+		vert0[1]=f0->V(1);
+		vert0[2]=f0->V(2);
+
+		vert1[0]=f1->V(0);
+		vert1[1]=f1->V(1);
+		vert1[2]=f1->V(2);
+
+		vert2[0]=f2->V(0);
+		vert2[1]=f2->V(1);
+		vert2[2]=f2->V(2);
+		
+		int num=0;
+		for (int i=0;i<3;i++)
+		{
+			AbstractVertex * test=vert0[i];
+			bool found0=false,found1=false;
+			if ((vert1[0]==test)||(vert1[1]==test)||(vert1[2]==test))
+					found0=true;
+			if (found0)
+			{
+				if ((vert2[0]==test)||(vert2[1]==test)||(vert2[2]==test))
+					found1=true;
+			}
+			if ((found0)&&(found1))
+			{
+				shared[num]=test;
+				num++;
+			}
+		}
+
+		return num;
+	}
+	
+	int getSharedVertices(AbstractFace *f0,AbstractFace *f1,AbstractVertex *shared[3])
+	{
+		AbstractVertex *vert0[3],*vert1[3];
+		
+		vert0[0]=f0->V(0);
+		vert0[1]=f0->V(1);
+		vert0[2]=f0->V(2);
+
+		vert1[0]=f1->V(0);
+		vert1[1]=f1->V(1);
+		vert1[2]=f1->V(2);
+
+		
+		int num=0;
+		for (int i=0;i<3;i++)
+		{
+			AbstractVertex * test=vert0[i];
+			bool found0=false;
+			if ((vert1[0]==test)||(vert1[1]==test)||(vert1[2]==test))
+					found0=true;
+			if (found0)
+			{
+				shared[num]=test;
+				num++;
+			}
+		}
+
+		return num;
+	}
+	
+	int getSharedVertices(const std::vector<int> &I,AbstractVertex *shared[3],int *_num=NULL)
+	{	
+		///else test the number of vertices shared 
+		AbstractVertex * shared_vert[3];
+		bool sharedB[3];
+		int size;
+		if (_num==NULL)
+			size=I.size();
+		else
+			size=*_num;
+
+		///quick test for 2 or 3 cases
+		if (size==2)
+			return getSharedVertices(&AbsMesh()->face[I[0]],&AbsMesh()->face[I[1]],shared);
+		else
+		if (size==3)
+			return getSharedVertices(&AbsMesh()->face[I[0]],&AbsMesh()->face[I[1]],&AbsMesh()->face[I[2]],shared);
+
+		AbstractFace* f0=&AbsMesh()->face[I[0]];
+		AbstractVertex *v0=f0->V(0);
+		AbstractVertex *v1=f0->V(1);
+		AbstractVertex *v2=f0->V(2);
+		shared_vert[0]=v0;
+		shared_vert[1]=v1;
+		shared_vert[2]=v2;
+		sharedB[0]=true;
+		sharedB[1]=true;
+		sharedB[2]=true;
+		//for each face
+		for (int i=1;i<size;i++)
+		{
+			AbstractFace* f=&AbsMesh()->face[I[i]];
+			//for each vertex
+			for (int j=0;j<3;j++)
+			{
+				if (sharedB[j])
+				{
+					AbstractVertex *v_test=shared_vert[j];
+					if (!((v_test==f->V(0))||(v_test==f->V(1))||(v_test==f->V(2))))
+						sharedB[j]=false;
+				}	
+			}
+		}
+
+		///return vertices correctly
+		int num=0;
+		for (int i=0;i<3;i++)
+			if (sharedB[i])
+			{
+				shared[num]=shared_vert[i];
+				num++;
+			}
+		return num;
+	}
+
+
+	void Clamp(vcg::Point2f &UV)
+	{
+		float eps=0.00001f;
+		if ((UV.X()<eps)&&(UV.X()>-eps))
+			UV.X()=0;
+		if ((UV.X()<1+eps)&&(UV.X()>1-eps))
+			UV.X()=1;
+		if ((UV.Y()<eps)&&(UV.Y()>-eps))
+			UV.Y()=0;
+		if ((UV.Y()<1+eps)&&(UV.Y()>1-eps))
+			UV.Y()=1;
+	}
+	
+	
+	float Area3d;
+	float AbstractArea;
+
+public:
+	
+	///return the minimum interpolation space shared by a face changing coordinates
+	///return 0 if is a face 1 is a diamaond and 2 is a star
+	int InterpolationSpace(ParamFace *f,
+		vcg::Point2f &uvI0,
+		vcg::Point2f &uvI1,
+		vcg::Point2f &uvI2,
+		int &IndexDomain)
+	{
+		ParamVertex *v0=f->V(0);
+		ParamVertex *v1=f->V(1);
+		ParamVertex *v2=f->V(2);
+
+		int I0=v0->T().N();
+		int I1=v1->T().N();
+		int I2=v2->T().N();
+
+		vcg::Point2f UV0=v0->T().P();
+		vcg::Point2f UV1=v1->T().P();
+		vcg::Point2f UV2=v2->T().P();
+
+		///if they are equal it's is triavially the interpolation of UV coords
+		///and the same face I as the domain
+		if ((I0==I1)&&(I1==I2))
+		{
+			GE2(I0,UV0,uvI0);
+			GE2(I1,UV1,uvI1);
+			GE2(I2,UV2,uvI2);
+			IndexDomain=I0;
+			return 0;
+		}
+
+		///else find the right interpolation domain in which the face belongs
+		///test if they share an edge then use half diamond
+		AbstractFace *f0=&abstract_mesh->face[I0];
+		AbstractFace *f1=&abstract_mesh->face[I1];
+		AbstractFace *f2=&abstract_mesh->face[I2];
+		AbstractVertex *shared[3];
+
+		int num=getSharedVertices(f0,f1,f2,shared);
+		if (num<1)
+		{
+			return -1;
+		}
+		//assert((num==1)||(num==2));
+		if (num==2)///ude diamond
+		{
+			AbstractVertex* v0=shared[0];
+			AbstractVertex* v1=shared[1];
+			int EdgeIndex;
+
+			getDiamondFromPointer(v0,v1,EdgeIndex);			
+
+			GE1(I0,UV0,EdgeIndex,uvI0);
+			GE1(I1,UV1,EdgeIndex,uvI1);
+			GE1(I2,UV2,EdgeIndex,uvI2);
+
+			IndexDomain=EdgeIndex;
+			return 1;
+		}
+
+		///use the star domain
+
+		AbstractVertex* center=shared[0];
+		int StarIndex;
+		getStarFromPointer(center,StarIndex);
+		bool b0=GE0(I0,UV0,StarIndex,uvI0);
+		bool b1=GE0(I1,UV1,StarIndex,uvI1);
+		bool b2=GE0(I2,UV2,StarIndex,uvI2);
+		IndexDomain=StarIndex;
+		if ((!b0)||(!b1)||(!b2))
+		{
+			printf("AZZZ 1\n");
+			return -1;
+		}
+		assert((uvI0.X()>=-1)&&(uvI0.Y()>=-1)&&(uvI0.X()<=1)&&(uvI0.Y()<=1));
+		assert((uvI1.X()>=-1)&&(uvI1.Y()>=-1)&&(uvI1.X()<=1)&&(uvI1.Y()<=1));
+		assert((uvI2.X()>=-1)&&(uvI2.Y()>=-1)&&(uvI2.X()<=1)&&(uvI2.Y()<=1)); 
+
+		
+
+		return 2;
+
+	}
+	
+	///return the minimum interpolation space shared by two faces of abstarct domain
+	///return 0 if is a face 1 is a diamaond and 2 is a star
+	int InterpolationSpace(const int &I0,const int &I1,int &IndexDomain)
+	{
+		///that case is the face itself
+		if (I0==I1)
+		{
+			IndexDomain=I0;
+			return 0;
+		}
+		AbstractFace* f0=&AbsMesh()->face[I0];
+		AbstractFace* f1=&AbsMesh()->face[I1];
+	/*	AbstractVertex *v0=f0->V(0);
+		AbstractVertex *v1=f0->V(1);
+		AbstractVertex *v2=f0->V(2);
+		AbstractVertex *v3=f1->V(0);
+		AbstractVertex *v4=f1->V(1);
+		AbstractVertex *v5=f1->V(2);*/
+
+		
+		AbstractVertex *shared[3];
+
+		int num=getSharedVertices(f0,f1,shared);
+		if (!((num==1)||(num==2)))
+			return -1;
+		if (num==2)///use diamond
+		{
+			AbstractVertex* v0=shared[0];
+			AbstractVertex* v1=shared[1];
+			int EdgeIndex;
+
+			getDiamondFromPointer(v0,v1,EdgeIndex);
+
+			IndexDomain=EdgeIndex;
+			return 1;
+		}
+
+		///use the star domain
+
+		AbstractVertex* center=shared[0];
+		int StarIndex;
+		getStarFromPointer(center,StarIndex);
+		IndexDomain=StarIndex;
+
+		return 2;
+
+	}
+	
+	///return 0 if is a face 1 is a diamaond and 2 is a star
+	int InterpolationSpace(const std::vector<int> &I,int &IndexDomain,int *_num=NULL)
+	{
+		int size;
+		if (_num==NULL)
+			size=I.size();
+		else
+			size=*_num;
+
+		///simple cases
+		assert(I.size()>0);
+		///1 element
+		if (size==1)
+		{
+			IndexDomain=I[0];
+			return 0;
+		}
+		///2 elements
+		if (size==2)
+			return InterpolationSpace(I[0],I[1],IndexDomain);
+
+		///test if they all are the same
+		///that case is the face itself
+		bool sameface=true;
+		int i=1;
+		int I0=I[0];
+		while ((i<size)&&(sameface))
+		{
+			sameface&=(I[i]==I0);
+			i++;
+		}
+		if (sameface)
+		{
+			IndexDomain=I0;
+			return 0;
+		}
+
+		///else test the number of vertices shared 
+		AbstractVertex *shared[3];
+		int num=getSharedVertices(I,shared,_num);
+		assert(num!=3); ///no same yet face possible
+		if (num==0)
+			return -1;  ///no interpolation space exists
+
+		if (num==2)///ude diamond
+		{
+			AbstractVertex* v0=shared[0];
+			AbstractVertex* v1=shared[1];
+			int EdgeIndex;
+
+			getDiamondFromPointer(v0,v1,EdgeIndex);
+
+			IndexDomain=EdgeIndex;
+			return 1;
+		}
+
+		///use the star domain
+
+		AbstractVertex* center=shared[0];
+		int StarIndex;
+		getStarFromPointer(center,StarIndex);
+		IndexDomain=StarIndex;
+
+		return 2;
+
+	}
+
+	int getHStarIndex(const int &I,
+		const vcg::Point2<ScalarType> &UV)
+	{
+		int vertStar=2;
+		CoordType bary=CoordType(UV.X(),UV.Y(),(ScalarType)1.0-UV.X()-UV.Y());
+
+		if ((bary.X()>bary.Y())&&(bary.X()>bary.Z()))
+			vertStar=0;
+		else
+			if ((bary.Y()>bary.X())&&(bary.Y()>bary.Z()))
+				vertStar=1;
+
+		AbstractFace *f=&abstract_mesh->face[I];
+		AbstractVertex *Center=f->V(vertStar);
+
+		int StarIndex;
+		getStarFromPointer(Center,StarIndex);
+		return StarIndex;
+	}
+
+	int getHDiamIndex(const int &I,
+		const vcg::Point2<ScalarType> &UV)
+	{
+		CoordType bary=CoordType(UV.X(),UV.Y(),1-UV.X()-UV.Y());
+		ScalarType sum0=bary.X()+bary.Y();
+		ScalarType sum1=bary.Y()+bary.Z();
+		ScalarType sum2=bary.X()+bary.Z();
+		int edge=2;
+		if ((sum0>sum1)&&(sum0>sum2))
+			edge=0;
+		else
+			if ((sum1>sum0)&&(sum1>sum2))
+				edge=1;
+
+		///get the half-diamond mesh
+		int DiamIndex;
+		getDiamondFromPointer(abstract_mesh->face[I].V(edge),abstract_mesh->face[I].V1(edge),DiamIndex);
+		return(DiamIndex);
+	}
+
+	///give the face and barycentric coordinate return I and UV coordinates
+	void Phi(const ParamFace *f,
+		const CoordType &bary3D,
+		int &I,
+		vcg::Point2<ScalarType> &UV)
+	{
+#ifndef NDEBUG
+		float eps=0.00001f;
+#endif
+		///control right domain
+		int I0=f->V(0)->T().N();
+		int I1=f->V(1)->T().N();
+		int I2=f->V(2)->T().N();
+
+		///if they are equal it's is triavially the interpolation of UV coords
+		///and the same face I as the domain
+		if ((I0==I1)&&(I1==I2))
+		{
+			UV=bary3D.X()*f->V(0)->T().P()+bary3D.Y()*f->V(1)->T().P()+bary3D.Z()*f->V(2)->T().P();
+			Clamp(UV);
+			assert((UV.X()>=0)&&(UV.Y()>=0)&&(UV.X()<=1)&&(UV.Y()<=1)&&(UV.X()+UV.Y()<=1));
+			I=I0;
+			return;
+		}
+		
+
+		///else find the right interpolation domain in which the face belongs
+		///test if they share an edge then use half diamond
+		AbstractFace *f0=&abstract_mesh->face[I0];
+		AbstractFace *f1=&abstract_mesh->face[I1];
+		AbstractFace *f2=&abstract_mesh->face[I2];
+		AbstractVertex *shared[3];
+
+		int num=getSharedVertices(f0,f1,f2,shared);
+
+		/*///if num==1
+		if (num==0)
+		{
+			float alpha=bary3D.X();
+			float beta =bary3D.Y();
+			float gamma=bary3D.Z();
+#ifndef _MESHLAB
+			printf("problems with interpolation, solved...");
+#endif
+			if ((alpha>beta)&&(alpha>gamma))
+			{
+				I=I0;
+				UV=f->V(0)->T().P();
+			}
+			else
+			if ((beta>alpha)&&(beta>gamma))
+			{
+				I=I1;
+				UV=f->V(1)->T().P();
+			}
+			else
+			{
+				I=I2;
+				UV=f->V(2)->T().P();
+			}
+			
+			return;
+		}*/
+
+		assert((num==1)||(num==2));
+		if ((num!=1)&&(num!=2))
+		{
+			printf("DOMAIN %d\n",num);
+			assert(0);
+		}
+		if (num==1)///use the star domain
+		{
+			//printf("phi 0\n");
+			AbstractVertex* center=shared[0];
+			int StarIndex;
+			getStarFromPointer(center,StarIndex);
+			vcg::Point2<ScalarType> UVs0,UVs1,UVs2;
+			vcg::Point2<ScalarType> UV0=f->V(0)->T().P();
+			vcg::Point2<ScalarType> UV1=f->V(1)->T().P();
+			vcg::Point2<ScalarType> UV2=f->V(2)->T().P();
+
+			GE0(I0,UV0,StarIndex,UVs0);
+			GE0(I1,UV1,StarIndex,UVs1);
+			GE0(I2,UV2,StarIndex,UVs2);
+			assert((UVs0.X()>=-1)&&(UVs0.Y()>=-1)&&(UVs0.X()<=1)&&(UVs0.Y()<=1));
+			assert((UVs1.X()>=-1)&&(UVs1.Y()>=-1)&&(UVs1.X()<=1)&&(UVs1.Y()<=1));
+			assert((UVs2.X()>=-1)&&(UVs2.Y()>=-1)&&(UVs2.X()<=1)&&(UVs2.Y()<=1));
+
+			///interpolate star value
+			vcg::Point2<ScalarType> UV_interp=bary3D.X()*UVs0+bary3D.Y()*UVs1+bary3D.Z()*UVs2;
+			inv_GE0(StarIndex,UV_interp,I,UV);
+			Clamp(UV);
+			assert((UV.X()>=0)&&(UV.Y()>=0)&&(UV.X()<=1)&&(UV.Y()<=1)&&(UV.X()+UV.Y()<=1+eps));
+			return;
+		}
+		else			///use the diamond domain
+		{
+			//printf("phi 1\n");
+			//std::set<AbstractVertex*>::iterator it=temp2.begin();
+			//std::vector<AbstractVertex*>::iterator it=shared[0];
+			AbstractVertex* v0=shared[0];
+			//it++;
+			AbstractVertex* v1=shared[1];
+			int EdgeIndex;
+			getDiamondFromPointer(v0,v1,EdgeIndex);
+
+			vcg::Point2<ScalarType> UVd0,UVd1,UVd2;
+			vcg::Point2<ScalarType> UV0=f->V(0)->T().P();
+			vcg::Point2<ScalarType> UV1=f->V(1)->T().P();
+			vcg::Point2<ScalarType> UV2=f->V(2)->T().P();
+
+			GE1(I0,UV0,EdgeIndex,UVd0);
+			GE1(I1,UV1,EdgeIndex,UVd1);
+			GE1(I2,UV2,EdgeIndex,UVd2);
+
+			///interpolate star value
+			vcg::Point2<ScalarType> UV_interp=bary3D.X()*UVd0+bary3D.Y()*UVd1+bary3D.Z()*UVd2;
+			inv_GE1(EdgeIndex,UV_interp,I,UV);
+			Clamp(UV);
+			assert((UV.X()>=0)&&(UV.Y()>=0)&&(UV.X()<=1)&&(UV.Y()<=1)&&(UV.X()+UV.Y()<=1+eps));
+			assert((I==I0)||(I==I1)||(I==I2));
+			return;
+		}
+
+	}
+
+	///given the I and UV coordinates return the face and barycentric coords
+	///return the domain used for interpolation 0=face 1=half diam 2=half star
+	int Theta(const int &I,
+		const vcg::Point2<ScalarType> &UV, // alphaBeta
+		std::vector<ParamFace*> &face,
+		std::vector<CoordType> &baryVal)
+	{
+		#ifndef NDEBUG
+		const ScalarType eps=(ScalarType)0.0001;
+		#endif
+		assert(UV.X()<=1);
+		assert(UV.Y()<=1);
+		assert(UV.X()>=0);
+		assert(UV.Y()>=0);
+		//printf("%f,%f \n",UV.X(),UV.Y());
+		assert((UV.X()+UV.Y())<=(1+eps));
+		
+		//printf("%f,%f \n",UV.X(),UV.Y());
+		///FACE SEARCH
+		///first test if is in the face domain 
+		//printf("face\n");
+		bool found=false;
+		int indexFace=I;
+		/*if (indexFace>=face_meshes.size())
+			printf("B");*/
+
+		vcg::Point2<ScalarType> UVFace;
+		GE2(indexFace,UV,UVFace);
+		found=face_meshes[indexFace].Project(UVFace,face,baryVal);
+		if (found)
+			return 0;
+		
+		///DIAMOND SEARCH
+		///search in the diamond domain
+		//printf("diam\n");
+		int indexDiam=getHDiamIndex(I,UV);///get diamond index
+		vcg::Point2<ScalarType> UVDiam;
+		///transform UV coordids in diamond
+		GE1(I,UV,indexDiam,UVDiam);
+		/*if (indexDiam>=diamond_meshes.size())*/
+			/*printf("C");*/
+		found=diamond_meshes[indexDiam].Project(UVDiam,face,baryVal);
+		if (found)
+			return 1;
+
+		///STAR SEARCH
+		//printf("star\n");
+		int indexStar=getHStarIndex(I,UV);///get star index
+		vcg::Point2<ScalarType> UVStar;
+		///transform UV coords in star
+		GE0(I,UV,indexStar,UVStar);
+		found=star_meshes[indexStar].Project(UVStar,face,baryVal);
+		if (!found)
+		{
+			//printf("\n problems projecting u,v:%lf,%lf (RESOLVED)\n",UV.X(),UV.Y());
+#ifndef NDEBUG
+			bool found=star_meshes[indexStar].getClosest(UVStar,face,baryVal);
+			assert(found);
+#else
+			star_meshes[indexStar].getClosest(UVStar,face,baryVal);
+			/*printf("D");*/
+#endif
+		}
+		return 2;
+	}
+	
+	///given the I and UV coordinates return the face and barycentric coords
+	///return the domain used for interpolation 0=face 1=half diam 2=half star
+	int Theta(const int &I,
+		const vcg::Point2<ScalarType> &UV, // alphaBeta
+		ParamFace* &face,
+		CoordType &baryVal)
+	{
+		std::vector<ParamFace*> faces;
+		std::vector<CoordType>  baryVals;
+		int ret=Theta(I,UV,faces,baryVals);
+		if (ret!=-1)
+		{
+			face=faces[0];
+			baryVal=baryVals[0];
+		}
+		return ret;
+	}
+
+	///given the I and UV coordinates return the face and barycentric coords
+	///return the domain used for interpolation 0=face 1=half diam 2=half star
+	///and 3D Coordinates
+	int Theta(const int &I,
+		const vcg::Point2<ScalarType> &UV,
+		CoordType &pos3D)
+	{
+		std::vector<ParamFace*> face;
+		std::vector<CoordType> baryVal;
+			
+		int ret=Theta(I,UV,face,baryVal);
+			
+		pos3D=CoordType(0,0,0);
+		for (int i=0;i<(int)face.size();i++)
+		{
+			CoordType pos=face[i]->V(0)->P()*baryVal[i].X()+
+						  face[i]->V(1)->P()*baryVal[i].Y()+
+						  face[i]->V(2)->P()*baryVal[i].Z();
+			pos3D+=pos;
+		}
+		
+		pos3D/=(ScalarType)face.size();
+		return ret;
+	}
+
+	///return the coordinate on the half star domain
+	bool GE0(const int &I,
+		const vcg::Point2<ScalarType> &UV,
+		const int &StarIndex,
+		vcg::Point2<ScalarType> &UVHstar)
+	{
+		//int vertStar=2;
+		CoordType bary=CoordType(UV.X(),UV.Y(),1-UV.X()-UV.Y());
+
+		///then transform to the star domain
+
+		///get star mesh
+		AbstractMesh* star_domain=star_meshes[StarIndex].domain;
+		int LocalIndex=star_meshes[StarIndex].Global2Local(I);
+		if (LocalIndex==-1)
+			return false;
+
+		GetUV<AbstractMesh>(&star_domain->face[LocalIndex],bary,UVHstar.X(),UVHstar.Y());
+		return true;
+	}
+
+	///return the coordinate on the half star domain
+	bool inv_GE0(int &StarIndex,
+		vcg::Point2<ScalarType> &UVHstar,
+		int &I,
+		vcg::Point2<ScalarType> &UV)
+	{
+		AbstractMesh* star_domain=star_meshes[StarIndex].domain;
+		CoordType bary;
+		int index;
+		bool done=GetBaryFaceFromUV(*star_domain,UVHstar.X(),UVHstar.Y(),bary,index);
+		if (!done)
+			return false;
+		UV.X()=bary.X();
+		UV.Y()=bary.Y();
+		I=star_meshes[StarIndex].Local2Global(index);
+		return done;
+	}
+
+
+	void InterpParam(vcg::Point2f p1,vcg::Point2f p2,vcg::Point2f p3,vcg::Point2f p_test,
+					 ScalarType &b1,ScalarType &b2,ScalarType &b3)
+	{
+		ScalarType x0=p_test.X();
+		ScalarType y0=p_test.Y();
+		ScalarType x1=p1.X();
+		ScalarType y1=p1.Y();
+		ScalarType x2=p2.X();
+		ScalarType y2=p2.Y();
+		ScalarType x3=p3.X();
+		ScalarType y3=p3.Y();
+		
+		ScalarType b0 =  (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1);
+		b1 = ((x2 - x0) * (y3 - y0) - (x3 - x0) * (y2 - y0)) / b0;
+		b2 = ((x3 - x0) * (y1 - y0) - (x1 - x0) * (y3 - y0)) / b0;
+		b3 = ((x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0)) / b0;
+	}
+
+	///return the coordinate on the half diamond domain
+	void GE1(const int &I,
+		const vcg::Point2<ScalarType> &UV,
+		const int &DiamIndex,
+		vcg::Point2<ScalarType> &UVDiam)
+	{
+		///get the right edge index
+		CoordType bary=CoordType(UV.X(),UV.Y(),1-UV.X()-UV.Y());
+		
+		///then transform to the half-diamond domain
+		///get egde mesh
+		AbstractMesh* diam_domain=diamond_meshes[DiamIndex].domain;
+		int LocalIndex=diamond_meshes[DiamIndex].Global2Local(I);
+		if(LocalIndex!=-1)
+		{
+			GetUV<AbstractMesh>(&diam_domain->face[LocalIndex],bary,UVDiam.X(),UVDiam.Y());
+			return;
+		}
+		///if ! found seach in the star space
+		else
+		{
+			AbstractFace *f_diam=&diam_domain->face[0];
+			int indexF0=diamond_meshes[DiamIndex].Local2Global(0);
+			int indexF1=diamond_meshes[DiamIndex].Local2Global(1);
+
+			//getFaceIndexFromPointer(f0,indexF0);
+			vcg::Point2<ScalarType> UVHstar;
+			//int StarIndex=getHStarIndex(I,UV);
+			int StarIndex=getHStarIndex(I,UV);
+			///get star coordinates
+#ifndef NDEBUG
+			bool found=GE0(I,UV,StarIndex,UVHstar);
+			assert(found);
+#else
+			GE0(I,UV,StarIndex,UVHstar);
+#endif
+
+			///then find which face is in the star
+			int indexParam;
+			int indexParam0=star_meshes[StarIndex].Global2Local(indexF0);
+			int indexParam1=star_meshes[StarIndex].Global2Local(indexF1);
+			if(indexParam0==-1)
+				indexParam=indexParam1;
+			else
+				indexParam=indexParam0;
+			
+			AbstractFace *f_param=&star_meshes[StarIndex].domain->face[indexParam];
+			vcg::Point2f p0=f_param->V(0)->T().P();
+			vcg::Point2f p1=f_param->V(1)->T().P();
+			vcg::Point2f p2=f_param->V(2)->T().P();
+			
+			vcg::Point3f coord;
+			//bool inside=vcg::InterpolationParameters2<float>(p0,p1,p2,UVHstar,coord);
+			InterpParam(p0,p1,p2,UVHstar,coord.X(),coord.Y(),coord.Z());
+			///finally reinterpolate in diamond space
+			UVDiam=coord.X()*f_diam->V(0)->T().P()+coord.Y()*f_diam->V(1)->T().P()+coord.Z()*f_diam->V(2)->T().P();
+			return;
+		}
+		//CoordType bary=CoordType(UV.X(),UV.Y(),1-UV.X()-UV.Y());
+		
+	}
+
+	///given the diamond coordinates return the coordinates in the parametrization space
+	void inv_GE1(const int &DiamIndex,
+		const vcg::Point2<ScalarType> &UVDiam,
+		int &I,
+		vcg::Point2<ScalarType> &UV)
+	{
+		AbstractMesh* diam_domain=diamond_meshes[DiamIndex].domain;
+		CoordType bary;
+		int index;
+#ifndef NDEBUG
+		bool done=GetBaryFaceFromUV(*diam_domain,UVDiam.X(),UVDiam.Y(),bary,index);
+		assert(done);
+#else
+		GetBaryFaceFromUV(*diam_domain,UVDiam.X(),UVDiam.Y(),bary,index);
+#endif
+		UV.X()=bary.X();
+		UV.Y()=bary.Y();
+		I=diamond_meshes[DiamIndex].Local2Global(index);
+		
+	}
+	
+	///given the diamond coordinates return the coordinates in the parametrization space
+	///in this case I is fixed and should falls also outside the face I
+	void inv_GE1_fixedI(const int &DiamIndex,
+		const vcg::Point2<ScalarType> &UVDiam,
+		const int &I,
+		vcg::Point2<ScalarType> &bary)
+	{
+		/*AbstractMesh* diam_domain=diamond_meshes[DiamIndex].domain;*/
+		//int index;
+		CoordType bary3d;
+		///then find barycentryc coordinates with respect to such face
+		int local_face=diamond_meshes[DiamIndex].Global2Local(I);
+		AbstractFace* f=&diamond_meshes[DiamIndex].domain->face[local_face];
+		vcg::Point2<ScalarType> p0=f->V(0)->T().P();
+		vcg::Point2<ScalarType> p1=f->V(1)->T().P();
+		vcg::Point2<ScalarType> p2=f->V(2)->T().P();
+		InterpParam(p0,p1,p2,UVDiam,bary3d.X(),bary3d.Y(),bary3d.Z());
+		bary.X()=bary3d.X();
+		bary.Y()=bary3d.Y();
+	}
+	
+	///given the star return the coordinates in the parametrization space
+	///in this case I is fixed and should falls also outside the face I
+	void inv_GE0_fixedI(const int &StarIndex,
+		const vcg::Point2<ScalarType> &UVStar,
+		const int &I,
+		vcg::Point2<ScalarType> &bary)
+	{
+		//AbstractMesh* star_domain=star_meshes[StarIndex].domain;
+		/*int index;*/
+		CoordType bary3d;
+		///then find barycentryc coordinates with respect to such face
+		int local_face=star_meshes[StarIndex].Global2Local(I);
+		AbstractFace* f=&star_meshes[StarIndex].domain->face[local_face];
+		vcg::Point2<ScalarType> p0=f->V(0)->T().P();
+		vcg::Point2<ScalarType> p1=f->V(1)->T().P();
+		vcg::Point2<ScalarType> p2=f->V(2)->T().P();
+		InterpParam(p0,p1,p2,UVStar,bary3d.X(),bary3d.Y(),bary3d.Z());
+		bary.X()=bary3d.X();
+		bary.Y()=bary3d.Y();
+	}
+
+	///given the diamond coordinates AS A QUAD return the coordinates in the parametrization space
+	void inv_GE1Quad(const int &DiamIndex,
+					const vcg::Point2<ScalarType> &UVQuad,
+					int &I,
+					vcg::Point2<ScalarType> &UV)
+	{
+		assert((UVQuad.X()>=0)&&(UVQuad.X()<=1));
+		assert((UVQuad.Y()>=0)&&(UVQuad.Y()<=1));
+
+		///get the abstract mesh
+		AbstractMesh* diam_domain=diamond_meshes[DiamIndex].domain;
+		///get the 4 vertices on the full diamond
+
+		///transform in diamond coordinates
+		vcg::Point2<ScalarType> c0=vcg::Point2<ScalarType>(0,(ScalarType)-0.5);
+		vcg::Point2<ScalarType> c1=vcg::Point2<ScalarType>((sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
+		vcg::Point2<ScalarType> c2=vcg::Point2<ScalarType>(0,(ScalarType)0.5);
+		vcg::Point2<ScalarType> c3=vcg::Point2<ScalarType>(-(sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
+
+		///get 2 directions
+		vcg::Point2<ScalarType> v0=c1-c0;
+		//v0.Normalize();
+		vcg::Point2<ScalarType> v1=c3-c0;
+		//v1.Normalize();
+		
+		///value in diamond coordinates
+		vcg::Point2<ScalarType> UVDiam=c0+UVQuad.X()*v0;
+		vcg::Point2<ScalarType> diry=UVQuad.Y()*v1;
+		UVDiam=UVDiam+diry;
+		
+		//printf("Diamond: %d,%f,%f \n",DiamIndex,UVDiam.X(),UVDiam.Y());
+
+		int index;
+		CoordType bary;
+#ifndef NDEBUG
+		bool done=GetBaryFaceFromUV(*diam_domain,UVDiam.X(),UVDiam.Y(),bary,index);
+#else
+		GetBaryFaceFromUV(*diam_domain,UVDiam.X(),UVDiam.Y(),bary,index);
+#endif
+		UV.X()=bary.X();
+		UV.Y()=bary.Y();
+
+		I=diamond_meshes[DiamIndex].Local2Global(index);
+		assert(done);
+	}
+	
+	///TO RESCALE?
+	///given the coordinates in the parametrization space return return the coordinates AS A QUAD 
+	void GE1Quad(const int &I,
+				 const vcg::Point2<ScalarType> &UV,
+				 int &DiamIndex,
+				 vcg::Point2<ScalarType> &UVQuad)
+	{
+		///first get the right half diamond index
+		DiamIndex=getHDiamIndex(I,UV);
+		
+		///transform in diamond space
+		vcg::Point2<ScalarType> UVDiam;
+		GE1(I,UV,DiamIndex,UVDiam);
+		
+		///transform in diamond coordinates
+		vcg::Point2<ScalarType> c0=vcg::Point2<ScalarType>(0,(ScalarType)-0.5);
+		vcg::Point2<ScalarType> c1=vcg::Point2<ScalarType>((sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
+		vcg::Point2<ScalarType> c2=vcg::Point2<ScalarType>(0,(ScalarType)0.5);
+		vcg::Point2<ScalarType> c3=vcg::Point2<ScalarType>(-(sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
+
+		///get 2 directions
+		vcg::Point2<ScalarType> v0=c1-c0;
+		//v0.Normalize();
+		vcg::Point2<ScalarType> v1=c3-c0;
+		//v1.Normalize();
+		
+		///translate respect to zero
+		UVDiam-=c0;
+
+		///then transform in new coordspace
+		UVQuad.X()=v0.X()*UVDiam.X()+v0.Y()*UVDiam.Y();
+		UVQuad.Y()=v1.X()*UVDiam.X()+v1.Y()*UVDiam.Y();
+
+	}
+	
+	///given the diamond coordinates return return the coordinates AS A QUAD 
+	void GE1Quad(const int &/*DiamIndex*/,
+				 const vcg::Point2<ScalarType> &UVDiam,
+				 vcg::Point2<ScalarType> &UVQuad)
+	{
+		//assert(UVDiam.Y()<0);
+		///transform in diamond coordinates
+		vcg::Point2<ScalarType> c0=vcg::Point2<ScalarType>(0,(ScalarType)-0.5);
+		vcg::Point2<ScalarType> c1=vcg::Point2<ScalarType>((sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
+		vcg::Point2<ScalarType> c2=vcg::Point2<ScalarType>(0,(ScalarType)0.5);
+		vcg::Point2<ScalarType> c3=vcg::Point2<ScalarType>(-(sqrt((ScalarType)3.0)/(ScalarType)6.0),0);
+		
+		///get 2 directions
+		vcg::Point2<ScalarType> v0=c1-c0;
+		vcg::Point2<ScalarType> v1=c3-c0;
+		
+		///translate respect to zero
+		vcg::Point2<ScalarType> temp=UVDiam;
+		//temp=c3;
+		temp-=c0;
+		ScalarType det=(ScalarType)1.0/(v0.X()*v1.Y()-v1.X()*v0.Y());
+		///then transform in new coordspace
+		UVQuad.X()=v1.Y()*temp.X()-v1.X()*temp.Y();
+		UVQuad.Y()=-v0.Y()*temp.X()+v0.X()*temp.Y();
+		UVQuad.X()*=det;
+		UVQuad.Y()*=det;
+	/*	printf("UVtr1=%f, %f \n",UVQuad.X(),UVQuad.Y());
+		system("pause");*/
+	}
+
+	///return the coordinate on the face domain
+	void GE2(const int &I,
+		const vcg::Point2<ScalarType> &UV,
+		vcg::Point2<ScalarType> &UVFace)
+	{
+		///get the right edge index
+		CoordType bary=CoordType(UV.X(),UV.Y(),1-UV.X()-UV.Y());
+		
+		///then transform to the face domain
+		///get face mesh
+		AbstractMesh* face_domain=face_meshes[I].domain;
+		AbstractFace* f=&(face_domain->face[0]);
+
+		UVFace=bary.X()*f->V(0)->T().P()+bary.Y()*f->V(1)->T().P()+bary.Z()*f->V(2)->T().P();
+	}
+
+	///given the face coordinates return the coordinates in the parametrization space
+	void inv_GE2(const int &FaceIndex,
+		const vcg::Point2<ScalarType> &UVFace,
+		vcg::Point2<ScalarType> &UV)
+	{
+		AbstractMesh* face_domain=face_meshes[FaceIndex].domain;
+		CoordType bary;
+		int index;
+#ifndef NDEBUG
+		bool done=GetBaryFaceFromUV(*face_domain,UVFace.X(),UVFace.Y(),bary,index);
+		assert(done);
+#else
+		GetBaryFaceFromUV(*face_domain,UVFace.X(),UVFace.Y(),bary,index);
+#endif
+		UV.X()=bary.X();
+		UV.Y()=bary.Y();
+
+	}
+
+	void Clear()
+	{
+		face_to_vert.clear();
+		star_meshes.clear();
+		face_meshes.clear();
+		diamond_meshes.clear();
+	}
+
+	bool Update(bool test=true)
+	{
+		UpdateTopologies(abstract_mesh);
+		UpdateTopologies(param_mesh);
+		float fix_num=sqrt((ScalarType)3.0)/(ScalarType)4.0;
+
+		int edge_count=0;
+		///cont number of edges
+		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
+		{
+			if (!(abstract_mesh->face[i].IsD()))
+			{
+				AbstractFace *f0=&abstract_mesh->face[i];
+				//for each edge
+				for (int j=0;j<3;j++)
+				{
+					AbstractFace * f1=f0->FFp(j);
+					if (f1>f0)
+						edge_count++;
+				}
+			}
+		}
+
+		///test param mesh
+		for (unsigned int i=0;i<param_mesh->vert.size();i++)
+		{
+			if (!(param_mesh->vert[i].IsD()))
+			{
+				ParamVertex *v0=&param_mesh->vert[i];
+				ParamMesh::CoordType bary=ParamMesh::CoordType(v0->T().U(),v0->T().V(),1-v0->T().U()-v0->T().V());
+				int patchNum=v0->T().N();
+				if (!testBaryCoords(bary))
+					return false;
+				if (patchNum<0)
+					return false;
+				if (patchNum>AbsMesh()->fn)
+					return false;
+			}
+		}
+		Area3d=vcg::tri::Stat<ParamMesh>::ComputeMeshArea(*param_mesh);
+		AbstractArea=(ScalarType)abstract_mesh->fn*fix_num;
+		
+		face_to_vert.clear();
+		star_meshes.clear();
+		face_meshes.clear();
+		diamond_meshes.clear();
+		star_meshes.resize(abstract_mesh->vn);
+		face_meshes.resize(abstract_mesh->fn);
+		diamond_meshes.resize(edge_count);
+		InitFaceToVert();
+		InitFace();
+		InitDiamond();
+		InitStar();
+		if (test)
+			return (Test());
+		return true;
+	}
+
+	bool Init(AbstractMesh * _abstract_mesh,
+			  ParamMesh	 * _param_mesh,bool test=true)
+	{
+		
+		abstract_mesh=_abstract_mesh;
+		param_mesh=_param_mesh;
+
+		UpdateTopologies(abstract_mesh);
+		UpdateTopologies(param_mesh);
+		
+		return (Update(test));
+	}
+	
+	AbstractMesh *&AbsMesh(){return abstract_mesh;} 
+	ParamMesh	 *&ParaMesh(){return param_mesh;} 
+
+	///given the index of face and the index of the edge return the 
+	///index of diamond
+	int GetDiamond(const int &I,const int & edge)
+	{
+		AbstractVertex *v0=AbsMesh()->face[I].V0(edge);
+		AbstractVertex *v1=AbsMesh()->face[I].V1(edge);
+		int index;
+		getDiamondFromPointer(v0,v1,index);
+		return index;
+	}
+
+	int GetStarIndex(const int &I,const int & indexV)
+	{
+		AbstractVertex *v=AbsMesh()->face[I].V(indexV);
+		int index;
+		getStarFromPointer(v,index);
+		return index;
+	}
+
+	void SaveBaseDomain(char *pathname)
+	{
+		/*vcg::tri::io::ExporterPLY<AbstractMesh>::Save(*AbsMesh(),pathname);*/
+		/*Warp(0);*/
+		FILE *f;
+		f=fopen(pathname,"w+");
+	
+		std::map<AbstractVertex*,int> vertexmap;
+		typedef std::map<AbstractVertex*,int>::iterator iteMapVert;
+
+		///add vertices
+		fprintf(f,"%d,%d \n",AbsMesh()->fn,AbsMesh()->vn);
+		int index=0;
+		for (unsigned int i=0;i<AbsMesh()->vert.size();i++)
+		{
+			AbstractVertex* vert=&AbsMesh()->vert[i];
+			if (!vert->IsD())
+			{
+				vertexmap.insert(std::pair<AbstractVertex*,int>(vert,index));
+				CoordType pos=vert->P();
+				CoordType RPos=vert->RPos;
+				fprintf(f,"%f,%f,%f;\n",pos.X(),pos.Y(),pos.Z());
+				index++;
+			}
+		}
+
+		///add faces
+		for (unsigned int i=0;i<AbsMesh()->face.size();i++)
+		{
+			AbstractFace* face=&AbsMesh()->face[i];
+			if (!face->IsD())
+			{
+				AbstractVertex* v0=face->V(0);
+				AbstractVertex* v1=face->V(1);
+				AbstractVertex* v2=face->V(2);
+				iteMapVert vertIte;
+				vertIte=vertexmap.find(v0);
+				assert(vertIte!=vertexmap.end());
+				int index0=(*vertIte).second;
+				vertIte=vertexmap.find(v1);
+				assert(vertIte!=vertexmap.end());
+				int index1=(*vertIte).second;
+				vertIte=vertexmap.find(v2);
+				assert(vertIte!=vertexmap.end());
+				int index2=(*vertIte).second;
+				assert((index0!=index1)&&(index1!=index2));
+				fprintf(f,"%d,%d,%d \n",index0,index1,index2);
+			}
+		}
+		fclose(f);
+	}
+
+	template <class MeshType>
+	bool SetParamMesh(MeshType	*_input_mesh,
+										ParamMesh	 * _param_mesh)
+	{
+		param_mesh=_param_mesh;
+		param_mesh->Clear();
+		vcg::tri::Append<ParamMesh,MeshType>::Mesh(*param_mesh,*_input_mesh);
+		return(Update(true));
+	}
+
+	template <class MeshType>
+	bool LoadBaseDomain(char *pathname,
+						MeshType	*_input_mesh,
+						ParamMesh	 * _param_mesh,
+						AbstractMesh *_absMesh,
+            bool test=true)
+//						bool use_quality=true)
+	{
+		param_mesh=_param_mesh;
+		param_mesh->Clear();
+		/*vcg::tri::Allocator<MeshType>::CompactVertexVector(*_input_mesh);
+		vcg::tri::Allocator<MeshType>::CompactFaceVector(*_input_mesh);*/
+		vcg::tri::Append<ParamMesh,MeshType>::Mesh(*param_mesh,*_input_mesh);
+		/*UpdateStructures<ParamMesh>(param_mesh);*/
+
+		///quality copy to index of texture
+    for (size_t i=0;i<param_mesh->vert.size();i++)
+		{
+			int val0=(int)param_mesh->vert[i].Q();
+			//int val1=param_mesh->vert[i].T().N();*/
+			param_mesh->vert[i].T().N()=val0;
+			assert(param_mesh->vert[i].T().N()>=0);
+		}
+		/*if (AbsMesh()!=NULL)
+			delete(AbsMesh());*/
+
+		//AbsMesh()=new AbstractMesh();
+		AbsMesh()=_absMesh;
+		AbsMesh()->Clear();
+
+		FILE *f=NULL;              
+		f=fopen(pathname,"r");
+		if (f==NULL)
+			return -1;
+		
+		///read vertices
+		fscanf(f,"%d,%d \n",&abstract_mesh->fn,&abstract_mesh->vn);
+		abstract_mesh->vert.resize(abstract_mesh->vn);
+		abstract_mesh->face.resize(abstract_mesh->fn);
+
+		for (unsigned int i=0;i<abstract_mesh->vert.size();i++)
+		{
+			AbstractVertex* vert=&abstract_mesh->vert[i];
+			CoordType pos;
+			fscanf(f,"%f,%f,%f;\n",&pos.X(),&pos.Y(),&pos.Z());
+			vert->P()=pos;
+		}
+
+		///add faces
+		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
+		{
+			AbstractFace* face=&abstract_mesh->face[i];
+			if (!face->IsD())
+			{
+				int index0,index1,index2;
+				fscanf(f,"%d,%d,%d \n",&index0,&index1,&index2);
+				abstract_mesh->face[i].V(0)=&abstract_mesh->vert[index0];
+				abstract_mesh->face[i].V(1)=&abstract_mesh->vert[index1];
+				abstract_mesh->face[i].V(2)=&abstract_mesh->vert[index2];
+			}
+		}
+		UpdateTopologies<AbstractMesh>(AbsMesh());
+		fclose(f);
+		
+		return (Update(test));
+	}
+	
+	template <class MeshType>
+	void CopyParametrization(MeshType	* _param_mesh)
+	{
+    for (size_t i=0;i<_param_mesh->vert.size();i++)
+		{
+			_param_mesh->vert[i].T().P()=ParaMesh()->vert[i].T().P();
+			_param_mesh->vert[i].T().N()=ParaMesh()->vert[i].T().N();
+      _param_mesh->vert[i].Q()=(typename MeshType::ScalarType)ParaMesh()->vert[i].T().N();
+		}
+	}
+
+	template <class MeshType>
+	int LoadMCP(AbstractMesh * _abstract_mesh,
+			  ParamMesh	 * _param_mesh,
+				char* filename,MeshType *coloredMesh=NULL)
+	{
+		abstract_mesh=_abstract_mesh;
+		param_mesh=_param_mesh;
+
+		FILE *f=NULL;              
+		f=fopen(filename,"r");
+		if (f==NULL)
+			return -1;
+		
+
+		///add vertices
+		abstract_mesh->Clear();
+		fscanf(f,"%d,%d \n",&abstract_mesh->fn,&abstract_mesh->vn);
+		abstract_mesh->vert.resize(abstract_mesh->vn);
+		abstract_mesh->face.resize(abstract_mesh->fn);
+
+		for (unsigned int i=0;i<abstract_mesh->vert.size();i++)
+		{
+			AbstractVertex* vert=&abstract_mesh->vert[i];
+			CoordType pos;
+			CoordType RPos;
+			fscanf(f,"%f,%f,%f;%f,%f,%f \n",&pos.X(),&pos.Y(),&pos.Z(),&RPos.X(),&RPos.Y(),&RPos.Z());
+			vert->P()=pos;
+			//vert->RPos=RPos;
+		}
+
+		
+
+		///add faces
+		for (unsigned int i=0;i<abstract_mesh->face.size();i++)
+		{
+			AbstractFace* face=&abstract_mesh->face[i];
+			if (!face->IsD())
+			{
+				int index0,index1,index2;
+				fscanf(f,"%d,%d,%d \n",&index0,&index1,&index2);
+				abstract_mesh->face[i].V(0)=&abstract_mesh->vert[index0];
+				abstract_mesh->face[i].V(1)=&abstract_mesh->vert[index1];
+				abstract_mesh->face[i].V(2)=&abstract_mesh->vert[index2];
+			}
+		}
+		
+		///high resolution mesh
+		fscanf(f,"%d,%d \n",&param_mesh->fn,&param_mesh->vn);
+		param_mesh->vert.resize(param_mesh->vn);
+		param_mesh->face.resize(param_mesh->fn);
+
+		///add vertices
+		for (unsigned int i=0;i<param_mesh->vert.size();i++)
+		{
+			ParamVertex* vert=&param_mesh->vert[i];
+			CoordType pos;
+			CoordType bary;
+			vcg::Color4b col;
+			int index_face;
+			int col0,col1,col2;
+			fscanf(f,"%f,%f,%f;%f,%f,%f;%d,%d,%d;%d \n",
+				  &pos.X(),&pos.Y(),&pos.Z(),
+				  &bary.X(),&bary.Y(),&bary.Z(),
+				  &col0,&col1,&col2,
+				  &index_face);
+			vert->P()=pos;
+			//vert->RPos=pos;
+			vert->T().P()=vcg::Point2<ScalarType>(bary.X(),bary.Y());
+			vert->T().N()=index_face;
+			if (coloredMesh!=NULL)
+			{
+				vcg::Color4b col=coloredMesh->vert[i].C();
+				vert->C()=col;
+			}
+		}
+
+		///add faces
+		for (unsigned int i=0;i<param_mesh->face.size();i++)
+		{
+			//BaseFace* face=&final_mesh.face[i];
+			
+			int index0,index1,index2;
+			fscanf(f,"%d,%d,%d \n",&index0,&index1,&index2);
+			param_mesh->face[i].V(0)=&param_mesh->vert[index0];
+			param_mesh->face[i].V(1)=&param_mesh->vert[index1];
+			param_mesh->face[i].V(2)=&param_mesh->vert[index2];
+			
+		}
+		fclose(f);
+		
+		///update structures
+		vcg::tri::UpdateBounding<AbstractMesh>::Box(*abstract_mesh);
+		vcg::tri::UpdateTopology<AbstractMesh>::FaceFace(*abstract_mesh);
+		vcg::tri::UpdateTopology<AbstractMesh>::VertexFace(*abstract_mesh);
+
+		vcg::tri::UpdateBounding<ParamMesh>::Box(*param_mesh);
+		vcg::tri::UpdateTopology<ParamMesh>::FaceFace(*param_mesh);
+		vcg::tri::UpdateTopology<ParamMesh>::VertexFace(*param_mesh);
+
+		
+		Update();
+
+		return 0;
+	}
+};
+
+
+#endif
diff --git a/src/meshlabplugins/filter_isoparametrization/iso_transfer.h b/src/meshlabplugins/filter_isoparametrization/iso_transfer.h
index 3a0ccab86..9538d215b 100644
--- a/src/meshlabplugins/filter_isoparametrization/iso_transfer.h
+++ b/src/meshlabplugins/filter_isoparametrization/iso_transfer.h
@@ -1,135 +1,135 @@
-#include <iso_parametrization.h>
-
-#include<vcg/simplex/edge/base.h>
-#include<vcg/simplex/vertex/base.h>
-#include<vcg/simplex/face/base.h>
-#include <vcg/complex/trimesh/base.h>
-#include <vcg/complex/trimesh/update/topology.h>
-#include <vcg/complex/trimesh/update/edges.h>
-#include <vcg/complex/trimesh/update/bounding.h>
-#include <vcg/complex/trimesh/update/flag.h>
-#include <vcg/space/index/grid_static_ptr.h>
-#include <vcg/complex/trimesh/closest.h>
-
-#ifndef _ISO_TRANSFER
-#define _ISO_TRANSFER
-
-class IsoTransfer
-{
-	typedef vcg::GridStaticPtr<ParamMesh::FaceType, ParamMesh::ScalarType> TriMeshGrid;
-	typedef ParamMesh::CoordType CoordType;
-	typedef ParamMesh::ScalarType ScalarType;
-	TriMeshGrid TRGrid;
-
-	void Clamp(CoordType &bary)
-	{
-	/*	float eps=0.01;*/
-		float sum=0;
-		int bigger=0;
-		int lower=0;
-	/*	for (int i=0;i<3;i++)
-		{
-			if ((bary.V(i)<eps)&&(bary.V(i)>-eps))
-				bary.V(i)=0;
-			if ((bary.V(i)<1+eps)&&(bary.V(i)>1-eps))
-				bary.V(i)=1;
-
-			sum+=bary.V(i);
-
-			if (bary.V(i)>bary.V(bigger))
-				bigger=i;
-			if (bary.V(i)<bary.V(lower))
-				lower=i;
-		}
-		assert(bigger!=lower);
-		if (sum>(1.0+eps))
-		{
-			float diff=sum-1.0;
-			bary.V(bigger)-=diff;
-		}
-		else
-		if (sum<(1.0-eps))
-		{
-			float diff=1.0-sum;
-			bary.V(lower)+=diff;
-		}*/
-			for (int i=0;i<3;i++)
-		{
-			if (bary.V(i)<0)
-				bary.V(i)=0;
-			if (bary.V(i)>1)
-				bary.V(i)=1;
-
-			sum+=bary.V(i);
-
-			if (bary.V(i)>bary.V(bigger))
-				bigger=i;
-			if (bary.V(i)<bary.V(lower))
-				lower=i;
-		}
-		//assert(bigger!=lower);
-		if (sum>(1.0))
-		{
-			float diff=sum-1.0;
-			bary.V(bigger)-=diff;
-		}
-		else
-		if (sum<(1.0))
-		{
-			float diff=1.0-sum;
-			bary.V(lower)+=diff;
-		}
-	}
-
-	public:
-	template <class MeshType>
-	void Transfer(IsoParametrization &IsoParam,
-								MeshType &to_assing)
-	{
-		///put the mesh in the grid
-		typedef typename MeshType::ScalarType ScalarType;
-		vcg::tri::UpdateBounding<ParamMesh>::Box(*IsoParam.ParaMesh());
-		vcg::tri::UpdateNormals<ParamMesh>::PerFaceNormalized(*IsoParam.ParaMesh());
-		vcg::tri::UpdateNormals<ParamMesh>::PerVertexAngleWeighted(*IsoParam.ParaMesh());
-		vcg::tri::UpdateNormals<ParamMesh>::NormalizeVertex(*IsoParam.ParaMesh());
-		vcg::tri::UpdateEdges<ParamMesh>::Set(*IsoParam.ParaMesh());
-		vcg::tri::UpdateFlags<ParamMesh>::FaceProjection(*IsoParam.ParaMesh());
-		
-		TRGrid.Set(IsoParam.ParaMesh()->face.begin(),IsoParam.ParaMesh()->face.end());
-		ScalarType maxDist=IsoParam.ParaMesh()->bbox.Diag();
-		///then for each vertex find the closest
-    for (size_t i=0;i<to_assing.vert.size();i++)
-		{
-      typename MeshType::VertexType *vert=&to_assing.vert[i];
-			if (!vert->IsD())
-			{
-				ScalarType dist;
-				CoordType closest,norm,bary;
-				ParamMesh::FaceType * f=NULL;
-				f=GetClosestFace(*IsoParam.ParaMesh(),TRGrid,vert->P(), maxDist,dist,closest,norm,bary);
-				assert(f!=NULL);
-				
-				///then find back the coordinates
-				if (!((bary.X()>=0)&&(bary.X()<=1)&&
-					  (bary.Y()>=0)&&(bary.Y()<=1)&&
-						(bary.Z()>=0)&&(bary.Z()<=1)))
-				{
-            printf("%i,%3.3f,%3.3f,%3.3f",int(i),bary.X(),bary.Y(),bary.Z());
-						system("pause");
-				}
-				Clamp(bary);
-				int I;
-				vcg::Point2<ScalarType> UV;
-				IsoParam.Phi(f,bary,I,UV);
-				///and finally set to the vertex
-				assert(I>=0);
-				vert->T().P()=UV;
-				vert->T().N()=I;
-				vert->Q()=(typename MeshType::ScalarType)I;
-			}
-		}
-	}
-
-};
-
-#endif
+#include <iso_parametrization.h>
+
+#include<vcg/simplex/edge/base.h>
+#include<vcg/simplex/vertex/base.h>
+#include<vcg/simplex/face/base.h>
+#include <vcg/complex/complex.h>
+#include <vcg/complex/algorithms/update/topology.h>
+#include <vcg/complex/algorithms/update/edges.h>
+#include <vcg/complex/algorithms/update/bounding.h>
+#include <vcg/complex/algorithms/update/flag.h>
+#include <vcg/space/index/grid_static_ptr.h>
+#include <vcg/complex/algorithms/closest.h>
+
+#ifndef _ISO_TRANSFER
+#define _ISO_TRANSFER
+
+class IsoTransfer
+{
+	typedef vcg::GridStaticPtr<ParamMesh::FaceType, ParamMesh::ScalarType> TriMeshGrid;
+	typedef ParamMesh::CoordType CoordType;
+	typedef ParamMesh::ScalarType ScalarType;
+	TriMeshGrid TRGrid;
+
+	void Clamp(CoordType &bary)
+	{
+	/*	float eps=0.01;*/
+		float sum=0;
+		int bigger=0;
+		int lower=0;
+	/*	for (int i=0;i<3;i++)
+		{
+			if ((bary.V(i)<eps)&&(bary.V(i)>-eps))
+				bary.V(i)=0;
+			if ((bary.V(i)<1+eps)&&(bary.V(i)>1-eps))
+				bary.V(i)=1;
+
+			sum+=bary.V(i);
+
+			if (bary.V(i)>bary.V(bigger))
+				bigger=i;
+			if (bary.V(i)<bary.V(lower))
+				lower=i;
+		}
+		assert(bigger!=lower);
+		if (sum>(1.0+eps))
+		{
+			float diff=sum-1.0;
+			bary.V(bigger)-=diff;
+		}
+		else
+		if (sum<(1.0-eps))
+		{
+			float diff=1.0-sum;
+			bary.V(lower)+=diff;
+		}*/
+			for (int i=0;i<3;i++)
+		{
+			if (bary.V(i)<0)
+				bary.V(i)=0;
+			if (bary.V(i)>1)
+				bary.V(i)=1;
+
+			sum+=bary.V(i);
+
+			if (bary.V(i)>bary.V(bigger))
+				bigger=i;
+			if (bary.V(i)<bary.V(lower))
+				lower=i;
+		}
+		//assert(bigger!=lower);
+		if (sum>(1.0))
+		{
+			float diff=sum-1.0;
+			bary.V(bigger)-=diff;
+		}
+		else
+		if (sum<(1.0))
+		{
+			float diff=1.0-sum;
+			bary.V(lower)+=diff;
+		}
+	}
+
+	public:
+	template <class MeshType>
+	void Transfer(IsoParametrization &IsoParam,
+								MeshType &to_assing)
+	{
+		///put the mesh in the grid
+		typedef typename MeshType::ScalarType ScalarType;
+		vcg::tri::UpdateBounding<ParamMesh>::Box(*IsoParam.ParaMesh());
+		vcg::tri::UpdateNormals<ParamMesh>::PerFaceNormalized(*IsoParam.ParaMesh());
+		vcg::tri::UpdateNormals<ParamMesh>::PerVertexAngleWeighted(*IsoParam.ParaMesh());
+		vcg::tri::UpdateNormals<ParamMesh>::NormalizeVertex(*IsoParam.ParaMesh());
+		vcg::tri::UpdateEdges<ParamMesh>::Set(*IsoParam.ParaMesh());
+		vcg::tri::UpdateFlags<ParamMesh>::FaceProjection(*IsoParam.ParaMesh());
+		
+		TRGrid.Set(IsoParam.ParaMesh()->face.begin(),IsoParam.ParaMesh()->face.end());
+		ScalarType maxDist=IsoParam.ParaMesh()->bbox.Diag();
+		///then for each vertex find the closest
+    for (size_t i=0;i<to_assing.vert.size();i++)
+		{
+      typename MeshType::VertexType *vert=&to_assing.vert[i];
+			if (!vert->IsD())
+			{
+				ScalarType dist;
+				CoordType closest,norm,bary;
+				ParamMesh::FaceType * f=NULL;
+				f=GetClosestFace(*IsoParam.ParaMesh(),TRGrid,vert->P(), maxDist,dist,closest,norm,bary);
+				assert(f!=NULL);
+				
+				///then find back the coordinates
+				if (!((bary.X()>=0)&&(bary.X()<=1)&&
+					  (bary.Y()>=0)&&(bary.Y()<=1)&&
+						(bary.Z()>=0)&&(bary.Z()<=1)))
+				{
+            printf("%i,%3.3f,%3.3f,%3.3f",int(i),bary.X(),bary.Y(),bary.Z());
+						system("pause");
+				}
+				Clamp(bary);
+				int I;
+				vcg::Point2<ScalarType> UV;
+				IsoParam.Phi(f,bary,I,UV);
+				///and finally set to the vertex
+				assert(I>=0);
+				vert->T().P()=UV;
+				vert->T().N()=I;
+				vert->Q()=(typename MeshType::ScalarType)I;
+			}
+		}
+	}
+
+};
+
+#endif
diff --git a/src/meshlabplugins/filter_isoparametrization/local_parametrization.h b/src/meshlabplugins/filter_isoparametrization/local_parametrization.h
index 166938165..eae7152d3 100644
--- a/src/meshlabplugins/filter_isoparametrization/local_parametrization.h
+++ b/src/meshlabplugins/filter_isoparametrization/local_parametrization.h
@@ -1,1378 +1,1378 @@
-
-
-#include "defines.h"
-///fitting
-#include <vcg/space/fitting3.h>
-#include <vcg/math/matrix33.h>
-#include <vcg/space/triangle2.h>
-#include "texcoord_optimization.h"
-#include "mesh_operators.h"
-
-#ifndef LOCAL_PARAMETRIZATION
-#define LOCAL_PARAMETRIZATION
-
-//#include <vcg/complex/trimesh/point_sampling.h>
-
-//#define samples_area 80
-
-template <class MeshType>
-void ParametrizeExternal(MeshType &to_parametrize)
-{
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename MeshType::CoordType CoordType;
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::VertexType VertexType;
-
-        std::vector<VertexType*> vertices;
-	
-	///find first border vertex
-        VertexType* Start=NULL;
-        typename MeshType::VertexIterator Vi=to_parametrize.vert.begin();
-	
-	while ((Start==NULL)&&(Vi<to_parametrize.vert.end()))
-	{
-		if (((*Vi).IsB())&&(!(*Vi).IsD()))
-			Start=&(*Vi);
-		Vi++;
-	}
-	if (Vi==to_parametrize.vert.end())
-	{
-		assert(0);
-	}
-	///get sorted border vertices
-	
-	FindSortedBorderVertices<MeshType>(to_parametrize,Start,vertices);
-
-	//assert(vertices.size()>=4);
-	
-	///find perimeter
-	ScalarType perimeter=0;
-	int size=vertices.size();
-	for (int i=0;i<size;i++)
-		perimeter+=(vertices[i]->P()-vertices[(i+1)%size]->P()).Norm();
-	
-	///find scaling factor
-	/*ScalarType Sperimeter=(2.0*M_PI)/perimeter;*/
-	
-	///set default texCoords
-	for (Vi=to_parametrize.vert.begin();Vi!=to_parametrize.vert.end();Vi++)
-	{
-		(*Vi).T().U()=-2;
-		(*Vi).T().V()=-2;
-	}
-
-	///set border vertices
-        typename std::vector<VertexType*>::iterator iteV;
-	/*ScalarType curr_perim=0;*/
-	ScalarType curr_angle=0;
-	vertices[0]->T().U()=cos(curr_angle);
-	vertices[0]->T().V()=sin(curr_angle);
-	//for (int i=1;i<vertices.size();i++)
-	//{
-	//	curr_perim+=(vertices[i]->P()-vertices[(i-1)]->P()).Norm();
-	//	//curr_perim+=perimeter/(ScalarType)size;
-	//	curr_angle=curr_perim*Sperimeter;
-	//	vertices[i]->T().U()=cos(curr_angle);
-	//	vertices[i]->T().V()=sin(curr_angle);
-	//	assert((vertices[i]->T().U()>=-1)&&(vertices[i]->T().U()<=1));
-	//	assert((vertices[i]->T().V()>=-1)&&(vertices[i]->T().V()<=1));
-	//}
-	ScalarType anglediv=(2.0*M_PI)/(ScalarType)(vertices.size());
-	curr_angle=0;
-	for (unsigned int i=1;i<vertices.size();i++)
-	{
-		curr_angle+=anglediv;
-		vertices[i]->T().U()=cos(curr_angle);
-		vertices[i]->T().V()=sin(curr_angle);
-		assert((vertices[i]->T().U()>=-1)&&(vertices[i]->T().U()<=1));
-		assert((vertices[i]->T().V()>=-1)&&(vertices[i]->T().V()<=1));
-	}
-}
-
-template <class MeshType>
-void ParametrizeInternal(MeshType &to_parametrize)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	const ScalarType Eps=(ScalarType)0.0001;
-	///set internal vertices
-        for (typename MeshType::VertexIterator Vi=to_parametrize.vert.begin();Vi!=to_parametrize.vert.end();Vi++)
-	{
-		//assert(!Vi->IsD());
-		if ((!Vi->IsB())&&(!Vi->IsD()))
-		{
-			///find kernel
-                        std::vector<typename MeshType::VertexType*> star;
-			getVertexStar<MeshType>(&(*Vi),star);
-			ScalarType kernel=0;
-			for (unsigned int k=0;k<star.size();k++)
-				if (star[k]->IsB())
-				{
-					ScalarType dist=((*Vi).P()-star[k]->P()).Norm();
-					if (dist<Eps)
-						dist=Eps;
-					//ScalarType peso=1.0/(dist);
-					ScalarType peso=(dist)/star.size();
-					kernel+=(peso);//*dist);
-				}
-			assert(kernel>0);
-			///then find factor
-			kernel=1.0/kernel;       
-
-			(*Vi).T().U()=0;
-			(*Vi).T().V()=0;
-			
-			int num=0;
-			///find weighted media
-			for (unsigned int k=0;k<star.size();k++)
-				if (star[k]->IsB())
-				{
-					ScalarType dist=((*Vi).P()-star[k]->P()).Norm();
-					if (dist<Eps)
-						dist=Eps;
-					//ScalarType peso=1.0/(dist);
-					ScalarType peso=(dist)/star.size();
-					ScalarType kval=(peso)*kernel;
-					assert(kval>0);
-					(*Vi).T().U()+=kval*star[k]->T().U();
-					(*Vi).T().V()+=kval*star[k]->T().V();
-					num++;
-				}
-			////on border case 2 neighbors
-			///go next to the center
-			/*if (num==2)
-			{
-				(*Vi).T().U()/=2.0;
-				(*Vi).T().V()/=2.0;
-			}*/
-			/*ScalarType u=(*Vi).T().U();
-			ScalarType v=(*Vi).T().V();*/
-			assert(((*Vi).T().U()>=-1)&&((*Vi).T().U()<=1));
-			assert(((*Vi).T().V()>=-1)&&((*Vi).T().V()<=1));
-		}
-	}
-	///smoothing of txcoords
-	InitDampRestUV(to_parametrize);
-        for (typename MeshType::VertexIterator Vi=to_parametrize.vert.begin();Vi!=to_parametrize.vert.end();Vi++)
-	{
-		if ((!Vi->IsB())&&(!Vi->IsD()))
-		{
-                        std::vector<typename MeshType::VertexType*> star;
-			getVertexStar<MeshType>(&(*Vi),star);
-			vcg::Point2<ScalarType> UV=vcg::Point2<ScalarType>(0,0);
-			for (unsigned int k=0;k<star.size();k++)
-				UV+=star[k]->RestUV;
-			UV/=(ScalarType)star.size();
-			(*Vi).T().P()=UV;
-		}
-	}
-}
-
-
-template <class FaceType>
-typename FaceType::CoordType InterpolatePos
-(FaceType* f, const typename FaceType::CoordType &bary)
-{return (f->V(0)->P()*bary.X()+f->V(1)->P()*bary.Y()+f->V(2)->P()*bary.Z());}
-
-template <class FaceType>
-typename FaceType::CoordType InterpolateRPos
-(FaceType* f,const typename FaceType::CoordType &bary)
-{	
-	return (f->V(0)->RPos*bary.X()+f->V(1)->RPos*bary.Y()+f->V(2)->RPos*bary.Z());
-}
-
-template <class FaceType>
-typename FaceType::CoordType InterpolateNorm
-(FaceType* f, const typename FaceType::CoordType &bary)
-{	
-        typedef typename FaceType::CoordType CoordType;
-	CoordType n0=f->V(0)->N();
-	CoordType n1=f->V(1)->N();
-	CoordType n2=f->V(2)->N();
-	return (n0*bary.X()+n1*bary.Y()+n2*bary.Z());
-}
-
-template <class ScalarType>
-int Approx(const ScalarType &value)
-{
-	ScalarType val0=floor(value);
-	ScalarType val1=ceil(value);
-	if (fabs(val0-value)<fabs(val1-value))
-		return ((int)val0);
-	else
-		return ((int)val1);
-}
-
-template <class FaceType>
-vcg::Point3i InterpolateColor
-(FaceType* f,const typename FaceType::CoordType &bary)
-{	
-        typedef typename FaceType::ScalarType ScalarType;
-	vcg::Color4b c0=f->V(0)->C();
-	vcg::Color4b c1=f->V(1)->C();
-	vcg::Color4b c2=f->V(2)->C();
-	double R=(ScalarType)c0.X()*bary.X()+(ScalarType)c1.X()*bary.Y()+(ScalarType)c2.X()*bary.Z();
-	double G=(ScalarType)c0.Y()*bary.X()+(ScalarType)c1.Y()*bary.Y()+(ScalarType)c2.Y()*bary.Z();
-	double B=(ScalarType)c0.Z()*bary.X()+(ScalarType)c1.Z()*bary.Y()+(ScalarType)c2.Z()*bary.Z();
-
-	vcg::Point3i p=vcg::Point3i(Approx(R),Approx(G),Approx(B));
-
-	assert(p.X()<=255);
-	assert(p.Y()<=255);
-	assert(p.Z()<=255);
-
-	return (p);
-}
-
-template <class VertexType>
-typename VertexType::CoordType ProjectPos(const VertexType &v)
-{
-	typedef typename VertexType::FaceType FaceType;
-	typedef typename VertexType::CoordType CoordType;
-
-	FaceType *f=v.father;
-	CoordType b=v.Bary;
-	return (InterpolatePos<FaceType>(f,b));
-}
-
-template <class VertexType>
-typename VertexType::CoordType Warp(const VertexType* v)
-{
-        typename VertexType::FaceType * father=v->father;
-        typename VertexType::CoordType proj=father->P(0)*v->Bary.X()+father->P(1)*v->Bary.Y()+father->P(2)*v->Bary.Z();
-	return proj;
-}
-
-template <class VertexType>
-typename VertexType::CoordType WarpRpos(const VertexType* v)
-{
-        typename VertexType::FaceType * father=v->father;
-        typename VertexType::CoordType proj=father->V(0)->RPos*v->Bary.X()+father->V(1)->RPos*v->Bary.Y()+father->V(2)->RPos*v->Bary.Z();
-	return proj;
-}
-
-template <class MeshType>
-typename MeshType::ScalarType EstimateLenghtByParam
-								(const typename MeshType::VertexType* v0,
-								 const typename MeshType::VertexType* v1,
-								 typename MeshType::FaceType* on_edge[2])
-{
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename MeshType::CoordType CoordType;
-	typedef typename MeshType::VertexType VertexType;
-	typedef typename MeshType::ScalarType ScalarType;
-
-//	assert((on_edge.size()==0)||(on_edge.size()==1));
-	ScalarType estimated[2]={0,0};
-	int num[2]={0,0};
-	
-	for (int i=0;i<2;i++)
-	{
-		FaceType *test_face=on_edge[i];
-
-		int edge_index=EdgeIndex(test_face,v0,v1);
-		FaceType *Fopp=test_face->FFp(edge_index);
-
-		if (test_face->vertices_bary.size()<2)
-		{
-			ScalarType dist=Distance(v0->RPos,v1->RPos);
-			//#pragma omp atomic
-			estimated[i]+=dist;
-			num[i]=0;
-			continue;
-		}
-
-		///collect vertices
-		std::vector<VertexType*> vertices;
-		vertices.reserve(test_face->vertices_bary.size());
-		for (unsigned int k=0;k<test_face->vertices_bary.size();k++)
-			vertices.push_back(test_face->vertices_bary[k].first);
-
-		
-		///collect faces
-		std::vector<FaceType*> faces;
-		getSharedFace<MeshType>(vertices,faces);
-
-		///get border edges
-		std::vector<std::pair<VertexType*,VertexType*> > edges;
-		for (unsigned int j=0;j<faces.size();j++)
-		{
-			FaceType*f=faces[j];
-			///find if there is an on-edge edge
-			bool found=false;
-			int k=0;
-			while  ((k<3)&&(!found))
-			{
-				if ((f->V0(k)->father==test_face)&&
-					(f->V1(k)->father==test_face)&&
-					(f->V2(k)->father==Fopp))
-				{
-					edges.push_back(std::pair<VertexType*,VertexType*>(f->V0(k),f->V1(k)));
-					found=true;
-				}
-				k++;
-			}
-		}
-		
-		///find if there's ant edge return inital lenght
-		if (edges.size()==0)
-		{
-			estimated[i]+=(Distance(v0->RPos,v1->RPos));
-			num[i]=0;
-			continue;
-		}
-		else
-		{
-			//get edge direction
-			///store the two nearest for each vertex
-			/*VertexType *n0=edges[0].first;
-			VertexType *n1=edges[0].second;
-			ScalarType d0=(Warp(n0)-v0->P()).Norm();
-			ScalarType d1=(Warp(n1)-v1->P()).Norm();*/
-
-			//CoordType edgedir=v0->cP()-v1->cP();
-			CoordType edgedir=v0->RPos-v1->RPos;
-			edgedir.Normalize();
-			num[i]=edges.size();
-			for (unsigned int e=0;e<edges.size();e++)
-			{
-				VertexType *vH0=edges[e].first;
-				VertexType *vH1=edges[e].second;
-
-				///project points over the plane 
-				/*CoordType proj0=Warp(vH0);
-				CoordType proj1=Warp(vH1);*/
-				CoordType proj0=WarpRpos(vH0);
-				CoordType proj1=WarpRpos(vH1);
-				
-				CoordType dirproj=proj0-proj1;
-				dirproj.Normalize();
-				//estimated[i]+=fabs(dirproj*edgedir)*((vH0->P()-vH1->P()).Norm());
-				//#pragma omp atomic
-				estimated[i]+=fabs(dirproj*edgedir)*((vH0->RPos-vH1->RPos).Norm());
-
-			}
-		}
-	}
-
-	///media of estimated values
-	ScalarType alpha0,alpha1;
-	ScalarType max_num=abstraction_num;
-
-	if (num[0]>=max_num)
-		alpha0=1;
-	else
-		alpha0=num[0]/max_num;
-
-	if (num[1]>=max_num)
-		alpha1=1;
-	else
-		alpha1=num[1]/max_num;
-
-	estimated[0]=alpha0*estimated[0]+(1.0-alpha0)*(Distance(v0->RPos,v1->RPos));
-	estimated[1]=alpha1*estimated[1]+(1.0-alpha1)*(Distance(v0->RPos,v1->RPos));
-	return((estimated[0]+estimated[1])/2.0);
-}
-
-template <class MeshType>
-void MeanVal(const std::vector<vcg::Point2<typename MeshType::ScalarType> > &Points,
-			 std::vector<typename MeshType::ScalarType> &Lamda,
-			 typename MeshType::CoordType &p)
-{
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename MeshType::VertexType VertexType;
-	typedef typename MeshType::ScalarType ScalarType;
-        typedef typename MeshType::CoordType CoordType;
-
-	int size=Points.size();
-	Lamda.resize(size);
-
-	ScalarType sum=0;	
-	for (int i=0;i<size;i++)
-	{
-		int size=Points.size()-1;
-		vcg::Point2<ScalarType> Pcurr=Points[i];
-		vcg::Point2<ScalarType> Pprev=Points[(i+(size-1))%size];
-		vcg::Point2<ScalarType> Pnext=Points[(i+1)%size];
-
-		CoordType v0=Pprev-p;
-		CoordType v1=Pcurr-p;
-		CoordType v2=Pnext-p;
-		ScalarType l=v1.Norm();
-		v0.Normalize();
-		v1.Normalize();
-		v2.Normalize();
-
-		ScalarType Alpha0=acos(v0*v1);
-		ScalarType Alpha1=acos(v1*v2);
-
-                Lamda[i]=(tan(Alpha0/2.0)+tan(Alpha1/2.0))/l;
-                sum+=Lamda[i];
-	}
-
-	///normalization
-	for (int i=0;i<size;i++)
-                Lamda[i]/=sum;
-}
-
-template <class FaceType>
-typename FaceType::ScalarType EstimateAreaByParam(const FaceType* f)
-{
-	typedef typename FaceType::VertexType VertexType;
-	typedef typename FaceType::ScalarType ScalarType;
-	
-	int num=0;
-	ScalarType estimated=0;
-	for (unsigned int k=0;k<f->vertices_bary.size();k++)
-	{
-		VertexType *HresVert=f->vertices_bary[k].first;
-		estimated+=HresVert->area;
-		num++;
-	}
-
-	///media of estimated values
-	ScalarType alpha;
-	ScalarType max_num=abstraction_num;
-
-	if (num>=max_num)
-		alpha=1;
-	else
-		alpha=num/max_num;
-
-	ScalarType Rarea=((f->V(1)->RPos-f->V(0)->RPos)^(f->V(2)->RPos-f->V(0)->RPos)).Norm()/2.0;
-	estimated=alpha*estimated+(1.0-alpha)*Rarea;
-
-	return(estimated);
-}
-
-template <class MeshType>
-typename MeshType::ScalarType EstimateAreaByParam
-							  (const typename MeshType::VertexType* v0,
-							   const typename MeshType::VertexType* v1,
-							   typename MeshType::FaceType* on_edge[2])
-{
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename MeshType::VertexType VertexType;
-	typedef typename MeshType::ScalarType ScalarType;
-
-	//MeshType::PerVertexAttributeHandle<AuxiliaryVertData> handle = vcg::tri::Allocator<MeshType>::GetPerVertexAttribute<AuxiliaryVertData>(mesh,"AuxiliaryVertData");
-
-	ScalarType estimated[2]={0,0};
-	int num[2]={0,0};
-	VertexType *v2[2];
-	for (int i=0;i<2;i++)
-	{
-		FaceType *test_face=on_edge[i];
-
-		for (int k=0;k<3;k++)
-			if ((test_face->V(k)!=v0)&&(test_face->V(k)!=v1))
-				v2[i]=test_face->V(k);
-		
-		for (unsigned int k=0;k<test_face->vertices_bary.size();k++)
-		{
-			VertexType *brother=test_face->vertices_bary[k].first;
-			estimated[i]+=brother->area;
-			//estimated[i]+=handle[brother].area;
-			num[i]++;
-		}
-	}
-
-	///media of estimated values
-	ScalarType alpha0,alpha1;
-	ScalarType max_num=abstraction_num;//20
-
-	if (num[0]>=max_num)
-		alpha0=1;
-	else
-		alpha0=num[0]/max_num;
-
-	if (num[1]>=max_num)
-		alpha1=1;
-	else
-		alpha1=num[1]/max_num;
-	ScalarType Rarea0=((on_edge[0]->V(1)->RPos-on_edge[0]->V(0)->RPos)^(on_edge[0]->V(2)->RPos-on_edge[0]->V(0)->RPos)).Norm()/2.0;
-	ScalarType Rarea1=((on_edge[1]->V(1)->RPos-on_edge[1]->V(0)->RPos)^(on_edge[1]->V(2)->RPos-on_edge[1]->V(0)->RPos)).Norm()/2.0;
-	estimated[0]=alpha0*estimated[0]+(1.0-alpha0)*Rarea0;
-	estimated[1]=alpha1*estimated[1]+(1.0-alpha1)*Rarea1;
-	return((estimated[0]+estimated[1])/2.0);
-}
-
-///template class used to sample surface
-template <class FaceType>
-class VertexSampler{
-	typedef typename FaceType::CoordType CoordType;
-public: 
-	std::vector<CoordType> points;
-
-	void AddFace(const FaceType &f,const CoordType & bary)
-	{points.push_back(f.P(0)*bary.X()+f.P(1)*bary.Y()+f.P(2)*bary.Z());}
-};
-
-
-///sample 3d vertex possible's position
-///using area criterion
-//template <class MeshType>
-//void SamplingPoints(MeshType &mesh,
-//					std::vector<typename MeshType::CoordType> &pos)
-//{
-//	typedef typename MeshType::CoordType CoordType;
-//	typedef VertexSampler<MeshType::FaceType> Sampler;
-//	pos.reserve(samples_area);
-//	Sampler ps;
-//	ps.points.reserve(samples_area);
-//
-//	vcg::tri::SurfaceSampling<MeshType,Sampler>::Montecarlo(mesh,ps,samples_area);
-//	pos=std::vector<CoordType>(ps.points.begin(),ps.points.end());
-//}
-
-template <class MeshType> 
-void InitDampRestUV(MeshType &m)
-{
-	for (unsigned int i=0;i<m.vert.size();i++)
-		m.vert[i].RestUV=m.vert[i].T().P();
-}
-
-
-template <class MeshType> 
-void RestoreRestUV(MeshType &m)
-{
-	for (unsigned int i=0;i<m.vert.size();i++)
-		m.vert[i].T().P()=m.vert[i].RestUV;
-}
-
-
-///parametrize a submesh from trinagles that are incident on vertices 
-template <class MeshType>
-void ParametrizeLocally(MeshType &parametrized,
-						bool fix_boundary=true,
-						bool init_border=true)
-{
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::CoordType CoordType;
-
-	//const ScalarType epsilon=(ScalarType)0.0001;
-	
-
-	///save old positions
-
-	std::vector<CoordType> positions;
-	positions.resize(parametrized.vert.size());
-	///set rest position
-	for (unsigned int i=0;i<parametrized.vert.size();i++)
-	{
-		positions[i]=parametrized.vert[i].P();
-		parametrized.vert[i].P()=parametrized.vert[i].RPos;
-	}
-
-	UpdateTopologies(&parametrized);
-
-	if (init_border)
-		ParametrizeExternal(parametrized);
-
-	ParametrizeInternal(parametrized);
-	
-	//for (int i=0;i<parametrized.vert.size();i++)
-	//	parametrized.vert[i].RPos=parametrized.vert[i].P();
-
-	vcg::tri::MeanValueTexCoordOptimization<MeshType> opt(parametrized);
-	//vcg::tri::WachspressTexCoordOptimization<MeshType> opt(parametrized);
-	vcg::tri::AreaPreservingTexCoordOptimization<MeshType> opt1(parametrized);
-	opt.SetSpeed((ScalarType)0.0005);
-	InitDampRestUV(parametrized);
-	if (fix_boundary)
-	{
-		opt.TargetEquilateralGeometry();
-		//opt.TargetCurrentGeometry();
-		opt.SetBorderAsFixed();
-		opt.IterateUntilConvergence((ScalarType)0.000001,100);
-		/*opt.Iterate();
-		opt.Iterate();*/
-	}
-	else
-	{
-		opt1.TargetCurrentGeometry();
-		//opt1.SetBorderAsFixed();
-		opt1.IterateUntilConvergence((ScalarType)0.000001,200);
-	}
-
-	///assert parametrization
-	for (unsigned int i=0;i<parametrized.face.size();i++)
-	{
-		FaceType *f=&parametrized.face[i];
-		vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
-		vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
-		vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
-		vcg::Triangle2<typename MeshType::ScalarType> t2d=vcg::Triangle2<typename MeshType::ScalarType>(tex0,tex1,tex2);
-#ifndef NDEBUG
-		ScalarType area=(tex1-tex0)^(tex2-tex0);
-		assert(area>0);
-#endif
-//#ifndef _MESHLAB
-//		if (area<0){
-//			vcg::tri::io::ExporterPLY<BaseMesh>::Save(parametrized,"case0.ply");
-//
-//			for (int j=0;j<parametrized.vert.size();j++)
-//			{
-//				parametrized.vert[j].P().V(0)=parametrized.vert[j].T().U();
-//				parametrized.vert[j].P().V(1)=parametrized.vert[j].T().V();
-//				parametrized.vert[j].P().V(2)=0;
-//			}
-//			vcg::tri::io::ExporterPLY<BaseMesh>::Save(parametrized,"case1.ply");
-//			assert(0);
-//		}
-//#endif
-	}
-	///restore position
-	for (unsigned int i=0;i<parametrized.vert.size();i++)	
-		parametrized.vert[i].P()=positions[i];
-}
-
-template <class MeshType>
-void ForceInParam(vcg::Point2<typename MeshType::ScalarType> &UV,MeshType &domain)
-{
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename MeshType::CoordType CoordType;
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::VertexType VertexType;
-
-	ScalarType minDist=(ScalarType)1000.0;
-	vcg::Point2<ScalarType> closest;
-	vcg::Point2<ScalarType> center=vcg::Point2<ScalarType>(0,0);
-	for (unsigned int i=0;i<domain.face.size();i++)	
-	{
-		FaceType *f=&domain.face[i];
-		vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
-		vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
-		vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
-		center+=tex0;
-		center+=tex1;
-		center+=tex2;
-		vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
-		ScalarType dist;
-		vcg::Point2<ScalarType> temp;
-		t2d.PointDistance(UV,dist,temp);
-		if (dist<minDist)
-		{
-			minDist=dist;
-			closest=temp;
-		}
-	}
-	center/=(ScalarType)(domain.face.size()*3);
-	UV=closest*(ScalarType)0.95+center*(ScalarType)0.05;
-}
-
-
-template <class VertexType>
-bool testParamCoords(VertexType *v)
-{
-	typedef typename VertexType::ScalarType ScalarType;
-	ScalarType eps=(ScalarType)0.00001;
-	if (!(((v->T().P().X()>=-1-eps)&&(v->T().P().X()<=1+eps)&&
-		   (v->T().P().Y()>=-1-eps)&&(v->T().P().Y()<=1+eps))))
-			return (false);
-
-	return true;
-}
-
-template <class MeshType>
-bool testParamCoords(MeshType &domain)
-{
-	for (unsigned int i=0;i<domain.vert.size();i++)
-	{
-                typename MeshType::VertexType *v=&domain.vert[i];
-                bool b=testParamCoords<typename MeshType::VertexType>(v);
-		if (!b)
-		{
-			#ifndef _MESHLAB
-			printf("\n position %lf,%lf \n",v->T().U(),v->T().V());
-			#endif
-			return false;
-		}
-	}
-	return true;
-}
-
-template <class CoordType>
-bool testBaryCoords(CoordType &bary)
-{
-	typedef typename CoordType::ScalarType ScalarType;
-	///test
-	float eps=(ScalarType)0.0001;
-	if(!(fabs(bary.X()+bary.Y()+bary.Z()-1.0)<eps))
-		return false;
-	if(!((bary.X()<=1.0)&&(bary.X()>=-eps)&&(bary.Y()<=1.0)&&(bary.Y()>=-eps)&&(bary.Z()<=1.0)&&(bary.Z()>=-eps)))
-		return false;
-	return true;
-}
-
-template <class CoordType>
-bool NormalizeBaryCoords(CoordType &bary)
-{
-	bool isOK=testBaryCoords(bary);
-	if (!isOK)
-		return false;
-
-	typedef typename CoordType::ScalarType ScalarType;
-
-	///test <0
-	if (bary.X()<0)
-		bary.X()=0;
-	if (bary.Y()<0)
-		bary.Y()=0;
-	if (bary.Z()<0)
-		bary.Z()=0;
-
-	///test >1
-	if (bary.X()>1.0)
-		bary.X()=1.0;
-	if (bary.Y()>1.0)
-		bary.Y()=1.0;
-	if (bary.Z()>1.0)
-		bary.Z()=1.0;
-	
-	///test sum
-	ScalarType diff=bary.X()+bary.Y()+bary.Z()-1.0;
-	bary.X()-=diff;
-
-	if (bary.X()<0)
-		bary.X()=0;
-	return true;
-}
-
-template <class MeshType>
-void AssingFather(typename MeshType::VertexType &v,
-									typename MeshType::FaceType *father,
-									typename MeshType::CoordType &bary,
-                  MeshType & domain)
-{
-#ifdef _DEBUG
-	const typename MeshType::ScalarType eps=(typename MeshType::ScalarType)0.00001;
-	assert((father-&(*domain.face.begin()))<(int)domain.face.size());
-	assert(!(father->IsD()));
-	assert(!(father==NULL));
-	assert((bary.X()>=0)&&(bary.X()<=1)&&
-				 (bary.Y()>=0)&&(bary.Y()<=1)&&
-				 (bary.Z()>=0)&&(bary.Z()<=1)&&
-				 ((bary.X()+bary.Y()+bary.Z())<=1+eps)&&
-				 ((bary.X()+bary.Y()+bary.Z())>=1-eps));
-#endif
-	v.father=father;
-	v.Bary=bary;
-}
-
-template <class MeshType>
-bool testParametrization(MeshType &domain,
-						 MeshType &Hlev)
-{
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename MeshType::CoordType CoordType;
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::VertexType VertexType;
-	bool is_good=true;
-	int num_del=0;
-	int num_null=0;
-	int fath_son=0;
-	int wrong_address=0;
-	for (unsigned int i=0;i<Hlev.vert.size();i++)
-	{
-		VertexType *v=&Hlev.vert[i];
-		bool isGoodAddr=true;
-		if ((v->father-&(*domain.face.begin()))>=(int)domain.face.size())
-		{
-			printf("\n ADDRESS EXCEEDS OF %d \n",v->father-&(*domain.face.begin()));
-			wrong_address++;
-			is_good=false;
-			isGoodAddr=false;
-		}
-		if ((isGoodAddr)&&(v->father==NULL))
-		{
-			//printf("\n PAR ERROR : father NULL\n");
-			num_null++;
-			is_good=false;
-		}
-		if ((isGoodAddr)&&(v->father->IsD()))
-		{
-			//printf("\n PAR ERROR : father DELETED \n");
-			num_del++;
-			is_good=false;
-		}
-		if ((isGoodAddr)&&(!(((v->Bary.X()>=0)&&(v->Bary.X()<=1))&&
-		((v->Bary.Y()>=0)&&(v->Bary.Y()<=1))&&
-		((v->Bary.Z()>=0)&&(v->Bary.Z()<=1)))))
-		{
-			printf("\n PAR ERROR : bary coords exceeds: %f,%f,%f \n",v->Bary.X(),v->Bary.Y(),v->Bary.Z());
-			is_good=false;
-		}
-	}
-	for (unsigned int i=0;i<domain.face.size();i++)
-	{
-		FaceType *face=&domain.face[i];
-		if (!face->IsD())
-		{
-			for (unsigned int j=0;j<face->vertices_bary.size();j++)
-			{
-				VertexType *v=face->vertices_bary[j].first;
-				if (v->father!=face)
-				{
-					//printf("\n PAR ERROR : Father<->son \n");
-					fath_son++;
-					v->father=face;
-					is_good=false;
-				}
-			}
-		}
-	}
-	
-	if (num_del>0)
-		printf("\n PAR ERROR %d Father isDel  \n",num_del);
-	if (num_null>0)
-		printf("\n PAR ERROR %d Father isNull \n",num_null);
-	if (fath_son>0)
-		printf("\n PAR ERROR %d Father<->son  \n",fath_son);
-	if (wrong_address>0)
-	{
-		printf("\n PAR ERROR %d Wrong Address Num Faces %d\n",wrong_address,domain.fn);
-		/*system("pause");*/
-	}
-	return (is_good);
-}
-
-template <class MeshType>
-bool NonFolded(MeshType &parametrized)
-{
-	//const ScalarType epsilon=0.00001;
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename MeshType::CoordType CoordType;
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::VertexType VertexType;
-	///assert parametrization
-	for (unsigned int i=0;i<parametrized.face.size();i++)
-	{
-		FaceType *f=&parametrized.face[i];
-		if (!((f->V(0)->IsB())&&(f->V(1)->IsB())&&(f->V(2)->IsB())))
-		{
-
-			vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
-			vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
-			vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
-			vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
-			ScalarType area=(tex1-tex0)^(tex2-tex0);
-			if (area<=0)
-				return false;
-		}
-	}
-	return true;
-}
-
-template <class MeshType>
-bool NonFolded(MeshType &parametrized,std::vector<typename MeshType::FaceType*> &folded)
-{
-	
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename MeshType::CoordType CoordType;
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::VertexType VertexType;
-
-	const ScalarType epsilon=(ScalarType)0.00001;
-	folded.resize(0);
-	///assert parametrization
-	for (unsigned int i=0;i<parametrized.face.size();i++)
-	{
-		FaceType *f=&parametrized.face[i];
-		if (!((f->V(0)->IsB())&&(f->V(1)->IsB())&&(f->V(2)->IsB())))
-		{
-
-			vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
-			vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
-			vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
-			vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
-			ScalarType area=(tex1-tex0)^(tex2-tex0);
-			if (area<=epsilon)
-				folded.push_back(f);
-		}
-	}
-	return (folded.size()==0);
-}
-//getFoldedFaces(std::vector)
-///parametrize a submesh from trinagles that are incident on vertices with equi-area subdivision
-template <class MeshType>
-void ParametrizeStarEquilateral(MeshType &parametrized,
-								const typename MeshType::ScalarType &radius=1)
-{
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename MeshType::CoordType CoordType;
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::VertexType VertexType;
-	
-	UpdateTopologies(&parametrized);
-
-	//set borders
-
-	///find first border & non border vertex
-	std::vector<VertexType*> non_border;
-	VertexType* Start=NULL;
-	for (unsigned int i=0;i<parametrized.vert.size();i++)
-	{
-		VertexType* vert=&parametrized.vert[i];
-		if ((Start==NULL)&&(vert->IsB()))
-			Start=vert;
-
-		if (!vert->IsB())
-			non_border.push_back(vert);
-	}
-	assert(non_border.size()!=0);
-	
-	///get sorted border vertices
-  std::vector<VertexType*> vertices;
-	FindSortedBorderVertices<MeshType>(parametrized,Start,vertices);
-	
-	///set border vertices
-	int num=vertices.size();
-        typename std::vector<VertexType*>::iterator iteV;
-	ScalarType curr_angle=0;
-	vertices[0]->T().U()=cos(curr_angle)*radius;
-	vertices[0]->T().V()=sin(curr_angle)*radius;
-	ScalarType division=(2*M_PI)/(ScalarType)num;
-	///set border
-	for (unsigned int i=1;i<vertices.size();i++)
-	{
-		curr_angle+=division;
-		vertices[i]->T().U()=radius*cos(curr_angle);
-		vertices[i]->T().V()=radius*sin(curr_angle);
-	}
-
-	if (non_border.size()==1)
-	{
-		///if non-border vertex is one then set it to zero otherwise 
-		///set it to the average of neighbors
-		non_border[0]->T().P()=vcg::Point2<ScalarType>(0,0);
-	}
-	else
-	{
-		///set media of star vertices
-		assert(non_border.size()==2);
-		for (unsigned int i=0;i<non_border.size();i++)
-		{
-			VertexType *v=non_border[i];
-			v->T().P()=vcg::Point2<ScalarType>(0,0);
-			int ariety_vert=0;
-			std::vector<VertexType*> star;
-			getVertexStar<MeshType>(v,star);
-			for (unsigned int k=0;k<star.size();k++)
-			{
-				if ((!star[k]->IsD())&&(star[k]->IsB()))
-				{
-					v->T().P()+=star[k]->T().P();
-					ariety_vert++;
-				}
-			}
-			v->T().P()/=(ScalarType)ariety_vert;
-		}
-		///test particular cases
-		if (!NonFolded(parametrized))
-		{
-			std::vector<VertexType*> shared;
-			getSharedVertexStar<MeshType>(non_border[0],non_border[1],shared);
-		
-			assert(shared.size()==2);
-			assert(shared[0]->IsB());
-			assert(shared[1]->IsB());
-			assert(shared[0]!=shared[1]);
-		
-			//ScalarType epsilon=(ScalarType)0.001;
-			///then get the media of two shared vertices
-			vcg::Point2<ScalarType> uvAve=shared[0]->T().P()+shared[1]->T().P();
-			assert(uvAve.Norm()>(ScalarType)0.001);
-			uvAve.Normalize();
-			vcg::Point2<ScalarType> p0=uvAve*(ScalarType)0.3;
-			vcg::Point2<ScalarType> p1=uvAve*(ScalarType)(-0.3);
-			///then test and set right assignement
-			non_border[0]->T().P()=p0;
-			non_border[1]->T().P()=p1;
-			if (!NonFolded(parametrized)){
-				non_border[0]->T().P()=p1;
-				non_border[1]->T().P()=p0;
-			}
-		}
-	}
-
-	///final assert parametrization
-	assert(NonFolded(parametrized));
-
-}
-
-///given the mesh and the two edges (same) seen from face[0] and face[1] of the mesh construct
-///a diamond parametrization using equilateral triangles of edge edge_len
-template <class MeshType>
-void ParametrizeDiamondEquilateral(MeshType &parametrized,
-								   const int &edge0,const int &edge1,
-								   const typename MeshType::ScalarType &edge_len=1)
-{
-
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename FaceType::CoordType CoordType;
-	typedef typename FaceType::ScalarType ScalarType;
-	typedef typename FaceType::VertexType VertexType;
-	
-	ScalarType h=(sqrt(3.0)/2.0)*edge_len;
-
-	FaceType *fd0=&parametrized.face[0];
-#ifndef NDEBUG
-	FaceType *fd1=&parametrized.face[1];
-#endif
-	assert(fd0->FFp(edge0)==fd1);
-	assert(fd1->FFp(edge1)==fd0);
-
-	///get 2 vertex on the edge
-	VertexType *v0=fd0->V(edge0);
-	VertexType *v1=fd0->V((edge0+1)%3);
-
-#ifndef NDEBUG
-	VertexType *vtest0=fd1->V(edge1);
-	VertexType *vtest1=fd1->V((edge1+1)%3);
-
-	assert(v0!=v1);
-	assert(vtest0!=vtest1);
-	assert(((v0==vtest0)&&(v1==vtest1))||((v1==vtest0)&&(v0==vtest1)));
-#endif
-
-	///other 2 vertex
-	VertexType *v2=parametrized.face[0].V((edge0+2)%3);
-	VertexType *v3=parametrized.face[1].V((edge1+2)%3);
-	assert((v2!=v3)&&(v0!=v2)&&(v0!=v3)&&(v1!=v2)&&(v1!=v3));
-
-	///assing texcoords
-	v0->T().P()=vcg::Point2<ScalarType>(0,-edge_len/2.0);
-	v1->T().P()=vcg::Point2<ScalarType>(0,edge_len/2.0);
-	v2->T().P()=vcg::Point2<ScalarType>(-h,0);
-	v3->T().P()=vcg::Point2<ScalarType>(h,0);
-
-	///test
-	assert(NonFolded(parametrized));
-}
-
-///given the mesh and the two edges (same) seen from face[0] and face[1] of the mesh construct
-///a diamond parametrization using equilateral triangles of edge edge_len
-template <class MeshType>
-void ParametrizeFaceEquilateral(MeshType &parametrized,
-								   const typename MeshType::ScalarType &edge_len=1)
-{
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename FaceType::CoordType CoordType;
-	typedef typename FaceType::ScalarType ScalarType;
-	typedef typename FaceType::VertexType VertexType;
-	
-	ScalarType h=(sqrt(3.0)/2.0)*edge_len;
-
-	FaceType *f_param=&(parametrized.face[0]);
-				
-	f_param->V(0)->T().P()=vcg::Point2<ScalarType>(edge_len/2.0,0);
-	f_param->V(1)->T().P()=vcg::Point2<ScalarType>(0,h);
-	f_param->V(2)->T().P()=vcg::Point2<ScalarType>(-edge_len/2.0,0);
-}
-
-
-///parametrize and create a submesh from trinagles that are incident on
-/// vertices .... seturn a vetor of original faces
-template <class MeshType>
-void ParametrizeLocally(MeshType &parametrized,
-						const std::vector<typename MeshType::VertexType*> &subset,
-						std::vector<typename MeshType::FaceType*> &orderedFaces,
-						std::vector<typename MeshType::VertexType*> &orderedVertex)
-{
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename FaceType::CoordType CoordType;
-	typedef typename FaceType::ScalarType ScalarType;
-	typedef typename FaceType::VertexType VertexType;
-
-	orderedFaces.clear();
-        std::vector<VertexType*> vertices;
-	
-	
-	///get faces referenced by vertices
-	getSharedFace<MeshType>(subset,orderedFaces);
-	
-	///do a first copy of the mesh
-	///and parametrize it
-	///NB: order of faces is mantained
-	CopyMeshFromFaces<MeshType>(orderedFaces,orderedVertex,parametrized);
-	
-	//CreateMeshVertexStar(subset,orderedFaces,parametrized);
-	ParametrizeLocally(parametrized);	
-	
-}
-
-
-
-template <class MeshType>
-void GetUV(const typename MeshType::FaceType* f,
-		   const typename MeshType::CoordType &bary,
-		   typename MeshType::ScalarType &U,
-		   typename MeshType::ScalarType &V)
-{
-	U=bary.X()*f->V(0)->T().U()+bary.Y()*f->V(1)->T().U()+bary.Z()*f->V(2)->T().U();
-	V=bary.X()*f->V(0)->T().V()+bary.Y()*f->V(1)->T().V()+bary.Z()*f->V(2)->T().V();
-	/*if ((!((U>=-1)&&(U<=1)))||(!((V>=-1)&&(V<=1))))
-	{
-		printf("Bary:%f,%f,%f \n",bary.X(),bary.Y(),bary.Z());
-		printf("texCoord:%f,%f \n",U,V);
-		assert(0);
-	}*/
-	//assert ((U>=-1)&&(U<=1));
-	//assert ((V>=-1)&&(V<=1));
-}
-
-template <class MeshType>
-bool GetBaryFaceFromUV(const MeshType &m,
-				       const typename MeshType::ScalarType &U,
-					   const typename MeshType::ScalarType &V,
-				       typename MeshType::CoordType &bary,
-				       int &index)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	const ScalarType _EPSILON = ScalarType(0.0000001);
-	/*assert ((U>=-1)&&(U<=1));
-	assert ((V>=-1)&&(V<=1));*/
-	for (unsigned int i=0;i<m.face.size();i++)
-	{
-                const typename  MeshType::FaceType *f=&m.face[i];
-		vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
-		vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
-		vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
-
-		vcg::Point2<ScalarType> test=vcg::Point2<ScalarType>(U,V);
-		vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
-		ScalarType area=(tex1-tex0)^(tex2-tex0);
-		//assert(area>-_EPSILON);
-		///then find if the point 2d falls inside
-		if ((area>_EPSILON)&&(t2d.InterpolationParameters(test,bary.X(),bary.Y(),bary.Z())))
-		{
-			index=i;
-			///approximation errors
-			ScalarType sum=0;
-			for (int x=0;x<3;x++)
-			{
-				if (((bary[x])<=0)&&(bary[x]>=-_EPSILON))
-					bary[x]=0;
-				else
-				if (((bary[x])>=1)&&(bary[x]<=1+_EPSILON))
-					bary[x]=1;
-				sum+=bary[x];
-			}
-			if (sum==0)
-				printf("error SUM %f \n",sum);
-
-			bary/=sum;
-			return true;
-		}
-	}
-
-	return (false);
-}
-
-template <class FaceType>
-bool GetBaryFaceFromUV(std::vector<FaceType*> faces,
-				       const typename FaceType::ScalarType &U,
-					   const typename FaceType::ScalarType &V,
-				       typename FaceType::CoordType &bary,
-				       int &index)
-{
-	typedef typename FaceType::CoordType CoordType;
-	typedef typename FaceType::ScalarType ScalarType;
-	typedef typename FaceType::VertexType VertexType;
-	typedef typename FaceType::ScalarType ScalarType;
-	const ScalarType _EPSILON = ScalarType(0.0000001);
-	/*assert ((U>=-1)&&(U<=1));
-	assert ((V>=-1)&&(V<=1));*/
-	for (unsigned int i=0;i<faces.size();i++)
-	{
-		FaceType *f=faces[i];
-		vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
-		vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
-		vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
-
-		vcg::Point2<ScalarType> test=vcg::Point2<ScalarType>(U,V);
-		vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
-		ScalarType area=fabs((tex1-tex0)^(tex2-tex0));
-		//assert(area>-_EPSILON);
-		///then find if the point 2d falls inside
-		if ((area>_EPSILON)&&(t2d.InterpolationParameters(test,bary.X(),bary.Y(),bary.Z())))
-		{
-			index=i;
-			
-			///approximation errors
-			ScalarType sum=0;
-			for (int x=0;x<3;x++)
-			{
-				if (((bary[x])<=0)&&(bary[x]>=-_EPSILON))
-					bary[x]=0;
-				else
-				if (((bary[x])>=1)&&(bary[x]<=1+_EPSILON))
-					bary[x]=1;
-				sum+=fabs(bary[x]);
-			}
-			if (sum==0)
-				printf("error SUM %f \n",sum);
-			
-			bary/=sum;
-			/*if (!((bary.X()>=0)&& (bary.X()<=1)))
-				printf("error %f \n",bary.X());*/
-			/*ScalarType diff=(1.0-bary.X()-bary.Y()-bary.Z());
-			bary.X()+=diff;*/
-			return true;
-		}
-	}
-
-	return (false);
-}
-
-template <class MeshType>
-bool GetBaryFaceFromUV(const MeshType &m,
-				       const typename MeshType::ScalarType &U,
-					   const typename MeshType::ScalarType &V,
-				       const std::vector<typename MeshType::FaceType*> &orderedFaces,
-				       typename MeshType::CoordType &bary,
-				       typename MeshType::FaceType* &chosen)
-{
-	int index;
-	bool found=GetBaryFaceFromUV(m,U,V,bary,index);
-	if(!found) {
-			chosen=0;
-			return false;
-		}
-	chosen=orderedFaces[index];
-	return true;
-}
-
-template <class MeshType>
-bool GetCoordFromUV(const MeshType &m,
-				    const typename MeshType::ScalarType &U,
-					const typename MeshType::ScalarType &V,
-				    typename MeshType::CoordType &val,
-					bool rpos=false)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	const ScalarType _EPSILON = (ScalarType)0.00001;
-	for (unsigned int i=0;i<m.face.size();i++)
-	{
-                const typename MeshType::FaceType *f=&m.face[i];
-		vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
-		vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
-		vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
-
-		vcg::Point2<ScalarType> test=vcg::Point2<ScalarType>(U,V);
-		vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
-		ScalarType area=(tex1-tex0)^(tex2-tex0);
-		///then find if the point 2d falls inside
-                typename MeshType::CoordType bary;
-		if ((area>_EPSILON)&&(t2d.InterpolationParameters(test,bary.X(),bary.Y(),bary.Z())))
-		{
-			///approximation errors
-			for (int x=0;x<3;x++)
-			{
-				if (((bary[x])<=0)&&(bary[x]>=-_EPSILON))
-					bary[x]=0;
-				else
-				if (((bary[x])>=1)&&(bary[x]<=1+_EPSILON))
-					bary[x]=1;
-			}	
-			ScalarType diff=(1.0-bary.X()-bary.Y()-bary.Z());
-			bary.X()+=diff;
-			if (!rpos)
-				val=f->P(0)*bary.X()+f->P(1)*bary.Y()+f->P(0)*bary.Z();
-			else
-				val=f->V(0)->RPos*bary.X()+f->V(1)->RPos*bary.Y()+f->V(2)->RPos*bary.Z();
-			
-			return true;
-		}
-	}
-	return false;
-}
-
-template <class MeshType>
-typename MeshType::ScalarType GetSmallestUVEdgeSize(const MeshType &m)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-
-	ScalarType smallest=100.f;
-	assert(m.fn>0);
-	for (int i=0;i<m.face.size();i++)
-	{
-
-		///approximation errors
-			for (int j=0;j<3;j++)
-			{
-
-				vcg::Point2<ScalarType> uv0=m.face[i].V(j)->T().P();
-				vcg::Point2<ScalarType> uv1=m.face[i].V((j+1)%3)->T().P();
-				ScalarType test=(uv0-uv1).Norm();
-				if (test<smallest)
-					smallest=test;
-			}
-	}
-	return smallest;
-}
-
-template <class MeshType>
-typename MeshType::ScalarType GetSmallestUVHeight(const MeshType &m)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	ScalarType smallest=(ScalarType)100.0;
-	ScalarType eps=(ScalarType)0.0001;
-	assert(m.fn>0);
-	for (unsigned int i=0;i<m.face.size();i++)
-	{
-                const typename MeshType::FaceType *f=&m.face[i];
-		///approximation errors
-		for (int j=0;j<3;j++)
-		{
-			vcg::Point2<ScalarType> uv0=f->V(j)->cT().P();
-			vcg::Point2<ScalarType> uv1=f->V1(j)->cT().P();
-			vcg::Point2<ScalarType> uv2=f->V2(j)->cT().P();
-			ScalarType area=fabs((uv1-uv0)^(uv2-uv0));
-			ScalarType base=(uv1-uv2).Norm();
-			ScalarType h_test=area/base;
-			if (h_test<smallest)
-					smallest=h_test;
-			}
-	}
-	if (smallest<eps)
-		smallest=(ScalarType)eps;
-	if (smallest>(ScalarType)0.05)
-		smallest=(ScalarType)0.05;
-	return smallest;
-}
-
-template <class MeshType>
-void ParametrizeStarEquilateral(typename MeshType::VertexType *center,
-								bool /*subvertices=true*/)
-{
-	///initialize domain
-	typedef typename MeshType::VertexType VertexType;
-	typedef typename MeshType::FaceType FaceType;
-	typedef typename MeshType::CoordType CoordType;
-
-	MeshType parametrized;
-	std::vector<VertexType*> vertices,ordVert;
-	std::vector<VertexType*> HresVert;
-	std::vector<FaceType*> faces;
-	vertices.push_back(center);
-	getSharedFace<MeshType>(vertices,faces);
-	CopyMeshFromFaces<MeshType>(faces,ordVert,parametrized);
-
-	///parametrize and then copy back
-	ParametrizeStarEquilateral<MeshType>(parametrized);
-	for (unsigned int i=0;i<ordVert.size();i++)
-		ordVert[i]->T().P()=parametrized.vert[i].T().P();
-
-	///initialize sub-vertices
-	getHresVertex<FaceType>(faces,HresVert);
-	for (unsigned int i=0;i<HresVert.size();i++)
-	{
-		FaceType *father=HresVert[i]->father;
-		CoordType Bary=HresVert[i]->Bary;
-		GetUV<MeshType>(father,Bary,HresVert[i]->T().U(),HresVert[i]->T().V());
-	}
-}
-
-#endif
+
+
+#include "defines.h"
+///fitting
+#include <vcg/space/fitting3.h>
+#include <vcg/math/matrix33.h>
+#include <vcg/space/triangle2.h>
+#include "texcoord_optimization.h"
+#include "mesh_operators.h"
+
+#ifndef LOCAL_PARAMETRIZATION
+#define LOCAL_PARAMETRIZATION
+
+//#include <vcg/complex/algorithms/point_sampling.h>
+
+//#define samples_area 80
+
+template <class MeshType>
+void ParametrizeExternal(MeshType &to_parametrize)
+{
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename MeshType::CoordType CoordType;
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::VertexType VertexType;
+
+        std::vector<VertexType*> vertices;
+	
+	///find first border vertex
+        VertexType* Start=NULL;
+        typename MeshType::VertexIterator Vi=to_parametrize.vert.begin();
+	
+	while ((Start==NULL)&&(Vi<to_parametrize.vert.end()))
+	{
+		if (((*Vi).IsB())&&(!(*Vi).IsD()))
+			Start=&(*Vi);
+		Vi++;
+	}
+	if (Vi==to_parametrize.vert.end())
+	{
+		assert(0);
+	}
+	///get sorted border vertices
+	
+	FindSortedBorderVertices<MeshType>(to_parametrize,Start,vertices);
+
+	//assert(vertices.size()>=4);
+	
+	///find perimeter
+	ScalarType perimeter=0;
+	int size=vertices.size();
+	for (int i=0;i<size;i++)
+		perimeter+=(vertices[i]->P()-vertices[(i+1)%size]->P()).Norm();
+	
+	///find scaling factor
+	/*ScalarType Sperimeter=(2.0*M_PI)/perimeter;*/
+	
+	///set default texCoords
+	for (Vi=to_parametrize.vert.begin();Vi!=to_parametrize.vert.end();Vi++)
+	{
+		(*Vi).T().U()=-2;
+		(*Vi).T().V()=-2;
+	}
+
+	///set border vertices
+        typename std::vector<VertexType*>::iterator iteV;
+	/*ScalarType curr_perim=0;*/
+	ScalarType curr_angle=0;
+	vertices[0]->T().U()=cos(curr_angle);
+	vertices[0]->T().V()=sin(curr_angle);
+	//for (int i=1;i<vertices.size();i++)
+	//{
+	//	curr_perim+=(vertices[i]->P()-vertices[(i-1)]->P()).Norm();
+	//	//curr_perim+=perimeter/(ScalarType)size;
+	//	curr_angle=curr_perim*Sperimeter;
+	//	vertices[i]->T().U()=cos(curr_angle);
+	//	vertices[i]->T().V()=sin(curr_angle);
+	//	assert((vertices[i]->T().U()>=-1)&&(vertices[i]->T().U()<=1));
+	//	assert((vertices[i]->T().V()>=-1)&&(vertices[i]->T().V()<=1));
+	//}
+	ScalarType anglediv=(2.0*M_PI)/(ScalarType)(vertices.size());
+	curr_angle=0;
+	for (unsigned int i=1;i<vertices.size();i++)
+	{
+		curr_angle+=anglediv;
+		vertices[i]->T().U()=cos(curr_angle);
+		vertices[i]->T().V()=sin(curr_angle);
+		assert((vertices[i]->T().U()>=-1)&&(vertices[i]->T().U()<=1));
+		assert((vertices[i]->T().V()>=-1)&&(vertices[i]->T().V()<=1));
+	}
+}
+
+template <class MeshType>
+void ParametrizeInternal(MeshType &to_parametrize)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	const ScalarType Eps=(ScalarType)0.0001;
+	///set internal vertices
+        for (typename MeshType::VertexIterator Vi=to_parametrize.vert.begin();Vi!=to_parametrize.vert.end();Vi++)
+	{
+		//assert(!Vi->IsD());
+		if ((!Vi->IsB())&&(!Vi->IsD()))
+		{
+			///find kernel
+                        std::vector<typename MeshType::VertexType*> star;
+			getVertexStar<MeshType>(&(*Vi),star);
+			ScalarType kernel=0;
+			for (unsigned int k=0;k<star.size();k++)
+				if (star[k]->IsB())
+				{
+					ScalarType dist=((*Vi).P()-star[k]->P()).Norm();
+					if (dist<Eps)
+						dist=Eps;
+					//ScalarType peso=1.0/(dist);
+					ScalarType peso=(dist)/star.size();
+					kernel+=(peso);//*dist);
+				}
+			assert(kernel>0);
+			///then find factor
+			kernel=1.0/kernel;       
+
+			(*Vi).T().U()=0;
+			(*Vi).T().V()=0;
+			
+			int num=0;
+			///find weighted media
+			for (unsigned int k=0;k<star.size();k++)
+				if (star[k]->IsB())
+				{
+					ScalarType dist=((*Vi).P()-star[k]->P()).Norm();
+					if (dist<Eps)
+						dist=Eps;
+					//ScalarType peso=1.0/(dist);
+					ScalarType peso=(dist)/star.size();
+					ScalarType kval=(peso)*kernel;
+					assert(kval>0);
+					(*Vi).T().U()+=kval*star[k]->T().U();
+					(*Vi).T().V()+=kval*star[k]->T().V();
+					num++;
+				}
+			////on border case 2 neighbors
+			///go next to the center
+			/*if (num==2)
+			{
+				(*Vi).T().U()/=2.0;
+				(*Vi).T().V()/=2.0;
+			}*/
+			/*ScalarType u=(*Vi).T().U();
+			ScalarType v=(*Vi).T().V();*/
+			assert(((*Vi).T().U()>=-1)&&((*Vi).T().U()<=1));
+			assert(((*Vi).T().V()>=-1)&&((*Vi).T().V()<=1));
+		}
+	}
+	///smoothing of txcoords
+	InitDampRestUV(to_parametrize);
+        for (typename MeshType::VertexIterator Vi=to_parametrize.vert.begin();Vi!=to_parametrize.vert.end();Vi++)
+	{
+		if ((!Vi->IsB())&&(!Vi->IsD()))
+		{
+                        std::vector<typename MeshType::VertexType*> star;
+			getVertexStar<MeshType>(&(*Vi),star);
+			vcg::Point2<ScalarType> UV=vcg::Point2<ScalarType>(0,0);
+			for (unsigned int k=0;k<star.size();k++)
+				UV+=star[k]->RestUV;
+			UV/=(ScalarType)star.size();
+			(*Vi).T().P()=UV;
+		}
+	}
+}
+
+
+template <class FaceType>
+typename FaceType::CoordType InterpolatePos
+(FaceType* f, const typename FaceType::CoordType &bary)
+{return (f->V(0)->P()*bary.X()+f->V(1)->P()*bary.Y()+f->V(2)->P()*bary.Z());}
+
+template <class FaceType>
+typename FaceType::CoordType InterpolateRPos
+(FaceType* f,const typename FaceType::CoordType &bary)
+{	
+	return (f->V(0)->RPos*bary.X()+f->V(1)->RPos*bary.Y()+f->V(2)->RPos*bary.Z());
+}
+
+template <class FaceType>
+typename FaceType::CoordType InterpolateNorm
+(FaceType* f, const typename FaceType::CoordType &bary)
+{	
+        typedef typename FaceType::CoordType CoordType;
+	CoordType n0=f->V(0)->N();
+	CoordType n1=f->V(1)->N();
+	CoordType n2=f->V(2)->N();
+	return (n0*bary.X()+n1*bary.Y()+n2*bary.Z());
+}
+
+template <class ScalarType>
+int Approx(const ScalarType &value)
+{
+	ScalarType val0=floor(value);
+	ScalarType val1=ceil(value);
+	if (fabs(val0-value)<fabs(val1-value))
+		return ((int)val0);
+	else
+		return ((int)val1);
+}
+
+template <class FaceType>
+vcg::Point3i InterpolateColor
+(FaceType* f,const typename FaceType::CoordType &bary)
+{	
+        typedef typename FaceType::ScalarType ScalarType;
+	vcg::Color4b c0=f->V(0)->C();
+	vcg::Color4b c1=f->V(1)->C();
+	vcg::Color4b c2=f->V(2)->C();
+	double R=(ScalarType)c0.X()*bary.X()+(ScalarType)c1.X()*bary.Y()+(ScalarType)c2.X()*bary.Z();
+	double G=(ScalarType)c0.Y()*bary.X()+(ScalarType)c1.Y()*bary.Y()+(ScalarType)c2.Y()*bary.Z();
+	double B=(ScalarType)c0.Z()*bary.X()+(ScalarType)c1.Z()*bary.Y()+(ScalarType)c2.Z()*bary.Z();
+
+	vcg::Point3i p=vcg::Point3i(Approx(R),Approx(G),Approx(B));
+
+	assert(p.X()<=255);
+	assert(p.Y()<=255);
+	assert(p.Z()<=255);
+
+	return (p);
+}
+
+template <class VertexType>
+typename VertexType::CoordType ProjectPos(const VertexType &v)
+{
+	typedef typename VertexType::FaceType FaceType;
+	typedef typename VertexType::CoordType CoordType;
+
+	FaceType *f=v.father;
+	CoordType b=v.Bary;
+	return (InterpolatePos<FaceType>(f,b));
+}
+
+template <class VertexType>
+typename VertexType::CoordType Warp(const VertexType* v)
+{
+        typename VertexType::FaceType * father=v->father;
+        typename VertexType::CoordType proj=father->P(0)*v->Bary.X()+father->P(1)*v->Bary.Y()+father->P(2)*v->Bary.Z();
+	return proj;
+}
+
+template <class VertexType>
+typename VertexType::CoordType WarpRpos(const VertexType* v)
+{
+        typename VertexType::FaceType * father=v->father;
+        typename VertexType::CoordType proj=father->V(0)->RPos*v->Bary.X()+father->V(1)->RPos*v->Bary.Y()+father->V(2)->RPos*v->Bary.Z();
+	return proj;
+}
+
+template <class MeshType>
+typename MeshType::ScalarType EstimateLenghtByParam
+								(const typename MeshType::VertexType* v0,
+								 const typename MeshType::VertexType* v1,
+								 typename MeshType::FaceType* on_edge[2])
+{
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename MeshType::CoordType CoordType;
+	typedef typename MeshType::VertexType VertexType;
+	typedef typename MeshType::ScalarType ScalarType;
+
+//	assert((on_edge.size()==0)||(on_edge.size()==1));
+	ScalarType estimated[2]={0,0};
+	int num[2]={0,0};
+	
+	for (int i=0;i<2;i++)
+	{
+		FaceType *test_face=on_edge[i];
+
+		int edge_index=EdgeIndex(test_face,v0,v1);
+		FaceType *Fopp=test_face->FFp(edge_index);
+
+		if (test_face->vertices_bary.size()<2)
+		{
+			ScalarType dist=Distance(v0->RPos,v1->RPos);
+			//#pragma omp atomic
+			estimated[i]+=dist;
+			num[i]=0;
+			continue;
+		}
+
+		///collect vertices
+		std::vector<VertexType*> vertices;
+		vertices.reserve(test_face->vertices_bary.size());
+		for (unsigned int k=0;k<test_face->vertices_bary.size();k++)
+			vertices.push_back(test_face->vertices_bary[k].first);
+
+		
+		///collect faces
+		std::vector<FaceType*> faces;
+		getSharedFace<MeshType>(vertices,faces);
+
+		///get border edges
+		std::vector<std::pair<VertexType*,VertexType*> > edges;
+		for (unsigned int j=0;j<faces.size();j++)
+		{
+			FaceType*f=faces[j];
+			///find if there is an on-edge edge
+			bool found=false;
+			int k=0;
+			while  ((k<3)&&(!found))
+			{
+				if ((f->V0(k)->father==test_face)&&
+					(f->V1(k)->father==test_face)&&
+					(f->V2(k)->father==Fopp))
+				{
+					edges.push_back(std::pair<VertexType*,VertexType*>(f->V0(k),f->V1(k)));
+					found=true;
+				}
+				k++;
+			}
+		}
+		
+		///find if there's ant edge return inital lenght
+		if (edges.size()==0)
+		{
+			estimated[i]+=(Distance(v0->RPos,v1->RPos));
+			num[i]=0;
+			continue;
+		}
+		else
+		{
+			//get edge direction
+			///store the two nearest for each vertex
+			/*VertexType *n0=edges[0].first;
+			VertexType *n1=edges[0].second;
+			ScalarType d0=(Warp(n0)-v0->P()).Norm();
+			ScalarType d1=(Warp(n1)-v1->P()).Norm();*/
+
+			//CoordType edgedir=v0->cP()-v1->cP();
+			CoordType edgedir=v0->RPos-v1->RPos;
+			edgedir.Normalize();
+			num[i]=edges.size();
+			for (unsigned int e=0;e<edges.size();e++)
+			{
+				VertexType *vH0=edges[e].first;
+				VertexType *vH1=edges[e].second;
+
+				///project points over the plane 
+				/*CoordType proj0=Warp(vH0);
+				CoordType proj1=Warp(vH1);*/
+				CoordType proj0=WarpRpos(vH0);
+				CoordType proj1=WarpRpos(vH1);
+				
+				CoordType dirproj=proj0-proj1;
+				dirproj.Normalize();
+				//estimated[i]+=fabs(dirproj*edgedir)*((vH0->P()-vH1->P()).Norm());
+				//#pragma omp atomic
+				estimated[i]+=fabs(dirproj*edgedir)*((vH0->RPos-vH1->RPos).Norm());
+
+			}
+		}
+	}
+
+	///media of estimated values
+	ScalarType alpha0,alpha1;
+	ScalarType max_num=abstraction_num;
+
+	if (num[0]>=max_num)
+		alpha0=1;
+	else
+		alpha0=num[0]/max_num;
+
+	if (num[1]>=max_num)
+		alpha1=1;
+	else
+		alpha1=num[1]/max_num;
+
+	estimated[0]=alpha0*estimated[0]+(1.0-alpha0)*(Distance(v0->RPos,v1->RPos));
+	estimated[1]=alpha1*estimated[1]+(1.0-alpha1)*(Distance(v0->RPos,v1->RPos));
+	return((estimated[0]+estimated[1])/2.0);
+}
+
+template <class MeshType>
+void MeanVal(const std::vector<vcg::Point2<typename MeshType::ScalarType> > &Points,
+			 std::vector<typename MeshType::ScalarType> &Lamda,
+			 typename MeshType::CoordType &p)
+{
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename MeshType::VertexType VertexType;
+	typedef typename MeshType::ScalarType ScalarType;
+        typedef typename MeshType::CoordType CoordType;
+
+	int size=Points.size();
+	Lamda.resize(size);
+
+	ScalarType sum=0;	
+	for (int i=0;i<size;i++)
+	{
+		int size=Points.size()-1;
+		vcg::Point2<ScalarType> Pcurr=Points[i];
+		vcg::Point2<ScalarType> Pprev=Points[(i+(size-1))%size];
+		vcg::Point2<ScalarType> Pnext=Points[(i+1)%size];
+
+		CoordType v0=Pprev-p;
+		CoordType v1=Pcurr-p;
+		CoordType v2=Pnext-p;
+		ScalarType l=v1.Norm();
+		v0.Normalize();
+		v1.Normalize();
+		v2.Normalize();
+
+		ScalarType Alpha0=acos(v0*v1);
+		ScalarType Alpha1=acos(v1*v2);
+
+                Lamda[i]=(tan(Alpha0/2.0)+tan(Alpha1/2.0))/l;
+                sum+=Lamda[i];
+	}
+
+	///normalization
+	for (int i=0;i<size;i++)
+                Lamda[i]/=sum;
+}
+
+template <class FaceType>
+typename FaceType::ScalarType EstimateAreaByParam(const FaceType* f)
+{
+	typedef typename FaceType::VertexType VertexType;
+	typedef typename FaceType::ScalarType ScalarType;
+	
+	int num=0;
+	ScalarType estimated=0;
+	for (unsigned int k=0;k<f->vertices_bary.size();k++)
+	{
+		VertexType *HresVert=f->vertices_bary[k].first;
+		estimated+=HresVert->area;
+		num++;
+	}
+
+	///media of estimated values
+	ScalarType alpha;
+	ScalarType max_num=abstraction_num;
+
+	if (num>=max_num)
+		alpha=1;
+	else
+		alpha=num/max_num;
+
+	ScalarType Rarea=((f->V(1)->RPos-f->V(0)->RPos)^(f->V(2)->RPos-f->V(0)->RPos)).Norm()/2.0;
+	estimated=alpha*estimated+(1.0-alpha)*Rarea;
+
+	return(estimated);
+}
+
+template <class MeshType>
+typename MeshType::ScalarType EstimateAreaByParam
+							  (const typename MeshType::VertexType* v0,
+							   const typename MeshType::VertexType* v1,
+							   typename MeshType::FaceType* on_edge[2])
+{
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename MeshType::VertexType VertexType;
+	typedef typename MeshType::ScalarType ScalarType;
+
+	//MeshType::PerVertexAttributeHandle<AuxiliaryVertData> handle = vcg::tri::Allocator<MeshType>::GetPerVertexAttribute<AuxiliaryVertData>(mesh,"AuxiliaryVertData");
+
+	ScalarType estimated[2]={0,0};
+	int num[2]={0,0};
+	VertexType *v2[2];
+	for (int i=0;i<2;i++)
+	{
+		FaceType *test_face=on_edge[i];
+
+		for (int k=0;k<3;k++)
+			if ((test_face->V(k)!=v0)&&(test_face->V(k)!=v1))
+				v2[i]=test_face->V(k);
+		
+		for (unsigned int k=0;k<test_face->vertices_bary.size();k++)
+		{
+			VertexType *brother=test_face->vertices_bary[k].first;
+			estimated[i]+=brother->area;
+			//estimated[i]+=handle[brother].area;
+			num[i]++;
+		}
+	}
+
+	///media of estimated values
+	ScalarType alpha0,alpha1;
+	ScalarType max_num=abstraction_num;//20
+
+	if (num[0]>=max_num)
+		alpha0=1;
+	else
+		alpha0=num[0]/max_num;
+
+	if (num[1]>=max_num)
+		alpha1=1;
+	else
+		alpha1=num[1]/max_num;
+	ScalarType Rarea0=((on_edge[0]->V(1)->RPos-on_edge[0]->V(0)->RPos)^(on_edge[0]->V(2)->RPos-on_edge[0]->V(0)->RPos)).Norm()/2.0;
+	ScalarType Rarea1=((on_edge[1]->V(1)->RPos-on_edge[1]->V(0)->RPos)^(on_edge[1]->V(2)->RPos-on_edge[1]->V(0)->RPos)).Norm()/2.0;
+	estimated[0]=alpha0*estimated[0]+(1.0-alpha0)*Rarea0;
+	estimated[1]=alpha1*estimated[1]+(1.0-alpha1)*Rarea1;
+	return((estimated[0]+estimated[1])/2.0);
+}
+
+///template class used to sample surface
+template <class FaceType>
+class VertexSampler{
+	typedef typename FaceType::CoordType CoordType;
+public: 
+	std::vector<CoordType> points;
+
+	void AddFace(const FaceType &f,const CoordType & bary)
+	{points.push_back(f.P(0)*bary.X()+f.P(1)*bary.Y()+f.P(2)*bary.Z());}
+};
+
+
+///sample 3d vertex possible's position
+///using area criterion
+//template <class MeshType>
+//void SamplingPoints(MeshType &mesh,
+//					std::vector<typename MeshType::CoordType> &pos)
+//{
+//	typedef typename MeshType::CoordType CoordType;
+//	typedef VertexSampler<MeshType::FaceType> Sampler;
+//	pos.reserve(samples_area);
+//	Sampler ps;
+//	ps.points.reserve(samples_area);
+//
+//	vcg::tri::SurfaceSampling<MeshType,Sampler>::Montecarlo(mesh,ps,samples_area);
+//	pos=std::vector<CoordType>(ps.points.begin(),ps.points.end());
+//}
+
+template <class MeshType> 
+void InitDampRestUV(MeshType &m)
+{
+	for (unsigned int i=0;i<m.vert.size();i++)
+		m.vert[i].RestUV=m.vert[i].T().P();
+}
+
+
+template <class MeshType> 
+void RestoreRestUV(MeshType &m)
+{
+	for (unsigned int i=0;i<m.vert.size();i++)
+		m.vert[i].T().P()=m.vert[i].RestUV;
+}
+
+
+///parametrize a submesh from trinagles that are incident on vertices 
+template <class MeshType>
+void ParametrizeLocally(MeshType &parametrized,
+						bool fix_boundary=true,
+						bool init_border=true)
+{
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::CoordType CoordType;
+
+	//const ScalarType epsilon=(ScalarType)0.0001;
+	
+
+	///save old positions
+
+	std::vector<CoordType> positions;
+	positions.resize(parametrized.vert.size());
+	///set rest position
+	for (unsigned int i=0;i<parametrized.vert.size();i++)
+	{
+		positions[i]=parametrized.vert[i].P();
+		parametrized.vert[i].P()=parametrized.vert[i].RPos;
+	}
+
+	UpdateTopologies(&parametrized);
+
+	if (init_border)
+		ParametrizeExternal(parametrized);
+
+	ParametrizeInternal(parametrized);
+	
+	//for (int i=0;i<parametrized.vert.size();i++)
+	//	parametrized.vert[i].RPos=parametrized.vert[i].P();
+
+	vcg::tri::MeanValueTexCoordOptimization<MeshType> opt(parametrized);
+	//vcg::tri::WachspressTexCoordOptimization<MeshType> opt(parametrized);
+	vcg::tri::AreaPreservingTexCoordOptimization<MeshType> opt1(parametrized);
+	opt.SetSpeed((ScalarType)0.0005);
+	InitDampRestUV(parametrized);
+	if (fix_boundary)
+	{
+		opt.TargetEquilateralGeometry();
+		//opt.TargetCurrentGeometry();
+		opt.SetBorderAsFixed();
+		opt.IterateUntilConvergence((ScalarType)0.000001,100);
+		/*opt.Iterate();
+		opt.Iterate();*/
+	}
+	else
+	{
+		opt1.TargetCurrentGeometry();
+		//opt1.SetBorderAsFixed();
+		opt1.IterateUntilConvergence((ScalarType)0.000001,200);
+	}
+
+	///assert parametrization
+	for (unsigned int i=0;i<parametrized.face.size();i++)
+	{
+		FaceType *f=&parametrized.face[i];
+		vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
+		vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
+		vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
+		vcg::Triangle2<typename MeshType::ScalarType> t2d=vcg::Triangle2<typename MeshType::ScalarType>(tex0,tex1,tex2);
+#ifndef NDEBUG
+		ScalarType area=(tex1-tex0)^(tex2-tex0);
+		assert(area>0);
+#endif
+//#ifndef _MESHLAB
+//		if (area<0){
+//			vcg::tri::io::ExporterPLY<BaseMesh>::Save(parametrized,"case0.ply");
+//
+//			for (int j=0;j<parametrized.vert.size();j++)
+//			{
+//				parametrized.vert[j].P().V(0)=parametrized.vert[j].T().U();
+//				parametrized.vert[j].P().V(1)=parametrized.vert[j].T().V();
+//				parametrized.vert[j].P().V(2)=0;
+//			}
+//			vcg::tri::io::ExporterPLY<BaseMesh>::Save(parametrized,"case1.ply");
+//			assert(0);
+//		}
+//#endif
+	}
+	///restore position
+	for (unsigned int i=0;i<parametrized.vert.size();i++)	
+		parametrized.vert[i].P()=positions[i];
+}
+
+template <class MeshType>
+void ForceInParam(vcg::Point2<typename MeshType::ScalarType> &UV,MeshType &domain)
+{
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename MeshType::CoordType CoordType;
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::VertexType VertexType;
+
+	ScalarType minDist=(ScalarType)1000.0;
+	vcg::Point2<ScalarType> closest;
+	vcg::Point2<ScalarType> center=vcg::Point2<ScalarType>(0,0);
+	for (unsigned int i=0;i<domain.face.size();i++)	
+	{
+		FaceType *f=&domain.face[i];
+		vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
+		vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
+		vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
+		center+=tex0;
+		center+=tex1;
+		center+=tex2;
+		vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
+		ScalarType dist;
+		vcg::Point2<ScalarType> temp;
+		t2d.PointDistance(UV,dist,temp);
+		if (dist<minDist)
+		{
+			minDist=dist;
+			closest=temp;
+		}
+	}
+	center/=(ScalarType)(domain.face.size()*3);
+	UV=closest*(ScalarType)0.95+center*(ScalarType)0.05;
+}
+
+
+template <class VertexType>
+bool testParamCoords(VertexType *v)
+{
+	typedef typename VertexType::ScalarType ScalarType;
+	ScalarType eps=(ScalarType)0.00001;
+	if (!(((v->T().P().X()>=-1-eps)&&(v->T().P().X()<=1+eps)&&
+		   (v->T().P().Y()>=-1-eps)&&(v->T().P().Y()<=1+eps))))
+			return (false);
+
+	return true;
+}
+
+template <class MeshType>
+bool testParamCoords(MeshType &domain)
+{
+	for (unsigned int i=0;i<domain.vert.size();i++)
+	{
+                typename MeshType::VertexType *v=&domain.vert[i];
+                bool b=testParamCoords<typename MeshType::VertexType>(v);
+		if (!b)
+		{
+			#ifndef _MESHLAB
+			printf("\n position %lf,%lf \n",v->T().U(),v->T().V());
+			#endif
+			return false;
+		}
+	}
+	return true;
+}
+
+template <class CoordType>
+bool testBaryCoords(CoordType &bary)
+{
+	typedef typename CoordType::ScalarType ScalarType;
+	///test
+	float eps=(ScalarType)0.0001;
+	if(!(fabs(bary.X()+bary.Y()+bary.Z()-1.0)<eps))
+		return false;
+	if(!((bary.X()<=1.0)&&(bary.X()>=-eps)&&(bary.Y()<=1.0)&&(bary.Y()>=-eps)&&(bary.Z()<=1.0)&&(bary.Z()>=-eps)))
+		return false;
+	return true;
+}
+
+template <class CoordType>
+bool NormalizeBaryCoords(CoordType &bary)
+{
+	bool isOK=testBaryCoords(bary);
+	if (!isOK)
+		return false;
+
+	typedef typename CoordType::ScalarType ScalarType;
+
+	///test <0
+	if (bary.X()<0)
+		bary.X()=0;
+	if (bary.Y()<0)
+		bary.Y()=0;
+	if (bary.Z()<0)
+		bary.Z()=0;
+
+	///test >1
+	if (bary.X()>1.0)
+		bary.X()=1.0;
+	if (bary.Y()>1.0)
+		bary.Y()=1.0;
+	if (bary.Z()>1.0)
+		bary.Z()=1.0;
+	
+	///test sum
+	ScalarType diff=bary.X()+bary.Y()+bary.Z()-1.0;
+	bary.X()-=diff;
+
+	if (bary.X()<0)
+		bary.X()=0;
+	return true;
+}
+
+template <class MeshType>
+void AssingFather(typename MeshType::VertexType &v,
+									typename MeshType::FaceType *father,
+									typename MeshType::CoordType &bary,
+                  MeshType & domain)
+{
+#ifdef _DEBUG
+	const typename MeshType::ScalarType eps=(typename MeshType::ScalarType)0.00001;
+	assert((father-&(*domain.face.begin()))<(int)domain.face.size());
+	assert(!(father->IsD()));
+	assert(!(father==NULL));
+	assert((bary.X()>=0)&&(bary.X()<=1)&&
+				 (bary.Y()>=0)&&(bary.Y()<=1)&&
+				 (bary.Z()>=0)&&(bary.Z()<=1)&&
+				 ((bary.X()+bary.Y()+bary.Z())<=1+eps)&&
+				 ((bary.X()+bary.Y()+bary.Z())>=1-eps));
+#endif
+	v.father=father;
+	v.Bary=bary;
+}
+
+template <class MeshType>
+bool testParametrization(MeshType &domain,
+						 MeshType &Hlev)
+{
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename MeshType::CoordType CoordType;
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::VertexType VertexType;
+	bool is_good=true;
+	int num_del=0;
+	int num_null=0;
+	int fath_son=0;
+	int wrong_address=0;
+	for (unsigned int i=0;i<Hlev.vert.size();i++)
+	{
+		VertexType *v=&Hlev.vert[i];
+		bool isGoodAddr=true;
+		if ((v->father-&(*domain.face.begin()))>=(int)domain.face.size())
+		{
+			printf("\n ADDRESS EXCEEDS OF %d \n",v->father-&(*domain.face.begin()));
+			wrong_address++;
+			is_good=false;
+			isGoodAddr=false;
+		}
+		if ((isGoodAddr)&&(v->father==NULL))
+		{
+			//printf("\n PAR ERROR : father NULL\n");
+			num_null++;
+			is_good=false;
+		}
+		if ((isGoodAddr)&&(v->father->IsD()))
+		{
+			//printf("\n PAR ERROR : father DELETED \n");
+			num_del++;
+			is_good=false;
+		}
+		if ((isGoodAddr)&&(!(((v->Bary.X()>=0)&&(v->Bary.X()<=1))&&
+		((v->Bary.Y()>=0)&&(v->Bary.Y()<=1))&&
+		((v->Bary.Z()>=0)&&(v->Bary.Z()<=1)))))
+		{
+			printf("\n PAR ERROR : bary coords exceeds: %f,%f,%f \n",v->Bary.X(),v->Bary.Y(),v->Bary.Z());
+			is_good=false;
+		}
+	}
+	for (unsigned int i=0;i<domain.face.size();i++)
+	{
+		FaceType *face=&domain.face[i];
+		if (!face->IsD())
+		{
+			for (unsigned int j=0;j<face->vertices_bary.size();j++)
+			{
+				VertexType *v=face->vertices_bary[j].first;
+				if (v->father!=face)
+				{
+					//printf("\n PAR ERROR : Father<->son \n");
+					fath_son++;
+					v->father=face;
+					is_good=false;
+				}
+			}
+		}
+	}
+	
+	if (num_del>0)
+		printf("\n PAR ERROR %d Father isDel  \n",num_del);
+	if (num_null>0)
+		printf("\n PAR ERROR %d Father isNull \n",num_null);
+	if (fath_son>0)
+		printf("\n PAR ERROR %d Father<->son  \n",fath_son);
+	if (wrong_address>0)
+	{
+		printf("\n PAR ERROR %d Wrong Address Num Faces %d\n",wrong_address,domain.fn);
+		/*system("pause");*/
+	}
+	return (is_good);
+}
+
+template <class MeshType>
+bool NonFolded(MeshType &parametrized)
+{
+	//const ScalarType epsilon=0.00001;
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename MeshType::CoordType CoordType;
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::VertexType VertexType;
+	///assert parametrization
+	for (unsigned int i=0;i<parametrized.face.size();i++)
+	{
+		FaceType *f=&parametrized.face[i];
+		if (!((f->V(0)->IsB())&&(f->V(1)->IsB())&&(f->V(2)->IsB())))
+		{
+
+			vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
+			vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
+			vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
+			vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
+			ScalarType area=(tex1-tex0)^(tex2-tex0);
+			if (area<=0)
+				return false;
+		}
+	}
+	return true;
+}
+
+template <class MeshType>
+bool NonFolded(MeshType &parametrized,std::vector<typename MeshType::FaceType*> &folded)
+{
+	
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename MeshType::CoordType CoordType;
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::VertexType VertexType;
+
+	const ScalarType epsilon=(ScalarType)0.00001;
+	folded.resize(0);
+	///assert parametrization
+	for (unsigned int i=0;i<parametrized.face.size();i++)
+	{
+		FaceType *f=&parametrized.face[i];
+		if (!((f->V(0)->IsB())&&(f->V(1)->IsB())&&(f->V(2)->IsB())))
+		{
+
+			vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
+			vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
+			vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
+			vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
+			ScalarType area=(tex1-tex0)^(tex2-tex0);
+			if (area<=epsilon)
+				folded.push_back(f);
+		}
+	}
+	return (folded.size()==0);
+}
+//getFoldedFaces(std::vector)
+///parametrize a submesh from trinagles that are incident on vertices with equi-area subdivision
+template <class MeshType>
+void ParametrizeStarEquilateral(MeshType &parametrized,
+								const typename MeshType::ScalarType &radius=1)
+{
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename MeshType::CoordType CoordType;
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::VertexType VertexType;
+	
+	UpdateTopologies(&parametrized);
+
+	//set borders
+
+	///find first border & non border vertex
+	std::vector<VertexType*> non_border;
+	VertexType* Start=NULL;
+	for (unsigned int i=0;i<parametrized.vert.size();i++)
+	{
+		VertexType* vert=&parametrized.vert[i];
+		if ((Start==NULL)&&(vert->IsB()))
+			Start=vert;
+
+		if (!vert->IsB())
+			non_border.push_back(vert);
+	}
+	assert(non_border.size()!=0);
+	
+	///get sorted border vertices
+  std::vector<VertexType*> vertices;
+	FindSortedBorderVertices<MeshType>(parametrized,Start,vertices);
+	
+	///set border vertices
+	int num=vertices.size();
+        typename std::vector<VertexType*>::iterator iteV;
+	ScalarType curr_angle=0;
+	vertices[0]->T().U()=cos(curr_angle)*radius;
+	vertices[0]->T().V()=sin(curr_angle)*radius;
+	ScalarType division=(2*M_PI)/(ScalarType)num;
+	///set border
+	for (unsigned int i=1;i<vertices.size();i++)
+	{
+		curr_angle+=division;
+		vertices[i]->T().U()=radius*cos(curr_angle);
+		vertices[i]->T().V()=radius*sin(curr_angle);
+	}
+
+	if (non_border.size()==1)
+	{
+		///if non-border vertex is one then set it to zero otherwise 
+		///set it to the average of neighbors
+		non_border[0]->T().P()=vcg::Point2<ScalarType>(0,0);
+	}
+	else
+	{
+		///set media of star vertices
+		assert(non_border.size()==2);
+		for (unsigned int i=0;i<non_border.size();i++)
+		{
+			VertexType *v=non_border[i];
+			v->T().P()=vcg::Point2<ScalarType>(0,0);
+			int ariety_vert=0;
+			std::vector<VertexType*> star;
+			getVertexStar<MeshType>(v,star);
+			for (unsigned int k=0;k<star.size();k++)
+			{
+				if ((!star[k]->IsD())&&(star[k]->IsB()))
+				{
+					v->T().P()+=star[k]->T().P();
+					ariety_vert++;
+				}
+			}
+			v->T().P()/=(ScalarType)ariety_vert;
+		}
+		///test particular cases
+		if (!NonFolded(parametrized))
+		{
+			std::vector<VertexType*> shared;
+			getSharedVertexStar<MeshType>(non_border[0],non_border[1],shared);
+		
+			assert(shared.size()==2);
+			assert(shared[0]->IsB());
+			assert(shared[1]->IsB());
+			assert(shared[0]!=shared[1]);
+		
+			//ScalarType epsilon=(ScalarType)0.001;
+			///then get the media of two shared vertices
+			vcg::Point2<ScalarType> uvAve=shared[0]->T().P()+shared[1]->T().P();
+			assert(uvAve.Norm()>(ScalarType)0.001);
+			uvAve.Normalize();
+			vcg::Point2<ScalarType> p0=uvAve*(ScalarType)0.3;
+			vcg::Point2<ScalarType> p1=uvAve*(ScalarType)(-0.3);
+			///then test and set right assignement
+			non_border[0]->T().P()=p0;
+			non_border[1]->T().P()=p1;
+			if (!NonFolded(parametrized)){
+				non_border[0]->T().P()=p1;
+				non_border[1]->T().P()=p0;
+			}
+		}
+	}
+
+	///final assert parametrization
+	assert(NonFolded(parametrized));
+
+}
+
+///given the mesh and the two edges (same) seen from face[0] and face[1] of the mesh construct
+///a diamond parametrization using equilateral triangles of edge edge_len
+template <class MeshType>
+void ParametrizeDiamondEquilateral(MeshType &parametrized,
+								   const int &edge0,const int &edge1,
+								   const typename MeshType::ScalarType &edge_len=1)
+{
+
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename FaceType::CoordType CoordType;
+	typedef typename FaceType::ScalarType ScalarType;
+	typedef typename FaceType::VertexType VertexType;
+	
+	ScalarType h=(sqrt(3.0)/2.0)*edge_len;
+
+	FaceType *fd0=&parametrized.face[0];
+#ifndef NDEBUG
+	FaceType *fd1=&parametrized.face[1];
+#endif
+	assert(fd0->FFp(edge0)==fd1);
+	assert(fd1->FFp(edge1)==fd0);
+
+	///get 2 vertex on the edge
+	VertexType *v0=fd0->V(edge0);
+	VertexType *v1=fd0->V((edge0+1)%3);
+
+#ifndef NDEBUG
+	VertexType *vtest0=fd1->V(edge1);
+	VertexType *vtest1=fd1->V((edge1+1)%3);
+
+	assert(v0!=v1);
+	assert(vtest0!=vtest1);
+	assert(((v0==vtest0)&&(v1==vtest1))||((v1==vtest0)&&(v0==vtest1)));
+#endif
+
+	///other 2 vertex
+	VertexType *v2=parametrized.face[0].V((edge0+2)%3);
+	VertexType *v3=parametrized.face[1].V((edge1+2)%3);
+	assert((v2!=v3)&&(v0!=v2)&&(v0!=v3)&&(v1!=v2)&&(v1!=v3));
+
+	///assing texcoords
+	v0->T().P()=vcg::Point2<ScalarType>(0,-edge_len/2.0);
+	v1->T().P()=vcg::Point2<ScalarType>(0,edge_len/2.0);
+	v2->T().P()=vcg::Point2<ScalarType>(-h,0);
+	v3->T().P()=vcg::Point2<ScalarType>(h,0);
+
+	///test
+	assert(NonFolded(parametrized));
+}
+
+///given the mesh and the two edges (same) seen from face[0] and face[1] of the mesh construct
+///a diamond parametrization using equilateral triangles of edge edge_len
+template <class MeshType>
+void ParametrizeFaceEquilateral(MeshType &parametrized,
+								   const typename MeshType::ScalarType &edge_len=1)
+{
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename FaceType::CoordType CoordType;
+	typedef typename FaceType::ScalarType ScalarType;
+	typedef typename FaceType::VertexType VertexType;
+	
+	ScalarType h=(sqrt(3.0)/2.0)*edge_len;
+
+	FaceType *f_param=&(parametrized.face[0]);
+				
+	f_param->V(0)->T().P()=vcg::Point2<ScalarType>(edge_len/2.0,0);
+	f_param->V(1)->T().P()=vcg::Point2<ScalarType>(0,h);
+	f_param->V(2)->T().P()=vcg::Point2<ScalarType>(-edge_len/2.0,0);
+}
+
+
+///parametrize and create a submesh from trinagles that are incident on
+/// vertices .... seturn a vetor of original faces
+template <class MeshType>
+void ParametrizeLocally(MeshType &parametrized,
+						const std::vector<typename MeshType::VertexType*> &subset,
+						std::vector<typename MeshType::FaceType*> &orderedFaces,
+						std::vector<typename MeshType::VertexType*> &orderedVertex)
+{
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename FaceType::CoordType CoordType;
+	typedef typename FaceType::ScalarType ScalarType;
+	typedef typename FaceType::VertexType VertexType;
+
+	orderedFaces.clear();
+        std::vector<VertexType*> vertices;
+	
+	
+	///get faces referenced by vertices
+	getSharedFace<MeshType>(subset,orderedFaces);
+	
+	///do a first copy of the mesh
+	///and parametrize it
+	///NB: order of faces is mantained
+	CopyMeshFromFaces<MeshType>(orderedFaces,orderedVertex,parametrized);
+	
+	//CreateMeshVertexStar(subset,orderedFaces,parametrized);
+	ParametrizeLocally(parametrized);	
+	
+}
+
+
+
+template <class MeshType>
+void GetUV(const typename MeshType::FaceType* f,
+		   const typename MeshType::CoordType &bary,
+		   typename MeshType::ScalarType &U,
+		   typename MeshType::ScalarType &V)
+{
+	U=bary.X()*f->V(0)->T().U()+bary.Y()*f->V(1)->T().U()+bary.Z()*f->V(2)->T().U();
+	V=bary.X()*f->V(0)->T().V()+bary.Y()*f->V(1)->T().V()+bary.Z()*f->V(2)->T().V();
+	/*if ((!((U>=-1)&&(U<=1)))||(!((V>=-1)&&(V<=1))))
+	{
+		printf("Bary:%f,%f,%f \n",bary.X(),bary.Y(),bary.Z());
+		printf("texCoord:%f,%f \n",U,V);
+		assert(0);
+	}*/
+	//assert ((U>=-1)&&(U<=1));
+	//assert ((V>=-1)&&(V<=1));
+}
+
+template <class MeshType>
+bool GetBaryFaceFromUV(const MeshType &m,
+				       const typename MeshType::ScalarType &U,
+					   const typename MeshType::ScalarType &V,
+				       typename MeshType::CoordType &bary,
+				       int &index)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	const ScalarType _EPSILON = ScalarType(0.0000001);
+	/*assert ((U>=-1)&&(U<=1));
+	assert ((V>=-1)&&(V<=1));*/
+	for (unsigned int i=0;i<m.face.size();i++)
+	{
+                const typename  MeshType::FaceType *f=&m.face[i];
+		vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
+		vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
+		vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
+
+		vcg::Point2<ScalarType> test=vcg::Point2<ScalarType>(U,V);
+		vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
+		ScalarType area=(tex1-tex0)^(tex2-tex0);
+		//assert(area>-_EPSILON);
+		///then find if the point 2d falls inside
+		if ((area>_EPSILON)&&(t2d.InterpolationParameters(test,bary.X(),bary.Y(),bary.Z())))
+		{
+			index=i;
+			///approximation errors
+			ScalarType sum=0;
+			for (int x=0;x<3;x++)
+			{
+				if (((bary[x])<=0)&&(bary[x]>=-_EPSILON))
+					bary[x]=0;
+				else
+				if (((bary[x])>=1)&&(bary[x]<=1+_EPSILON))
+					bary[x]=1;
+				sum+=bary[x];
+			}
+			if (sum==0)
+				printf("error SUM %f \n",sum);
+
+			bary/=sum;
+			return true;
+		}
+	}
+
+	return (false);
+}
+
+template <class FaceType>
+bool GetBaryFaceFromUV(std::vector<FaceType*> faces,
+				       const typename FaceType::ScalarType &U,
+					   const typename FaceType::ScalarType &V,
+				       typename FaceType::CoordType &bary,
+				       int &index)
+{
+	typedef typename FaceType::CoordType CoordType;
+	typedef typename FaceType::ScalarType ScalarType;
+	typedef typename FaceType::VertexType VertexType;
+	typedef typename FaceType::ScalarType ScalarType;
+	const ScalarType _EPSILON = ScalarType(0.0000001);
+	/*assert ((U>=-1)&&(U<=1));
+	assert ((V>=-1)&&(V<=1));*/
+	for (unsigned int i=0;i<faces.size();i++)
+	{
+		FaceType *f=faces[i];
+		vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
+		vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
+		vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
+
+		vcg::Point2<ScalarType> test=vcg::Point2<ScalarType>(U,V);
+		vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
+		ScalarType area=fabs((tex1-tex0)^(tex2-tex0));
+		//assert(area>-_EPSILON);
+		///then find if the point 2d falls inside
+		if ((area>_EPSILON)&&(t2d.InterpolationParameters(test,bary.X(),bary.Y(),bary.Z())))
+		{
+			index=i;
+			
+			///approximation errors
+			ScalarType sum=0;
+			for (int x=0;x<3;x++)
+			{
+				if (((bary[x])<=0)&&(bary[x]>=-_EPSILON))
+					bary[x]=0;
+				else
+				if (((bary[x])>=1)&&(bary[x]<=1+_EPSILON))
+					bary[x]=1;
+				sum+=fabs(bary[x]);
+			}
+			if (sum==0)
+				printf("error SUM %f \n",sum);
+			
+			bary/=sum;
+			/*if (!((bary.X()>=0)&& (bary.X()<=1)))
+				printf("error %f \n",bary.X());*/
+			/*ScalarType diff=(1.0-bary.X()-bary.Y()-bary.Z());
+			bary.X()+=diff;*/
+			return true;
+		}
+	}
+
+	return (false);
+}
+
+template <class MeshType>
+bool GetBaryFaceFromUV(const MeshType &m,
+				       const typename MeshType::ScalarType &U,
+					   const typename MeshType::ScalarType &V,
+				       const std::vector<typename MeshType::FaceType*> &orderedFaces,
+				       typename MeshType::CoordType &bary,
+				       typename MeshType::FaceType* &chosen)
+{
+	int index;
+	bool found=GetBaryFaceFromUV(m,U,V,bary,index);
+	if(!found) {
+			chosen=0;
+			return false;
+		}
+	chosen=orderedFaces[index];
+	return true;
+}
+
+template <class MeshType>
+bool GetCoordFromUV(const MeshType &m,
+				    const typename MeshType::ScalarType &U,
+					const typename MeshType::ScalarType &V,
+				    typename MeshType::CoordType &val,
+					bool rpos=false)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	const ScalarType _EPSILON = (ScalarType)0.00001;
+	for (unsigned int i=0;i<m.face.size();i++)
+	{
+                const typename MeshType::FaceType *f=&m.face[i];
+		vcg::Point2<ScalarType> tex0=vcg::Point2<ScalarType>(f->V(0)->T().U(),f->V(0)->T().V());
+		vcg::Point2<ScalarType> tex1=vcg::Point2<ScalarType>(f->V(1)->T().U(),f->V(1)->T().V());
+		vcg::Point2<ScalarType> tex2=vcg::Point2<ScalarType>(f->V(2)->T().U(),f->V(2)->T().V());
+
+		vcg::Point2<ScalarType> test=vcg::Point2<ScalarType>(U,V);
+		vcg::Triangle2<ScalarType> t2d=vcg::Triangle2<ScalarType>(tex0,tex1,tex2);
+		ScalarType area=(tex1-tex0)^(tex2-tex0);
+		///then find if the point 2d falls inside
+                typename MeshType::CoordType bary;
+		if ((area>_EPSILON)&&(t2d.InterpolationParameters(test,bary.X(),bary.Y(),bary.Z())))
+		{
+			///approximation errors
+			for (int x=0;x<3;x++)
+			{
+				if (((bary[x])<=0)&&(bary[x]>=-_EPSILON))
+					bary[x]=0;
+				else
+				if (((bary[x])>=1)&&(bary[x]<=1+_EPSILON))
+					bary[x]=1;
+			}	
+			ScalarType diff=(1.0-bary.X()-bary.Y()-bary.Z());
+			bary.X()+=diff;
+			if (!rpos)
+				val=f->P(0)*bary.X()+f->P(1)*bary.Y()+f->P(0)*bary.Z();
+			else
+				val=f->V(0)->RPos*bary.X()+f->V(1)->RPos*bary.Y()+f->V(2)->RPos*bary.Z();
+			
+			return true;
+		}
+	}
+	return false;
+}
+
+template <class MeshType>
+typename MeshType::ScalarType GetSmallestUVEdgeSize(const MeshType &m)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+
+	ScalarType smallest=100.f;
+	assert(m.fn>0);
+	for (int i=0;i<m.face.size();i++)
+	{
+
+		///approximation errors
+			for (int j=0;j<3;j++)
+			{
+
+				vcg::Point2<ScalarType> uv0=m.face[i].V(j)->T().P();
+				vcg::Point2<ScalarType> uv1=m.face[i].V((j+1)%3)->T().P();
+				ScalarType test=(uv0-uv1).Norm();
+				if (test<smallest)
+					smallest=test;
+			}
+	}
+	return smallest;
+}
+
+template <class MeshType>
+typename MeshType::ScalarType GetSmallestUVHeight(const MeshType &m)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	ScalarType smallest=(ScalarType)100.0;
+	ScalarType eps=(ScalarType)0.0001;
+	assert(m.fn>0);
+	for (unsigned int i=0;i<m.face.size();i++)
+	{
+                const typename MeshType::FaceType *f=&m.face[i];
+		///approximation errors
+		for (int j=0;j<3;j++)
+		{
+			vcg::Point2<ScalarType> uv0=f->V(j)->cT().P();
+			vcg::Point2<ScalarType> uv1=f->V1(j)->cT().P();
+			vcg::Point2<ScalarType> uv2=f->V2(j)->cT().P();
+			ScalarType area=fabs((uv1-uv0)^(uv2-uv0));
+			ScalarType base=(uv1-uv2).Norm();
+			ScalarType h_test=area/base;
+			if (h_test<smallest)
+					smallest=h_test;
+			}
+	}
+	if (smallest<eps)
+		smallest=(ScalarType)eps;
+	if (smallest>(ScalarType)0.05)
+		smallest=(ScalarType)0.05;
+	return smallest;
+}
+
+template <class MeshType>
+void ParametrizeStarEquilateral(typename MeshType::VertexType *center,
+								bool /*subvertices=true*/)
+{
+	///initialize domain
+	typedef typename MeshType::VertexType VertexType;
+	typedef typename MeshType::FaceType FaceType;
+	typedef typename MeshType::CoordType CoordType;
+
+	MeshType parametrized;
+	std::vector<VertexType*> vertices,ordVert;
+	std::vector<VertexType*> HresVert;
+	std::vector<FaceType*> faces;
+	vertices.push_back(center);
+	getSharedFace<MeshType>(vertices,faces);
+	CopyMeshFromFaces<MeshType>(faces,ordVert,parametrized);
+
+	///parametrize and then copy back
+	ParametrizeStarEquilateral<MeshType>(parametrized);
+	for (unsigned int i=0;i<ordVert.size();i++)
+		ordVert[i]->T().P()=parametrized.vert[i].T().P();
+
+	///initialize sub-vertices
+	getHresVertex<FaceType>(faces,HresVert);
+	for (unsigned int i=0;i<HresVert.size();i++)
+	{
+		FaceType *father=HresVert[i]->father;
+		CoordType Bary=HresVert[i]->Bary;
+		GetUV<MeshType>(father,Bary,HresVert[i]->T().U(),HresVert[i]->T().V());
+	}
+}
+
+#endif
diff --git a/src/meshlabplugins/filter_isoparametrization/mesh_operators.h b/src/meshlabplugins/filter_isoparametrization/mesh_operators.h
index fc458e270..f60dad6a6 100644
--- a/src/meshlabplugins/filter_isoparametrization/mesh_operators.h
+++ b/src/meshlabplugins/filter_isoparametrization/mesh_operators.h
@@ -1,11 +1,11 @@
 #ifndef MESH_OPERATORS
 #define MESH_OPERATORS
 #include <vcg/simplex/face/pos.h>
-#include <vcg/complex/trimesh/update/normal.h>
-#include <vcg/complex/trimesh/update/topology.h>
-#include <vcg/complex/trimesh/update/flag.h>
-#include <vcg/complex/trimesh/update/bounding.h>
-#include <vcg/complex/trimesh/update/edges.h>
+#include <vcg/complex/algorithms/update/normal.h>
+#include <vcg/complex/algorithms/update/topology.h>
+#include <vcg/complex/algorithms/update/flag.h>
+#include <vcg/complex/algorithms/update/bounding.h>
+#include <vcg/complex/algorithms/update/edges.h>
 #include <vector>
 #include <map>
 
diff --git a/src/meshlabplugins/filter_isoparametrization/param_collapse.h b/src/meshlabplugins/filter_isoparametrization/param_collapse.h
index 7564f2ea9..53e45c9ff 100644
--- a/src/meshlabplugins/filter_isoparametrization/param_collapse.h
+++ b/src/meshlabplugins/filter_isoparametrization/param_collapse.h
@@ -1,702 +1,702 @@
-#ifndef PARAM_COLLAPSE
-#define PARAM_COLLAPSE
-
-#include <set>
-
-// local optimization
-#include <vcg/complex/local_optimization.h>
-#include <vcg/complex/local_optimization/tri_edge_collapse_quadric.h>
-#include <vcg/complex/local_optimization/tri_edge_flip.h>
-#include <vcg/complex/trimesh/append.h>
-#include <vcg/complex/trimesh/edge_collapse.h>
-#include <vcg/space/color4.h>
-#include <vcg/math/quadric.h>
-
-#include <local_parametrization.h>
-#include <mesh_operators.h>
-#include <lm.h>
-#include <uv_grid.h>
-
-#include "opt_patch.h"
-#include "local_optimization.h"
-
-template <class BaseMesh>
-class ParamEdgeCollapse: public vcg::tri::TriEdgeCollapse<BaseMesh,ParamEdgeCollapse<BaseMesh> > {
-public:
-        typedef vcg::tri::TriEdgeCollapse<BaseMesh,ParamEdgeCollapse<BaseMesh> > Super;
-	typedef typename BaseMesh::VertexType::EdgeType EdgeType;
-        typedef typename BaseMesh::VertexType VertexType;
-	typedef typename BaseMesh::VertexType BaseVertex;
-	typedef typename BaseMesh::FaceType   BaseFace;
-        typedef typename BaseMesh::FaceType FaceType;
-        typedef typename BaseMesh::ScalarType   ScalarType;
-        typedef typename BaseMesh::CoordType   CoordType;
-        typedef BaseMesh TriMeshType;
-
-	static EnergyType &EType(){static EnergyType E;return E;};
-	
-	inline ParamEdgeCollapse(const EdgeType &p, int mark)
-	{    
-        Super::localMark = mark;
-        Super::pos=p;
-        Super::_priority = ComputePriority();
-	}
-
-	inline ScalarType Cost()
-  {
-	std::vector<typename BaseMesh::FaceType*> on_edge,faces1,faces2;
-        getSharedFace<BaseMesh>(Super::pos.V(0),Super::pos.V(1),on_edge,faces1,faces2);
-
-	FaceType* edgeF[2];
-	edgeF[0]=on_edge[0];
-	edgeF[1]=on_edge[1];
-    ScalarType costArea=EstimateAreaByParam<BaseMesh>(Super::pos.V(0),Super::pos.V(1),edgeF);
-    ScalarType lenght=EstimateLenghtByParam<BaseMesh>(Super::pos.V(0),Super::pos.V(1),edgeF);
-
-	if (costArea<0)
-		assert(0);
-	assert(lenght>=0);
-	return (pow(lenght,2)+costArea);
-  }
-
-	inline bool IsFeasible(){
-    return LinkConditions(Super::pos);
-	}
-
-  inline void SetHlevMeshUV(const std::vector<BaseFace*> &LowFace,
-                                                    std::vector<BaseFace*> &HiFace,
-                                                        std::vector<BaseVertex*> &HiVertex)
-  {
-
-	///interpolate parametric u & v values into the face
-	for (unsigned int index=0;index<LowFace.size();index++)
-	{
-		FaceType *test_face=LowFace[index];
-		assert(!test_face->IsD());
-		for (unsigned int i=0;i<test_face->vertices_bary.size();i++)
-		{
-			VertexType *brother=test_face->vertices_bary[i].first;
-			CoordType bary=test_face->vertices_bary[i].second;
-                        GetUV<BaseMesh>(test_face,bary,brother->T().U(),brother->T().V());
-			//printf("%f , %f \n",brother->T().U(),brother->T().V());
-			assert(brother!=NULL);
-			HiVertex.push_back(brother);
-		}
-	}
-
-	///add brother of the domain mesh
-        std::vector<BaseVertex*> LowVertices;
-	getSharedVertex<BaseMesh>(LowFace,LowVertices);
-	for (unsigned int index=0;index<LowVertices.size();index++)
-	{
-		assert(!LowVertices[index]->IsD());
-		if (LowVertices[index]->brother!=NULL)
-		{
-			VertexType* b=LowVertices[index]->brother;
-			assert(b!=NULL);
-			HiVertex.push_back(b);
-			b->T().P()=LowVertices[index]->T().P();
-		}
-	}
-
-	///then return pointer to hight level faces
-	getSharedFace<BaseMesh>(HiVertex,HiFace);
-  }
-
-  static void  SetBaryFromUV(BaseMesh &domain,
-														 std::vector<BaseVertex*> &vertices)
-  {
-    ///set a vector of pointer to face
-        std::vector<BaseFace*> OrdFace;
-	for (unsigned int h=0;h<domain.face.size();h++)
-		OrdFace.push_back(&domain.face[h]);
-
-	///update parametric positions of vertices
-	for (unsigned int i=0;i<vertices.size();i++)
-		{
-			CoordType bary1;
-			FaceType *chosen;
-			ScalarType u=vertices[i]->T().U();
-			ScalarType v=vertices[i]->T().V();
-      GetBaryFaceFromUV<BaseMesh>(domain,u,v,OrdFace,bary1,chosen);
-			assert(fabs(bary1.X()+bary1.Y()+bary1.Z()-1.0)<=0.0001);
-			/*vertices[i]->father=chosen;
-			assert(!chosen->IsD());
-			vertices[i]->Bary=bary1;*/
-			AssingFather(vertices[i],chosen,bary1,domain);
-		}
-  }
-
- 
-  struct minInfo0
-  {
-  public:
-	BaseMesh *domain;
-	BaseMesh *collapsed;
-	BaseVertex *central;
-	CoordType middle;
-	std::vector<BaseFace*> HiFace;
-	std::vector<BaseVertex*> HiVertex;
-	ScalarType original_area;
-  };
-  
- 
-  static void energy0(double *p, double *x, int/* m*/, int /*n*/, void *data)
-  { 
-	minInfo0 &inf = *(minInfo0 *)data; 
-
-	///assing coordinate to the face
-	inf.central->P().X()=p[0];
-	inf.central->P().Y()=p[1];
-	inf.central->P().Z()=p[2];
-
-	///find aspect ratio
-	x[0]=(1.0/AspectRatio<BaseMesh>(*inf.collapsed));
-
-	ScalarType areadelta=0;
-	for (unsigned int i=0;i<inf.domain->face.size();i++)
-		areadelta+=inf.domain->face[i].areadelta;
-
-	ScalarType area0=Area(*inf.collapsed);
-	ScalarType area1=Area(*inf.domain)+areadelta;
-	
-	x[1]=pow(area0/area1+area1/area0,2);//2.0*pow((area0-area1)/area1,2);
-
-	x[2]=AreaDispersion<BaseMesh>(*inf.collapsed);
-	x[3]=0;//(inf.middle-inf.central->P()).SquaredNorm()/area1;
-  }
-
-   ///find best position
-  inline CoordType FindBestPos(BaseMesh &m)
-  {
-    minInfo0 Minf;
-    ///create the submesh
-    VertexType *v0=Super::pos.V(0);
-        VertexType *v1=Super::pos.V(1);
-	
-
-	std::vector<typename BaseMesh::VertexType*> star;
-	std::vector<typename BaseMesh::FaceType*> orderedFaces;
-	star.push_back(v0);
-	star.push_back(v1);
-	BaseMesh created,domain;
-
-	///DISTORSION
-	BaseMesh HLcreated;
-	///DISTORSION
-
-	CreateMeshVertexStar<BaseMesh>(star,orderedFaces,created);
-	/*if (created.face[1].areadelta>1)
-		assert(0);*/
-	UpdateTopologies<BaseMesh>(&created);
-	
-	//ParametrizeLocally(created);
-
-	/////copy uv values on ordered faces
-	//for (int i=0;i<created.face.size();i++)
-	//	for (int j=0;j<3;j++)
-	//		orderedFaces[i]->V(j)->T().P()=created.face[i].V(j)->T().P();
-
-	/////set parametric position respect to new part of submesh
-	///*std::vector<FaceType*> HiFace;
-	//std::vector<VertexType*> HiVertex;*/
-	//SetHlevMeshUV(orderedFaces,Minf.HiFace,Minf.HiVertex);
-
-	///save previous values
-	std::vector<std::pair<FaceType*,CoordType> > swap;
-        typename std::vector<VertexType*>::iterator iteVP;
-	for (iteVP=Minf.HiVertex.begin();iteVP!=Minf.HiVertex.end();iteVP++)
-		swap.push_back(std::pair<FaceType*,CoordType> ((*iteVP)->father,(*iteVP)->Bary));
-	///DISTORSION
-	
-	///create pos
-	EdgeType posEdge;
-	std::vector<typename FaceType::VertexType*> vertEdge;
-	FindNotBorderVertices<BaseMesh>(created,vertEdge);
-
-	posEdge.V(0)=std::max<typename FaceType::VertexType*>(vertEdge[1],vertEdge[0]);
-	posEdge.V(1)=std::min<typename FaceType::VertexType*>(vertEdge[1],vertEdge[0]);
-
-	///simulate collapse
-	CoordType newPos=(v0->P()+v1->P())/2.0;
-
-	///copy domain
-	vcg::tri::Append<BaseMesh,BaseMesh>::Mesh(domain,created);
-	for (unsigned int i=0;i<created.face.size();i++)
-		domain.face[i].areadelta=created.face[i].areadelta;
-
-	DoCollapse(created,posEdge, newPos); // v0 is deleted and v1 take the new position
-	
-	UpdateTopologies<BaseMesh>(&created);
-
-	/////parametrize domain
-	//ParametrizeLocally(created);
-	//ParametrizeLocally(domain);
-	
-	///minimization
-	double p[3];
-	p[0]=newPos.X();
-	p[1]=newPos.Y();
-	p[2]=newPos.Z();
-
-	/*minInfo Minf;*/
-	Minf.domain=&domain;
-	Minf.collapsed=&created;
-	Minf.central=posEdge.V(1);
-	Minf.middle=newPos;
-
-	double x[4];
-	x[0]=0;
-	x[1]=0;
-	x[2]=0;
-	x[3]=0;
-	/*x[4]=0;*/
-
-	double opts[LM_OPTS_SZ], info[LM_INFO_SZ];
-	opts[0]=LM_INIT_MU; opts[1]=1E-15; opts[2]=1E-15; opts[3]=1E-20;
-	opts[4]=LM_DIFF_DELTA;
-
-	//energy0(p,x,3,4,Minf);
-	
-	/*int num=*/dlevmar_dif(energy0,p,x,3,4,1000,opts,info,NULL,NULL,&Minf);
-
-	///find back the value
-	
-	CoordType bestPos;
-	bestPos.X()=p[0];
-	bestPos.Y()=p[1];
-	bestPos.Z()=p[2];
-
-
-	for (unsigned int i=0;i<Minf.HiVertex.size();i++)
-	{/*
-		Minf.HiVertex[i]->father=swap[i].first;
-		assert(!swap[i].first->IsD());
-		Minf.HiVertex[i]->Bary=swap[i].second;*/
-		AssingFather(*Minf.HiVertex[i],swap[i].first,swap[i].second,m);
-	}
-
-	return (bestPos);
-  }
-
-  inline ScalarType ComputePriority()
-  { 
-	return (Cost());
-	//return( Distance(pos.V(0)->cP(),pos.V(1)->cP()));
-  }
-
-  CoordType ComputeMinimal(BaseMesh &m)
-  {
-	CoordType bestPos=FindBestPos(m);
-	return bestPos;
-  }
-
-  void UpdateFF(EdgeType &posEdge)
-	{
-		std::vector<typename TriMeshType::FaceType*> shared;
-		std::vector<typename TriMeshType::FaceType*> in_v0;
-		std::vector<typename TriMeshType::FaceType*> in_v1;
-		///then reupdate topology
-		getSharedFace<TriMeshType>(posEdge.V(0),posEdge.V(1),shared,in_v0,in_v1);
-
-		///find the edge shared between them
-		for (unsigned int j=0;j<shared.size();j++)
-		{
-			int iedge=-1;
-			FaceType* face=shared[j];
-			if (((face->V(0)==posEdge.V(0))&&(face->V(1)==posEdge.V(1)))||
-				 (face->V(0)==posEdge.V(1))&&(face->V(1)==posEdge.V(0)))
-				 iedge=0;
-			else
-			if (((face->V(1)==posEdge.V(0))&&(face->V(2)==posEdge.V(1)))||
-				 (face->V(1)==posEdge.V(1))&&(face->V(2)==posEdge.V(0)))
-				 iedge=1;
-			else
-			if (((face->V(2)==posEdge.V(0))&&(face->V(0)==posEdge.V(1)))||
-				 (face->V(2)==posEdge.V(1))&&(face->V(0)==posEdge.V(0)))
-				 iedge=2;
-			assert (iedge!=-1);
-
-			///then update topology for the two other faces 
-			int edge0=(iedge+1)%3;
-			int edge1=(iedge+2)%3;
-
-			///get opposEdgeite faces and indexes
-			FaceType* f0=face->FFp(edge0);
-			FaceType* f1=face->FFp(edge1);
-			
-			int indexopp0=face->FFi(edge0);
-			int indexopp1=face->FFi(edge1);
-			///control if they are border 
-			if ((f0==face)&&(f1==face))
-			{
-				printf("border");
-			}
-			else
-			if (f0==face)
-			{
-				f1->FFp(indexopp1)=f1;
-				f1->FFi(indexopp1)=-1;
-				printf("border");
-			}
-			else
-			if (f1==face)
-			{
-				f0->FFp(indexopp0)=f0;
-				f0->FFi(indexopp0)=-1;
-				printf("border");
-			}
-			else///otherwise attache two other faces
-			{
-				///the reassing adiacency
-				f0->FFp(indexopp0)=f1;
-				f1->FFp(indexopp1)=f0;
-				f0->FFi(indexopp0)=indexopp1;
-				f1->FFi(indexopp1)=indexopp0;
-				assert( f0->FFp(indexopp0)->FFp(f0->FFi(indexopp0))==f0 );
-				assert( f1->FFp(indexopp1)->FFp(f1->FFi(indexopp1))==f1 );
-			}
-			
-		}	
-	}
-
-
-///create a copy the submesh for a collapse and parameterize it
-void CreatePreCollapseSubmesh(EdgeType &pos,
-							  BaseMesh &param,
-							  std::vector<VertexType*> &orderedVertex,
-							  std::vector<FaceType*> &orderedFaces)
-{
-	std::vector<VertexType*> vert_star;
-	vert_star.push_back(pos.V(0));
-	vert_star.push_back(pos.V(1));
-
-	///get a copy of the mesh
-	CreateMeshVertexStar(vert_star,orderedFaces,orderedVertex,param);
-	UpdateTopologies(&param);
-	InitDampRestUV(param);
-
-	ParametrizeLocally<BaseMesh>(param);
-
-	///store UV coordinates in original vertex to copy 
-	///for post collapsed surface parametrization
-	for (unsigned int i=0;i<orderedVertex.size();i++)
-		orderedVertex[i]->T().P()=param.vert[i].T().P();
-}
-
-///create a copy the submesh after the collapse that is already parameterized
-/// only the central vertex has to be set to (0,0)
-void CreatePostCollapseSubmesh(EdgeType &pos,
-							   BaseMesh &param_post,
-							  std::vector<VertexType*> &orderedVertex,
-							  std::vector<FaceType*> &orderedFaces)
-{
-	std::vector<VertexType*> vert_star;
-	vert_star.push_back(pos.V(1));
-
-	CreateMeshVertexStar(vert_star,orderedFaces,orderedVertex,param_post);
-	UpdateTopologies(&param_post);
-	InitDampRestUV(param_post);
-
-	///set to zero the star center (non border)
-	bool found=false;
-	unsigned int i=0;
-	while ((i<param_post.vert.size())&&(!found))
-	{
-		if (!param_post.vert[i].IsB())
-			found=true;
-		else
-			i++;
-	}
-	assert(found);
-	param_post.vert[i].T().P()=vcg::Point2<ScalarType>(0,0);
-		
-}
-
-void AphaBetaToUV(EdgeType &pos,
-				  std::vector<FaceType*> &orderedFaces,
-				  BaseMesh &param,
-			      std::vector<VertexType*> &HresVert)
-{
-	/*const ScalarType eps=(ScalarType)0.00001;*/
-	///VERTEX ON FACE REPROJECTING
-	//transform from Alpha Beta to UV
-	for (unsigned int index=0;index<orderedFaces.size();index++)
-	{
-		FaceType *test_face=orderedFaces[index];
-		FaceType *parametric_face=&param.face[index];
-
-		///fro each vertex belonging to such face
-		for (unsigned int i=0;i<test_face->vertices_bary.size();i++)
-		{
-			///get brother vertex
-			VertexType *brother=test_face->vertices_bary[i].first;
-			assert(brother!=NULL);
-
-			///get his barycentric coordinates
-			CoordType bary=test_face->vertices_bary[i].second;
-
-			///transform to UV
-			ScalarType u,v;
-			GetUV<BaseMesh>(parametric_face,bary,u,v);
-			///and assing
-			brother->T().U()=u;
-			brother->T().V()=v;
-
-			/*///testing coordinates
-			if (!((u>-1.0-eps)&&(u<1.0+eps)&&
-			   (v>-1.0-eps)&&(v<1.0+eps)))
-			{
-				printf("Error 0 Uv :%f,%f \n",u,v);
-				printf("Bary :%f,%f %f \n",bary.X(),bary.Y(),bary.Z());
-				system("pause");
-			}*/
-
-			///save high res vertices
-			HresVert.push_back(brother);
-		}
-		/*///clear 
-		test_face->vertices_bary.clear();*/
-	}
-	
-	///add the two collapsed vertex
-	///and set UV coordinates
-	for (int i=0;i<2;i++)
-	{ 
-		if (pos.V(i)->brother!=NULL)
-		{
-			HresVert.push_back(pos.V(i)->brother);
-			///set his coordinates 
-			pos.V(i)->brother->T().P()=pos.V(i)->T().P();
-
-			//param_pos.push_back(vert_star0[i]->T().P());
-			///color for flip test
-
-			///set his brother as null
-			pos.V(i)->brother=NULL;
-		}
-	}
-
-}
-
-void UVToAlphaBeta(std::vector<VertexType*> &HresVert,
-									  BaseMesh &param,std::vector<FaceType*> &orderedFaces,
-										BaseMesh &base_mesh)
-{
-	///for each parametrized vertex
-	for (unsigned int i=0;i<HresVert.size();i++)
-	{
-		///get his brother
-		CoordType bary1;
-		FaceType *chosen;
-		VertexType *brother=HresVert[i];
-		assert(brother!=NULL);
-		///and its barycentric coords
-		ScalarType u=HresVert[i]->T().U();
-		ScalarType v=HresVert[i]->T().V();
-		int index;
-
-		////found the face and its barycentric coordinates form the parametrized mesh
-		bool found=GetBaryFaceFromUV(param,u,v,bary1,index);
-
-		///test for approximation errors
-		if (!found)
-		{
-			printf("Error 1\n");
-			printf("Old Uv :%f,%f \n",u,v);
-			while (!found)
-			{
-				///put next to the center
-				u*=(ScalarType)0.9;
-				v*=(ScalarType)0.9;
-				found=GetBaryFaceFromUV(param,u,v,bary1,index);//<BaseMesh>(param1,u,v,orderedFaces1,bary1,chosen);
-			}
-			printf("New Uv %f,%f \n",u,v);
-		}
-		
-		///get the face from original mesh
-		assert(found);
-		chosen=orderedFaces[index];
-		//if (!(fabs(bary1.X()+bary1.Y()+bary1.Z()-1.0)<=0.0001))
-		//{
-		//	printf("Error 2 Uv :%f,%f \n",u,v);
-		//	system("pause");
-		//	bary1=CoordType(0.3333,0.3333,0.3333);
-		//	chosen=orderedFaces[0];
-		//	//assert(0);
-		//}
-		///set father-son relation
-		chosen->vertices_bary.push_back(std::pair<BaseVertex*,vcg::Point3f>(brother,bary1));
-		
-		AssingFather(*brother,chosen,bary1,base_mesh);
-		/*brother->father=chosen;
-		assert(!chosen->IsD());
-		brother->Bary=bary1;*/
-
-		///set new parametrization value
-		GetUV<BaseMesh>(&param.face[index],bary1,u,v);
-		HresVert[i]->T().U()=u;
-		HresVert[i]->T().V()=v;
-	}
-}
-
-void ClearVert_Bary(std::vector<FaceType*> &orderedFaces)
-{
-	for (unsigned int index=0;index<orderedFaces.size();index++)
-	{
-		FaceType *test_face=orderedFaces[index];
-		test_face->vertices_bary.clear();
-	}
-}
-
-void AssignRPos(VertexType* &to_assign,
-				ScalarType &U,
-				ScalarType &V,
-				std::vector<FaceType*> &orderedFaces,
-				BaseMesh &param)
-{
-	CoordType val;
-
-	////set rest positions for survived vertex
-	///create h resolution mesh 
-	BaseMesh hlev_mesh;
-	std::vector<BaseVertex*> ord_vertex;
-	CopyHlevMesh(orderedFaces,hlev_mesh,ord_vertex);
-	///first interpolate in h_res then proceed to lowres if doesn't find
-	bool found;
-	found=GetCoordFromUV(hlev_mesh,U,V,val,true);   
-	if (!found)
-		found=GetCoordFromUV(param,U,V,val,true);   
-	
-	assert (found);
-	
-	to_assign->RPos=val;
-}
-
-void Execute(BaseMesh &m)
-	{	
-    typedef typename BaseMesh::FaceType FaceType;
-    typedef typename BaseMesh::VertexType VertexType;
-    typedef typename BaseMesh::ScalarType ScalarType;
-    typedef typename BaseMesh::CoordType CoordType;
-		
-		assert(this->pos.V(0)!=this->pos.V(1));
-		assert(!this->pos.V(0)->IsD());
-		assert(!this->pos.V(1)->IsD());
-    assert(size_t((this->pos.V(0)-&(*m.vert.begin())))<m.vert.size());
-    assert(size_t((this->pos.V(1)-&(*m.vert.begin())))<m.vert.size());
-				
-    std::vector<FaceType*> result;
-    std::vector<FaceType*> in_v0;
-    std::vector<FaceType*> in_v1;
-
-#ifndef NDEBUG
-		getSharedFace<BaseMesh>(this->pos.V(0),this->pos.V(1),result,in_v0,in_v1);
-		assert(result.size()==2);
-#endif
-
-		///compute new position
-		CoordType oldRPos=(this->pos.V(0)->RPos+this->pos.V(1)->RPos)/2.0;
-		CoordType newPos;
-		newPos=ComputeMinimal(m);//
-		//vcg::tri::UpdateTopology<BaseMesh>::TestVertexFace(m); ///TEST
-
-		BaseMesh param0,param1;
-		//std::vector<VertexType*> vert_star0,vert_star1;
-		std::vector<FaceType*> orderedFaces0,orderedFaces1;
-		std::vector<VertexType*> orderedVertex0,orderedVertex1;
-	
-		///create a parametrized submesh pre-collapse
-    CreatePreCollapseSubmesh(Super::pos,param0,orderedVertex0,orderedFaces0);
-
-//---------------------------///
-		///update FF topology post-collapse
-		UpdateFF(this->pos);
-		
-		///INITIAL AREA
-		ScalarType area0=Area<BaseFace>(orderedFaces0);
-
-		///do the collapse
-		DoCollapse(m, this->pos, newPos); // v0 is deleted and v1 take the new position
-		//vcg::tri::UpdateTopology<BaseMesh>::TestVertexFace(m); ///TEST
-		//---------------------------///
-		///create a parametrized submesh post-collapse #1
-    CreatePostCollapseSubmesh(this->pos,param1,orderedVertex1,orderedFaces1);
-
-		//---------------------------///
-		///FINAL AREA
-		ScalarType area1=Area<BaseFace>(orderedFaces1);
-		
-		////save error
-		ScalarType areadelta=(area0-area1)/(ScalarType)orderedFaces1.size();
-		for (unsigned int i=0;i<orderedFaces1.size();i++)
-			orderedFaces1[i]->areadelta=areadelta;
-		
-		///VERTEX ON FACE REPROJECTING #2
-		//---------------------------///
-		/////collect all vertices with respective param coords
-		std::vector<VertexType*> HresVert;
-	
-		//TRANSFORM TO UV
-    AphaBetaToUV(this->pos,orderedFaces0,param0,HresVert);
-		
-		//DELETE SONS
-		ClearVert_Bary(orderedFaces0);
-//---------------------------///
-		
-		///UPTIMIZE UV
-		//OptimizeUV(&param0,&param1,HresVert);
-		
-//---------------------------///
-		///REPROJECT BACK TO ORIGINAL FATHER #3
-		
-		UVToAlphaBeta(HresVert,param1,orderedFaces1,m);
-
-		
-        /*PatchesOptimizer<BaseMesh>::OptimizeUV(this->pos.V(1),m);*/
-	
-//---------------------------///
-		///get the non border one that is the one survived
-		unsigned int k=0;
-		while ((param1.vert[k].IsB())&&(k<param1.vert.size()))
-			k++;
-		assert(k<param1.vert.size());
-		CoordType val;
-
-//---------------------------///
-		///ASSIGN REST POSITION CENTRAL VERTEX
-		//AssignRPos(pos.V(1),param1.vert[k].T().U(),param1.vert[k].T().V(),orderedFaces1,param0);
-//---------------------------///
-	
-		///FINAL OPTIMIZATION
-		/*int t0=clock();*/
-		
-		this->pos.V(1)->RPos=oldRPos;
-		
-    /*bool b=*/SmartOptimizeStar<BaseMesh>(this->pos.V(1),m,Accuracy(),EType());
-		
-		/*int t1=clock();
-		time_opt+=(t1-t0);*/
-	}
-
-public:
-	static int &Accuracy()
-	{
-		static int _acc;
-		return _acc;
-	}
-	
-	static BaseMesh* &HresMesh()
-	{
-		static BaseMesh* mesh;
-		return mesh;
-	}
-
-	BaseVertex *getV(int num)
-	{
-		assert((num>=0)&&(num<2));
-		return this->pos.V(num);
-	}	
-};
-
-#endif
+#ifndef PARAM_COLLAPSE
+#define PARAM_COLLAPSE
+
+#include <set>
+
+// local optimization
+#include <vcg/complex/algorithms/local_optimization.h>
+#include <vcg/complex/algorithms/local_optimization/tri_edge_collapse_quadric.h>
+#include <vcg/complex/algorithms/local_optimization/tri_edge_flip.h>
+#include <vcg/complex/append.h>
+#include <vcg/complex/algorithms/edge_collapse.h>
+#include <vcg/space/color4.h>
+#include <vcg/math/quadric.h>
+
+#include <local_parametrization.h>
+#include <mesh_operators.h>
+#include <lm.h>
+#include <uv_grid.h>
+
+#include "opt_patch.h"
+#include "local_optimization.h"
+
+template <class BaseMesh>
+class ParamEdgeCollapse: public vcg::tri::TriEdgeCollapse<BaseMesh,ParamEdgeCollapse<BaseMesh> > {
+public:
+        typedef vcg::tri::TriEdgeCollapse<BaseMesh,ParamEdgeCollapse<BaseMesh> > Super;
+	typedef typename BaseMesh::VertexType::EdgeType EdgeType;
+        typedef typename BaseMesh::VertexType VertexType;
+	typedef typename BaseMesh::VertexType BaseVertex;
+	typedef typename BaseMesh::FaceType   BaseFace;
+        typedef typename BaseMesh::FaceType FaceType;
+        typedef typename BaseMesh::ScalarType   ScalarType;
+        typedef typename BaseMesh::CoordType   CoordType;
+        typedef BaseMesh TriMeshType;
+
+	static EnergyType &EType(){static EnergyType E;return E;};
+	
+	inline ParamEdgeCollapse(const EdgeType &p, int mark)
+	{    
+        Super::localMark = mark;
+        Super::pos=p;
+        Super::_priority = ComputePriority();
+	}
+
+	inline ScalarType Cost()
+  {
+	std::vector<typename BaseMesh::FaceType*> on_edge,faces1,faces2;
+        getSharedFace<BaseMesh>(Super::pos.V(0),Super::pos.V(1),on_edge,faces1,faces2);
+
+	FaceType* edgeF[2];
+	edgeF[0]=on_edge[0];
+	edgeF[1]=on_edge[1];
+    ScalarType costArea=EstimateAreaByParam<BaseMesh>(Super::pos.V(0),Super::pos.V(1),edgeF);
+    ScalarType lenght=EstimateLenghtByParam<BaseMesh>(Super::pos.V(0),Super::pos.V(1),edgeF);
+
+	if (costArea<0)
+		assert(0);
+	assert(lenght>=0);
+	return (pow(lenght,2)+costArea);
+  }
+
+	inline bool IsFeasible(){
+    return LinkConditions(Super::pos);
+	}
+
+  inline void SetHlevMeshUV(const std::vector<BaseFace*> &LowFace,
+                                                    std::vector<BaseFace*> &HiFace,
+                                                        std::vector<BaseVertex*> &HiVertex)
+  {
+
+	///interpolate parametric u & v values into the face
+	for (unsigned int index=0;index<LowFace.size();index++)
+	{
+		FaceType *test_face=LowFace[index];
+		assert(!test_face->IsD());
+		for (unsigned int i=0;i<test_face->vertices_bary.size();i++)
+		{
+			VertexType *brother=test_face->vertices_bary[i].first;
+			CoordType bary=test_face->vertices_bary[i].second;
+                        GetUV<BaseMesh>(test_face,bary,brother->T().U(),brother->T().V());
+			//printf("%f , %f \n",brother->T().U(),brother->T().V());
+			assert(brother!=NULL);
+			HiVertex.push_back(brother);
+		}
+	}
+
+	///add brother of the domain mesh
+        std::vector<BaseVertex*> LowVertices;
+	getSharedVertex<BaseMesh>(LowFace,LowVertices);
+	for (unsigned int index=0;index<LowVertices.size();index++)
+	{
+		assert(!LowVertices[index]->IsD());
+		if (LowVertices[index]->brother!=NULL)
+		{
+			VertexType* b=LowVertices[index]->brother;
+			assert(b!=NULL);
+			HiVertex.push_back(b);
+			b->T().P()=LowVertices[index]->T().P();
+		}
+	}
+
+	///then return pointer to hight level faces
+	getSharedFace<BaseMesh>(HiVertex,HiFace);
+  }
+
+  static void  SetBaryFromUV(BaseMesh &domain,
+														 std::vector<BaseVertex*> &vertices)
+  {
+    ///set a vector of pointer to face
+        std::vector<BaseFace*> OrdFace;
+	for (unsigned int h=0;h<domain.face.size();h++)
+		OrdFace.push_back(&domain.face[h]);
+
+	///update parametric positions of vertices
+	for (unsigned int i=0;i<vertices.size();i++)
+		{
+			CoordType bary1;
+			FaceType *chosen;
+			ScalarType u=vertices[i]->T().U();
+			ScalarType v=vertices[i]->T().V();
+      GetBaryFaceFromUV<BaseMesh>(domain,u,v,OrdFace,bary1,chosen);
+			assert(fabs(bary1.X()+bary1.Y()+bary1.Z()-1.0)<=0.0001);
+			/*vertices[i]->father=chosen;
+			assert(!chosen->IsD());
+			vertices[i]->Bary=bary1;*/
+			AssingFather(vertices[i],chosen,bary1,domain);
+		}
+  }
+
+ 
+  struct minInfo0
+  {
+  public:
+	BaseMesh *domain;
+	BaseMesh *collapsed;
+	BaseVertex *central;
+	CoordType middle;
+	std::vector<BaseFace*> HiFace;
+	std::vector<BaseVertex*> HiVertex;
+	ScalarType original_area;
+  };
+  
+ 
+  static void energy0(double *p, double *x, int/* m*/, int /*n*/, void *data)
+  { 
+	minInfo0 &inf = *(minInfo0 *)data; 
+
+	///assing coordinate to the face
+	inf.central->P().X()=p[0];
+	inf.central->P().Y()=p[1];
+	inf.central->P().Z()=p[2];
+
+	///find aspect ratio
+	x[0]=(1.0/AspectRatio<BaseMesh>(*inf.collapsed));
+
+	ScalarType areadelta=0;
+	for (unsigned int i=0;i<inf.domain->face.size();i++)
+		areadelta+=inf.domain->face[i].areadelta;
+
+	ScalarType area0=Area(*inf.collapsed);
+	ScalarType area1=Area(*inf.domain)+areadelta;
+	
+	x[1]=pow(area0/area1+area1/area0,2);//2.0*pow((area0-area1)/area1,2);
+
+	x[2]=AreaDispersion<BaseMesh>(*inf.collapsed);
+	x[3]=0;//(inf.middle-inf.central->P()).SquaredNorm()/area1;
+  }
+
+   ///find best position
+  inline CoordType FindBestPos(BaseMesh &m)
+  {
+    minInfo0 Minf;
+    ///create the submesh
+    VertexType *v0=Super::pos.V(0);
+        VertexType *v1=Super::pos.V(1);
+	
+
+	std::vector<typename BaseMesh::VertexType*> star;
+	std::vector<typename BaseMesh::FaceType*> orderedFaces;
+	star.push_back(v0);
+	star.push_back(v1);
+	BaseMesh created,domain;
+
+	///DISTORSION
+	BaseMesh HLcreated;
+	///DISTORSION
+
+	CreateMeshVertexStar<BaseMesh>(star,orderedFaces,created);
+	/*if (created.face[1].areadelta>1)
+		assert(0);*/
+	UpdateTopologies<BaseMesh>(&created);
+	
+	//ParametrizeLocally(created);
+
+	/////copy uv values on ordered faces
+	//for (int i=0;i<created.face.size();i++)
+	//	for (int j=0;j<3;j++)
+	//		orderedFaces[i]->V(j)->T().P()=created.face[i].V(j)->T().P();
+
+	/////set parametric position respect to new part of submesh
+	///*std::vector<FaceType*> HiFace;
+	//std::vector<VertexType*> HiVertex;*/
+	//SetHlevMeshUV(orderedFaces,Minf.HiFace,Minf.HiVertex);
+
+	///save previous values
+	std::vector<std::pair<FaceType*,CoordType> > swap;
+        typename std::vector<VertexType*>::iterator iteVP;
+	for (iteVP=Minf.HiVertex.begin();iteVP!=Minf.HiVertex.end();iteVP++)
+		swap.push_back(std::pair<FaceType*,CoordType> ((*iteVP)->father,(*iteVP)->Bary));
+	///DISTORSION
+	
+	///create pos
+	EdgeType posEdge;
+	std::vector<typename FaceType::VertexType*> vertEdge;
+	FindNotBorderVertices<BaseMesh>(created,vertEdge);
+
+	posEdge.V(0)=std::max<typename FaceType::VertexType*>(vertEdge[1],vertEdge[0]);
+	posEdge.V(1)=std::min<typename FaceType::VertexType*>(vertEdge[1],vertEdge[0]);
+
+	///simulate collapse
+	CoordType newPos=(v0->P()+v1->P())/2.0;
+
+	///copy domain
+	vcg::tri::Append<BaseMesh,BaseMesh>::Mesh(domain,created);
+	for (unsigned int i=0;i<created.face.size();i++)
+		domain.face[i].areadelta=created.face[i].areadelta;
+
+	DoCollapse(created,posEdge, newPos); // v0 is deleted and v1 take the new position
+	
+	UpdateTopologies<BaseMesh>(&created);
+
+	/////parametrize domain
+	//ParametrizeLocally(created);
+	//ParametrizeLocally(domain);
+	
+	///minimization
+	double p[3];
+	p[0]=newPos.X();
+	p[1]=newPos.Y();
+	p[2]=newPos.Z();
+
+	/*minInfo Minf;*/
+	Minf.domain=&domain;
+	Minf.collapsed=&created;
+	Minf.central=posEdge.V(1);
+	Minf.middle=newPos;
+
+	double x[4];
+	x[0]=0;
+	x[1]=0;
+	x[2]=0;
+	x[3]=0;
+	/*x[4]=0;*/
+
+	double opts[LM_OPTS_SZ], info[LM_INFO_SZ];
+	opts[0]=LM_INIT_MU; opts[1]=1E-15; opts[2]=1E-15; opts[3]=1E-20;
+	opts[4]=LM_DIFF_DELTA;
+
+	//energy0(p,x,3,4,Minf);
+	
+	/*int num=*/dlevmar_dif(energy0,p,x,3,4,1000,opts,info,NULL,NULL,&Minf);
+
+	///find back the value
+	
+	CoordType bestPos;
+	bestPos.X()=p[0];
+	bestPos.Y()=p[1];
+	bestPos.Z()=p[2];
+
+
+	for (unsigned int i=0;i<Minf.HiVertex.size();i++)
+	{/*
+		Minf.HiVertex[i]->father=swap[i].first;
+		assert(!swap[i].first->IsD());
+		Minf.HiVertex[i]->Bary=swap[i].second;*/
+		AssingFather(*Minf.HiVertex[i],swap[i].first,swap[i].second,m);
+	}
+
+	return (bestPos);
+  }
+
+  inline ScalarType ComputePriority()
+  { 
+	return (Cost());
+	//return( Distance(pos.V(0)->cP(),pos.V(1)->cP()));
+  }
+
+  CoordType ComputeMinimal(BaseMesh &m)
+  {
+	CoordType bestPos=FindBestPos(m);
+	return bestPos;
+  }
+
+  void UpdateFF(EdgeType &posEdge)
+	{
+		std::vector<typename TriMeshType::FaceType*> shared;
+		std::vector<typename TriMeshType::FaceType*> in_v0;
+		std::vector<typename TriMeshType::FaceType*> in_v1;
+		///then reupdate topology
+		getSharedFace<TriMeshType>(posEdge.V(0),posEdge.V(1),shared,in_v0,in_v1);
+
+		///find the edge shared between them
+		for (unsigned int j=0;j<shared.size();j++)
+		{
+			int iedge=-1;
+			FaceType* face=shared[j];
+			if (((face->V(0)==posEdge.V(0))&&(face->V(1)==posEdge.V(1)))||
+				 (face->V(0)==posEdge.V(1))&&(face->V(1)==posEdge.V(0)))
+				 iedge=0;
+			else
+			if (((face->V(1)==posEdge.V(0))&&(face->V(2)==posEdge.V(1)))||
+				 (face->V(1)==posEdge.V(1))&&(face->V(2)==posEdge.V(0)))
+				 iedge=1;
+			else
+			if (((face->V(2)==posEdge.V(0))&&(face->V(0)==posEdge.V(1)))||
+				 (face->V(2)==posEdge.V(1))&&(face->V(0)==posEdge.V(0)))
+				 iedge=2;
+			assert (iedge!=-1);
+
+			///then update topology for the two other faces 
+			int edge0=(iedge+1)%3;
+			int edge1=(iedge+2)%3;
+
+			///get opposEdgeite faces and indexes
+			FaceType* f0=face->FFp(edge0);
+			FaceType* f1=face->FFp(edge1);
+			
+			int indexopp0=face->FFi(edge0);
+			int indexopp1=face->FFi(edge1);
+			///control if they are border 
+			if ((f0==face)&&(f1==face))
+			{
+				printf("border");
+			}
+			else
+			if (f0==face)
+			{
+				f1->FFp(indexopp1)=f1;
+				f1->FFi(indexopp1)=-1;
+				printf("border");
+			}
+			else
+			if (f1==face)
+			{
+				f0->FFp(indexopp0)=f0;
+				f0->FFi(indexopp0)=-1;
+				printf("border");
+			}
+			else///otherwise attache two other faces
+			{
+				///the reassing adiacency
+				f0->FFp(indexopp0)=f1;
+				f1->FFp(indexopp1)=f0;
+				f0->FFi(indexopp0)=indexopp1;
+				f1->FFi(indexopp1)=indexopp0;
+				assert( f0->FFp(indexopp0)->FFp(f0->FFi(indexopp0))==f0 );
+				assert( f1->FFp(indexopp1)->FFp(f1->FFi(indexopp1))==f1 );
+			}
+			
+		}	
+	}
+
+
+///create a copy the submesh for a collapse and parameterize it
+void CreatePreCollapseSubmesh(EdgeType &pos,
+							  BaseMesh &param,
+							  std::vector<VertexType*> &orderedVertex,
+							  std::vector<FaceType*> &orderedFaces)
+{
+	std::vector<VertexType*> vert_star;
+	vert_star.push_back(pos.V(0));
+	vert_star.push_back(pos.V(1));
+
+	///get a copy of the mesh
+	CreateMeshVertexStar(vert_star,orderedFaces,orderedVertex,param);
+	UpdateTopologies(&param);
+	InitDampRestUV(param);
+
+	ParametrizeLocally<BaseMesh>(param);
+
+	///store UV coordinates in original vertex to copy 
+	///for post collapsed surface parametrization
+	for (unsigned int i=0;i<orderedVertex.size();i++)
+		orderedVertex[i]->T().P()=param.vert[i].T().P();
+}
+
+///create a copy the submesh after the collapse that is already parameterized
+/// only the central vertex has to be set to (0,0)
+void CreatePostCollapseSubmesh(EdgeType &pos,
+							   BaseMesh &param_post,
+							  std::vector<VertexType*> &orderedVertex,
+							  std::vector<FaceType*> &orderedFaces)
+{
+	std::vector<VertexType*> vert_star;
+	vert_star.push_back(pos.V(1));
+
+	CreateMeshVertexStar(vert_star,orderedFaces,orderedVertex,param_post);
+	UpdateTopologies(&param_post);
+	InitDampRestUV(param_post);
+
+	///set to zero the star center (non border)
+	bool found=false;
+	unsigned int i=0;
+	while ((i<param_post.vert.size())&&(!found))
+	{
+		if (!param_post.vert[i].IsB())
+			found=true;
+		else
+			i++;
+	}
+	assert(found);
+	param_post.vert[i].T().P()=vcg::Point2<ScalarType>(0,0);
+		
+}
+
+void AphaBetaToUV(EdgeType &pos,
+				  std::vector<FaceType*> &orderedFaces,
+				  BaseMesh &param,
+			      std::vector<VertexType*> &HresVert)
+{
+	/*const ScalarType eps=(ScalarType)0.00001;*/
+	///VERTEX ON FACE REPROJECTING
+	//transform from Alpha Beta to UV
+	for (unsigned int index=0;index<orderedFaces.size();index++)
+	{
+		FaceType *test_face=orderedFaces[index];
+		FaceType *parametric_face=&param.face[index];
+
+		///fro each vertex belonging to such face
+		for (unsigned int i=0;i<test_face->vertices_bary.size();i++)
+		{
+			///get brother vertex
+			VertexType *brother=test_face->vertices_bary[i].first;
+			assert(brother!=NULL);
+
+			///get his barycentric coordinates
+			CoordType bary=test_face->vertices_bary[i].second;
+
+			///transform to UV
+			ScalarType u,v;
+			GetUV<BaseMesh>(parametric_face,bary,u,v);
+			///and assing
+			brother->T().U()=u;
+			brother->T().V()=v;
+
+			/*///testing coordinates
+			if (!((u>-1.0-eps)&&(u<1.0+eps)&&
+			   (v>-1.0-eps)&&(v<1.0+eps)))
+			{
+				printf("Error 0 Uv :%f,%f \n",u,v);
+				printf("Bary :%f,%f %f \n",bary.X(),bary.Y(),bary.Z());
+				system("pause");
+			}*/
+
+			///save high res vertices
+			HresVert.push_back(brother);
+		}
+		/*///clear 
+		test_face->vertices_bary.clear();*/
+	}
+	
+	///add the two collapsed vertex
+	///and set UV coordinates
+	for (int i=0;i<2;i++)
+	{ 
+		if (pos.V(i)->brother!=NULL)
+		{
+			HresVert.push_back(pos.V(i)->brother);
+			///set his coordinates 
+			pos.V(i)->brother->T().P()=pos.V(i)->T().P();
+
+			//param_pos.push_back(vert_star0[i]->T().P());
+			///color for flip test
+
+			///set his brother as null
+			pos.V(i)->brother=NULL;
+		}
+	}
+
+}
+
+void UVToAlphaBeta(std::vector<VertexType*> &HresVert,
+									  BaseMesh &param,std::vector<FaceType*> &orderedFaces,
+										BaseMesh &base_mesh)
+{
+	///for each parametrized vertex
+	for (unsigned int i=0;i<HresVert.size();i++)
+	{
+		///get his brother
+		CoordType bary1;
+		FaceType *chosen;
+		VertexType *brother=HresVert[i];
+		assert(brother!=NULL);
+		///and its barycentric coords
+		ScalarType u=HresVert[i]->T().U();
+		ScalarType v=HresVert[i]->T().V();
+		int index;
+
+		////found the face and its barycentric coordinates form the parametrized mesh
+		bool found=GetBaryFaceFromUV(param,u,v,bary1,index);
+
+		///test for approximation errors
+		if (!found)
+		{
+			printf("Error 1\n");
+			printf("Old Uv :%f,%f \n",u,v);
+			while (!found)
+			{
+				///put next to the center
+				u*=(ScalarType)0.9;
+				v*=(ScalarType)0.9;
+				found=GetBaryFaceFromUV(param,u,v,bary1,index);//<BaseMesh>(param1,u,v,orderedFaces1,bary1,chosen);
+			}
+			printf("New Uv %f,%f \n",u,v);
+		}
+		
+		///get the face from original mesh
+		assert(found);
+		chosen=orderedFaces[index];
+		//if (!(fabs(bary1.X()+bary1.Y()+bary1.Z()-1.0)<=0.0001))
+		//{
+		//	printf("Error 2 Uv :%f,%f \n",u,v);
+		//	system("pause");
+		//	bary1=CoordType(0.3333,0.3333,0.3333);
+		//	chosen=orderedFaces[0];
+		//	//assert(0);
+		//}
+		///set father-son relation
+		chosen->vertices_bary.push_back(std::pair<BaseVertex*,vcg::Point3f>(brother,bary1));
+		
+		AssingFather(*brother,chosen,bary1,base_mesh);
+		/*brother->father=chosen;
+		assert(!chosen->IsD());
+		brother->Bary=bary1;*/
+
+		///set new parametrization value
+		GetUV<BaseMesh>(&param.face[index],bary1,u,v);
+		HresVert[i]->T().U()=u;
+		HresVert[i]->T().V()=v;
+	}
+}
+
+void ClearVert_Bary(std::vector<FaceType*> &orderedFaces)
+{
+	for (unsigned int index=0;index<orderedFaces.size();index++)
+	{
+		FaceType *test_face=orderedFaces[index];
+		test_face->vertices_bary.clear();
+	}
+}
+
+void AssignRPos(VertexType* &to_assign,
+				ScalarType &U,
+				ScalarType &V,
+				std::vector<FaceType*> &orderedFaces,
+				BaseMesh &param)
+{
+	CoordType val;
+
+	////set rest positions for survived vertex
+	///create h resolution mesh 
+	BaseMesh hlev_mesh;
+	std::vector<BaseVertex*> ord_vertex;
+	CopyHlevMesh(orderedFaces,hlev_mesh,ord_vertex);
+	///first interpolate in h_res then proceed to lowres if doesn't find
+	bool found;
+	found=GetCoordFromUV(hlev_mesh,U,V,val,true);   
+	if (!found)
+		found=GetCoordFromUV(param,U,V,val,true);   
+	
+	assert (found);
+	
+	to_assign->RPos=val;
+}
+
+void Execute(BaseMesh &m)
+	{	
+    typedef typename BaseMesh::FaceType FaceType;
+    typedef typename BaseMesh::VertexType VertexType;
+    typedef typename BaseMesh::ScalarType ScalarType;
+    typedef typename BaseMesh::CoordType CoordType;
+		
+		assert(this->pos.V(0)!=this->pos.V(1));
+		assert(!this->pos.V(0)->IsD());
+		assert(!this->pos.V(1)->IsD());
+    assert(size_t((this->pos.V(0)-&(*m.vert.begin())))<m.vert.size());
+    assert(size_t((this->pos.V(1)-&(*m.vert.begin())))<m.vert.size());
+				
+    std::vector<FaceType*> result;
+    std::vector<FaceType*> in_v0;
+    std::vector<FaceType*> in_v1;
+
+#ifndef NDEBUG
+		getSharedFace<BaseMesh>(this->pos.V(0),this->pos.V(1),result,in_v0,in_v1);
+		assert(result.size()==2);
+#endif
+
+		///compute new position
+		CoordType oldRPos=(this->pos.V(0)->RPos+this->pos.V(1)->RPos)/2.0;
+		CoordType newPos;
+		newPos=ComputeMinimal(m);//
+		//vcg::tri::UpdateTopology<BaseMesh>::TestVertexFace(m); ///TEST
+
+		BaseMesh param0,param1;
+		//std::vector<VertexType*> vert_star0,vert_star1;
+		std::vector<FaceType*> orderedFaces0,orderedFaces1;
+		std::vector<VertexType*> orderedVertex0,orderedVertex1;
+	
+		///create a parametrized submesh pre-collapse
+    CreatePreCollapseSubmesh(Super::pos,param0,orderedVertex0,orderedFaces0);
+
+//---------------------------///
+		///update FF topology post-collapse
+		UpdateFF(this->pos);
+		
+		///INITIAL AREA
+		ScalarType area0=Area<BaseFace>(orderedFaces0);
+
+		///do the collapse
+		DoCollapse(m, this->pos, newPos); // v0 is deleted and v1 take the new position
+		//vcg::tri::UpdateTopology<BaseMesh>::TestVertexFace(m); ///TEST
+		//---------------------------///
+		///create a parametrized submesh post-collapse #1
+    CreatePostCollapseSubmesh(this->pos,param1,orderedVertex1,orderedFaces1);
+
+		//---------------------------///
+		///FINAL AREA
+		ScalarType area1=Area<BaseFace>(orderedFaces1);
+		
+		////save error
+		ScalarType areadelta=(area0-area1)/(ScalarType)orderedFaces1.size();
+		for (unsigned int i=0;i<orderedFaces1.size();i++)
+			orderedFaces1[i]->areadelta=areadelta;
+		
+		///VERTEX ON FACE REPROJECTING #2
+		//---------------------------///
+		/////collect all vertices with respective param coords
+		std::vector<VertexType*> HresVert;
+	
+		//TRANSFORM TO UV
+    AphaBetaToUV(this->pos,orderedFaces0,param0,HresVert);
+		
+		//DELETE SONS
+		ClearVert_Bary(orderedFaces0);
+//---------------------------///
+		
+		///UPTIMIZE UV
+		//OptimizeUV(&param0,&param1,HresVert);
+		
+//---------------------------///
+		///REPROJECT BACK TO ORIGINAL FATHER #3
+		
+		UVToAlphaBeta(HresVert,param1,orderedFaces1,m);
+
+		
+        /*PatchesOptimizer<BaseMesh>::OptimizeUV(this->pos.V(1),m);*/
+	
+//---------------------------///
+		///get the non border one that is the one survived
+		unsigned int k=0;
+		while ((param1.vert[k].IsB())&&(k<param1.vert.size()))
+			k++;
+		assert(k<param1.vert.size());
+		CoordType val;
+
+//---------------------------///
+		///ASSIGN REST POSITION CENTRAL VERTEX
+		//AssignRPos(pos.V(1),param1.vert[k].T().U(),param1.vert[k].T().V(),orderedFaces1,param0);
+//---------------------------///
+	
+		///FINAL OPTIMIZATION
+		/*int t0=clock();*/
+		
+		this->pos.V(1)->RPos=oldRPos;
+		
+    /*bool b=*/SmartOptimizeStar<BaseMesh>(this->pos.V(1),m,Accuracy(),EType());
+		
+		/*int t1=clock();
+		time_opt+=(t1-t0);*/
+	}
+
+public:
+	static int &Accuracy()
+	{
+		static int _acc;
+		return _acc;
+	}
+	
+	static BaseMesh* &HresMesh()
+	{
+		static BaseMesh* mesh;
+		return mesh;
+	}
+
+	BaseVertex *getV(int num)
+	{
+		assert((num>=0)&&(num<2));
+		return this->pos.V(num);
+	}	
+};
+
+#endif
diff --git a/src/meshlabplugins/filter_isoparametrization/param_flip.h b/src/meshlabplugins/filter_isoparametrization/param_flip.h
index 8f1674208..f635fcc83 100644
--- a/src/meshlabplugins/filter_isoparametrization/param_flip.h
+++ b/src/meshlabplugins/filter_isoparametrization/param_flip.h
@@ -1,315 +1,315 @@
-#ifndef PARAM_FLIP
-#define PARAM_FLIP
-
-#include <vcg/complex/local_optimization/tri_edge_flip.h>
-
-///Flip function
-template <class BaseMesh>
-class ParamEdgeFlip : public vcg::tri::PlanarEdgeFlip<BaseMesh, ParamEdgeFlip<BaseMesh> >
-{
-	typedef typename BaseMesh::VertexType::EdgeType EdgeType;
-	typedef typename BaseMesh::VertexType BaseVertex;
-        typedef typename BaseMesh::VertexType VertexType;
-	typedef typename BaseMesh::FaceType   BaseFace;
-        typedef typename BaseMesh::FaceType   FaceType;
-        typedef typename BaseMesh::CoordType   CoordType;
-        typedef typename BaseMesh::ScalarType   ScalarType;
-        typedef vcg::tri::PlanarEdgeFlip<BaseMesh, ParamEdgeFlip<BaseMesh> > Super;
-	ScalarType diff;
-
-	public:
-	
-	static EnergyType &EType(){static EnergyType E;return E;};
-
-	bool savedomain;
-	
-	bool IsFeasible()
-	{
-		if(!vcg::face::CheckFlipEdge(*this->_pos.F(), this->_pos.E()))
-			return false;
-
-		return (this->_priority>0);
-	}
-
-	inline ParamEdgeFlip() {}
-
-	/*!
-	 *	Constructor with <I>pos</I> type
-	 */
-  inline ParamEdgeFlip(const typename Super::PosType pos, int mark)
-	{
-		this->_pos = pos;
-		this->_localMark = mark;
-		this->_priority = this->ComputePriority();
-		savedomain=false;
-	}
-
-	///do the effective flip 
-	void ExecuteFlip(FaceType &f, const int &edge, BaseMesh *base_domain=NULL)
-	{
-		std::vector<FaceType*> faces;
-		faces.push_back(&f);
-		faces.push_back(f.FFp(edge));
-		std::vector<VertexType*> HresVert;
-		getHresVertex<FaceType>(faces,HresVert);
-		///parametrize H_res mesh respect to diamond
-		for (unsigned int i=0;i<HresVert.size();i++)
-		{
-			VertexType* v=HresVert[i];
-			///get father & bary
-			FaceType* father=v->father;
-			CoordType bary=v->Bary;
-			assert((father==faces[0])||(father==faces[1]));
-			vcg::Point2<ScalarType> t0=father->V(0)->T().P();
-			vcg::Point2<ScalarType> t1=father->V(1)->T().P();
-			vcg::Point2<ScalarType> t2=father->V(2)->T().P();
-
-			//assert(testBaryCoords(bary));
-			if(!testBaryCoords(bary))
-		{
-			printf("BAry0 :%lf,%lf,%lf",bary.X(),bary.Y(),bary.Z());
-			//system("pause");
-		}
-
-			GetUV<BaseMesh>(father,bary,v->T().U(),v->T().V());
-		}
-
-		///update VF topology
-		FaceType *f1=f.FFp(edge);
-		FaceType *f0=&f;
-		vcg::face::VFDetach(*f1,0);
-		vcg::face::VFDetach(*f1,1);
-		vcg::face::VFDetach(*f1,2);
-		vcg::face::VFDetach(*f0,0);
-		vcg::face::VFDetach(*f0,1);
-		vcg::face::VFDetach(*f0,2);
-		///then do the effective flip
-
-		vcg::face::FlipEdge(f,edge);
-
-		
-		
-		vcg::face::VFAppend(f1,0);
-		vcg::face::VFAppend(f1,1);
-		vcg::face::VFAppend(f1,2);
-		vcg::face::VFAppend(f0,0);
-		vcg::face::VFAppend(f0,1);
-		vcg::face::VFAppend(f0,2);
-		///edh updating topology
-
-
-		///set son->father new link
-		for (unsigned int i=0;i<HresVert.size();i++)
-		{
-			VertexType* v=HresVert[i];
-			ScalarType U=v->T().U();
-			ScalarType V=v->T().V();
-			CoordType bary;
-			int index;
-			bool found=GetBaryFaceFromUV(faces,U,V,bary,index);
-			if (!found)
-			{
-				printf("\n U : %lf; V : %lf \n",U,V);
-				//system("pause");
-			}
-			//assert(found);
-			assert(testBaryCoords(bary));
-			if (base_domain!=NULL)
-				AssingFather(*v,faces[index],bary,*base_domain);
-			else
-			{
-				v->father=faces[index];
-				assert(!faces[index]->IsD());
-				v->Bary=bary;
-			}
-		}
-		
-		
-
-		///set father->son new link
-		for (unsigned int i=0;i<faces.size();i++)
-			faces[i]->vertices_bary.clear();
-
-		for (unsigned int i=0;i<HresVert.size();i++)
-		{
-			VertexType *son=HresVert[i];
-			FaceType *father=son->father;
-			CoordType bary=son->Bary;
-			father->vertices_bary.push_back(std::pair<BaseVertex*,vcg::Point3f>(son,bary));
-		}
-		
-	}
-
-	ScalarType EdgeDiff()
-	{
-		/*
-		     1  
-		    /|\
-		   / | \
-		 2 f0|f1 3 
-		   \ | /
-		    \|/
-		     0
-		 */
-		
-		VertexType *v0, *v1, *v2, *v3;
-		int edge0 = this->_pos.E();
-		v0 = this->_pos.F()->V0(edge0);
-		v1 = this->_pos.F()->V1(edge0);
-		v2 = this->_pos.F()->V2(edge0);
-		v3 = this->_pos.F()->FFp(edge0)->V2(this->_pos.F()->FFi(edge0));
-		int edge1=this->_pos.F()->FFi(edge0);
-		FaceType* f0=this->_pos.F();
-		FaceType* f1=this->_pos.F()->FFp(edge0);
-
-		///parametrize all possible diamonds
-		///diam0 & diam1
-		///make a copy of the mesh
-		std::vector<FaceType*> OrdFace;
-		OrdFace.push_back(f0);
-		OrdFace.push_back(f1);
-		
-		BaseMesh Diam;
-		BaseMesh DiamHres;
-
-		///create a copy of the domain and of the H resolution
-		CopySubMeshLevels(OrdFace,Diam,DiamHres);
-		
-		///parametrize domains
-		ParametrizeDiamondEquilateral(Diam,edge0,edge1);
-
-		///copy parametrization on original mesh
-
-		FaceType* on_edge[2];
-		on_edge[0]=&Diam.face[0];
-		on_edge[1]=&Diam.face[1];
-		assert(Diam.face[0].FFp(edge0)==&Diam.face[1]);///test
-		assert(Diam.face[1].FFp(edge1)==&Diam.face[0]);///test
-
-		///Evaluate lenght of shared edge
-		ScalarType L0=EstimateLenghtByParam<BaseMesh>(Diam.face[0].V(edge0),Diam.face[0].V((edge0+1)%3),on_edge);
-
-		///do the flip on the copied mesh do not affect the original mesh
-		ExecuteFlip(Diam.face[0],edge0);
-		
-		UpdateTopologies(&Diam);
-		
-		///get the non border edge of face0
-		int NB_edge=-1;
-		if (!Diam.face[0].IsB(0))
-			NB_edge=0;
-		else
-		if (!Diam.face[0].IsB(1))
-			NB_edge=1;
-		else
-		if (!Diam.face[0].IsB(2))
-			NB_edge=2;
-		assert(NB_edge!=-1);
-
-		ScalarType L1=EstimateLenghtByParam<BaseMesh>(Diam.face[0].V(NB_edge),Diam.face[0].V((NB_edge+1)%3),on_edge);
-		
-		ScalarType value=L0-L1;
-		diff=value;
-		this->_priority = 1.0/value;
-		return (this->_priority);
-	}
-	
-	
-	void Execute(BaseMesh &m)
-	{
-		
-		assert(this->_priority>0);
-		/*
-		     1  
-		    /|\
-		   / | \
-		 2 f0|f1 3 
-		   \ | /
-		    \|/
-		     0
-		 */
-		VertexType *v0, *v1, *v2, *v3;
-		int edge0 = this->_pos.E();
-		v0 = this->_pos.F()->V0(edge0);
-		v1 = this->_pos.F()->V1(edge0);
-		v2 = this->_pos.F()->V2(edge0);
-		v3 = this->_pos.F()->FFp(edge0)->V2(this->_pos.F()->FFi(edge0));
-		///assing texcoords
-		ScalarType h=(sqrt((ScalarType)3.0)/(ScalarType)2.0);
-		v0->T().P()=vcg::Point2<ScalarType>(0,(ScalarType)-0.5);
-		v1->T().P()=vcg::Point2<ScalarType>(0,(ScalarType)0.5);
-		v2->T().P()=vcg::Point2<ScalarType>(-h,0);
-		v3->T().P()=vcg::Point2<ScalarType>(h,0);
-
-#ifndef _MESHLAB
-		///save domain if need for demos
-		if (savedomain)
-		{
-			BaseMesh hlev_mesh;
-			std::vector<FaceType*> faces;
-			FaceType* f=this->_pos.F();
-			int edge=this->_pos.E();
-			faces.push_back(f);
-			faces.push_back(f->FFp(edge));
-			std::vector<VertexType*> HresVert;
-			getHresVertex<FaceType>(faces,HresVert);
-
-			///parametrize H_res mesh respect to diamond
-			std::vector<VertexType*> OrderedVertices;
-			std::vector<FaceType*> OrderedFaces;
-			CopyMeshFromVertices(HresVert,OrderedVertices,OrderedFaces,hlev_mesh);
-			//for (int i=0;i<hlev_mesh.vert.size();i++)
-				//hlev_mesh.vert[i].C()=hlev_mesh.vert[i].OriginalCol;
-
-			vcg::tri::io::ExporterPLY<BaseMesh>::Save(hlev_mesh,"c:/export_submeshes/FLIPHlev3D.ply",vcg::tri::io::Mask::IOM_VERTCOLOR);
-			for (unsigned int i=0;i<hlev_mesh.vert.size();i++)
-			{
-				hlev_mesh.vert[i].P().X()=hlev_mesh.vert[i].T().U();
-				hlev_mesh.vert[i].P().Y()=hlev_mesh.vert[i].T().V();
-				hlev_mesh.vert[i].P().Z()=0;
-			}
-			vcg::tri::io::ExporterPLY<BaseMesh>::Save(hlev_mesh,"c:/export_submeshes/FLIPHlevUV.ply",vcg::tri::io::Mask::IOM_VERTCOLOR);
-		}
-#endif
-
-		ExecuteFlip(*this->_pos.F(),this->_pos.E(),&m);
-		
-		UpdateTopologies(&m);
-		
-		///stars optimization
-		/*int t0=clock();*/
-		/*OptimizeStar<BaseMesh>(v0);
-		OptimizeStar<BaseMesh>(v1);
-		OptimizeStar<BaseMesh>(v2);
-		OptimizeStar<BaseMesh>(v3);*/
-		
-		SmartOptimizeStar<BaseMesh>(v0,m,Accuracy(),EType());
-		SmartOptimizeStar<BaseMesh>(v1,m,Accuracy(),EType());
-		SmartOptimizeStar<BaseMesh>(v2,m,Accuracy(),EType());
-		SmartOptimizeStar<BaseMesh>(v3,m,Accuracy(),EType());	
-		/*int t1=clock();
-		time_opt+=(t1-t0);*/
-	}
-
-	ScalarType ComputePriority()
-	{
-    this->_priority=EdgeDiff();
-		return this->_priority;
-	}
-
-	BaseFace *getF()
-	{return this->_pos.F();}
-
-	int getE()
-	{return this->_pos.E();}
-
-	public:
-	static int &Accuracy()
-	{
-		static int _acc;
-		return _acc;
-	}
-
-};
-
-#endif
+#ifndef PARAM_FLIP
+#define PARAM_FLIP
+
+#include <vcg/complex/algorithms/local_optimization/tri_edge_flip.h>
+
+///Flip function
+template <class BaseMesh>
+class ParamEdgeFlip : public vcg::tri::PlanarEdgeFlip<BaseMesh, ParamEdgeFlip<BaseMesh> >
+{
+	typedef typename BaseMesh::VertexType::EdgeType EdgeType;
+	typedef typename BaseMesh::VertexType BaseVertex;
+        typedef typename BaseMesh::VertexType VertexType;
+	typedef typename BaseMesh::FaceType   BaseFace;
+        typedef typename BaseMesh::FaceType   FaceType;
+        typedef typename BaseMesh::CoordType   CoordType;
+        typedef typename BaseMesh::ScalarType   ScalarType;
+        typedef vcg::tri::PlanarEdgeFlip<BaseMesh, ParamEdgeFlip<BaseMesh> > Super;
+	ScalarType diff;
+
+	public:
+	
+	static EnergyType &EType(){static EnergyType E;return E;};
+
+	bool savedomain;
+	
+	bool IsFeasible()
+	{
+		if(!vcg::face::CheckFlipEdge(*this->_pos.F(), this->_pos.E()))
+			return false;
+
+		return (this->_priority>0);
+	}
+
+	inline ParamEdgeFlip() {}
+
+	/*!
+	 *	Constructor with <I>pos</I> type
+	 */
+  inline ParamEdgeFlip(const typename Super::PosType pos, int mark)
+	{
+		this->_pos = pos;
+		this->_localMark = mark;
+		this->_priority = this->ComputePriority();
+		savedomain=false;
+	}
+
+	///do the effective flip 
+	void ExecuteFlip(FaceType &f, const int &edge, BaseMesh *base_domain=NULL)
+	{
+		std::vector<FaceType*> faces;
+		faces.push_back(&f);
+		faces.push_back(f.FFp(edge));
+		std::vector<VertexType*> HresVert;
+		getHresVertex<FaceType>(faces,HresVert);
+		///parametrize H_res mesh respect to diamond
+		for (unsigned int i=0;i<HresVert.size();i++)
+		{
+			VertexType* v=HresVert[i];
+			///get father & bary
+			FaceType* father=v->father;
+			CoordType bary=v->Bary;
+			assert((father==faces[0])||(father==faces[1]));
+			vcg::Point2<ScalarType> t0=father->V(0)->T().P();
+			vcg::Point2<ScalarType> t1=father->V(1)->T().P();
+			vcg::Point2<ScalarType> t2=father->V(2)->T().P();
+
+			//assert(testBaryCoords(bary));
+			if(!testBaryCoords(bary))
+		{
+			printf("BAry0 :%lf,%lf,%lf",bary.X(),bary.Y(),bary.Z());
+			//system("pause");
+		}
+
+			GetUV<BaseMesh>(father,bary,v->T().U(),v->T().V());
+		}
+
+		///update VF topology
+		FaceType *f1=f.FFp(edge);
+		FaceType *f0=&f;
+		vcg::face::VFDetach(*f1,0);
+		vcg::face::VFDetach(*f1,1);
+		vcg::face::VFDetach(*f1,2);
+		vcg::face::VFDetach(*f0,0);
+		vcg::face::VFDetach(*f0,1);
+		vcg::face::VFDetach(*f0,2);
+		///then do the effective flip
+
+		vcg::face::FlipEdge(f,edge);
+
+		
+		
+		vcg::face::VFAppend(f1,0);
+		vcg::face::VFAppend(f1,1);
+		vcg::face::VFAppend(f1,2);
+		vcg::face::VFAppend(f0,0);
+		vcg::face::VFAppend(f0,1);
+		vcg::face::VFAppend(f0,2);
+		///edh updating topology
+
+
+		///set son->father new link
+		for (unsigned int i=0;i<HresVert.size();i++)
+		{
+			VertexType* v=HresVert[i];
+			ScalarType U=v->T().U();
+			ScalarType V=v->T().V();
+			CoordType bary;
+			int index;
+			bool found=GetBaryFaceFromUV(faces,U,V,bary,index);
+			if (!found)
+			{
+				printf("\n U : %lf; V : %lf \n",U,V);
+				//system("pause");
+			}
+			//assert(found);
+			assert(testBaryCoords(bary));
+			if (base_domain!=NULL)
+				AssingFather(*v,faces[index],bary,*base_domain);
+			else
+			{
+				v->father=faces[index];
+				assert(!faces[index]->IsD());
+				v->Bary=bary;
+			}
+		}
+		
+		
+
+		///set father->son new link
+		for (unsigned int i=0;i<faces.size();i++)
+			faces[i]->vertices_bary.clear();
+
+		for (unsigned int i=0;i<HresVert.size();i++)
+		{
+			VertexType *son=HresVert[i];
+			FaceType *father=son->father;
+			CoordType bary=son->Bary;
+			father->vertices_bary.push_back(std::pair<BaseVertex*,vcg::Point3f>(son,bary));
+		}
+		
+	}
+
+	ScalarType EdgeDiff()
+	{
+		/*
+		     1  
+		    /|\
+		   / | \
+		 2 f0|f1 3 
+		   \ | /
+		    \|/
+		     0
+		 */
+		
+		VertexType *v0, *v1, *v2, *v3;
+		int edge0 = this->_pos.E();
+		v0 = this->_pos.F()->V0(edge0);
+		v1 = this->_pos.F()->V1(edge0);
+		v2 = this->_pos.F()->V2(edge0);
+		v3 = this->_pos.F()->FFp(edge0)->V2(this->_pos.F()->FFi(edge0));
+		int edge1=this->_pos.F()->FFi(edge0);
+		FaceType* f0=this->_pos.F();
+		FaceType* f1=this->_pos.F()->FFp(edge0);
+
+		///parametrize all possible diamonds
+		///diam0 & diam1
+		///make a copy of the mesh
+		std::vector<FaceType*> OrdFace;
+		OrdFace.push_back(f0);
+		OrdFace.push_back(f1);
+		
+		BaseMesh Diam;
+		BaseMesh DiamHres;
+
+		///create a copy of the domain and of the H resolution
+		CopySubMeshLevels(OrdFace,Diam,DiamHres);
+		
+		///parametrize domains
+		ParametrizeDiamondEquilateral(Diam,edge0,edge1);
+
+		///copy parametrization on original mesh
+
+		FaceType* on_edge[2];
+		on_edge[0]=&Diam.face[0];
+		on_edge[1]=&Diam.face[1];
+		assert(Diam.face[0].FFp(edge0)==&Diam.face[1]);///test
+		assert(Diam.face[1].FFp(edge1)==&Diam.face[0]);///test
+
+		///Evaluate lenght of shared edge
+		ScalarType L0=EstimateLenghtByParam<BaseMesh>(Diam.face[0].V(edge0),Diam.face[0].V((edge0+1)%3),on_edge);
+
+		///do the flip on the copied mesh do not affect the original mesh
+		ExecuteFlip(Diam.face[0],edge0);
+		
+		UpdateTopologies(&Diam);
+		
+		///get the non border edge of face0
+		int NB_edge=-1;
+		if (!Diam.face[0].IsB(0))
+			NB_edge=0;
+		else
+		if (!Diam.face[0].IsB(1))
+			NB_edge=1;
+		else
+		if (!Diam.face[0].IsB(2))
+			NB_edge=2;
+		assert(NB_edge!=-1);
+
+		ScalarType L1=EstimateLenghtByParam<BaseMesh>(Diam.face[0].V(NB_edge),Diam.face[0].V((NB_edge+1)%3),on_edge);
+		
+		ScalarType value=L0-L1;
+		diff=value;
+		this->_priority = 1.0/value;
+		return (this->_priority);
+	}
+	
+	
+	void Execute(BaseMesh &m)
+	{
+		
+		assert(this->_priority>0);
+		/*
+		     1  
+		    /|\
+		   / | \
+		 2 f0|f1 3 
+		   \ | /
+		    \|/
+		     0
+		 */
+		VertexType *v0, *v1, *v2, *v3;
+		int edge0 = this->_pos.E();
+		v0 = this->_pos.F()->V0(edge0);
+		v1 = this->_pos.F()->V1(edge0);
+		v2 = this->_pos.F()->V2(edge0);
+		v3 = this->_pos.F()->FFp(edge0)->V2(this->_pos.F()->FFi(edge0));
+		///assing texcoords
+		ScalarType h=(sqrt((ScalarType)3.0)/(ScalarType)2.0);
+		v0->T().P()=vcg::Point2<ScalarType>(0,(ScalarType)-0.5);
+		v1->T().P()=vcg::Point2<ScalarType>(0,(ScalarType)0.5);
+		v2->T().P()=vcg::Point2<ScalarType>(-h,0);
+		v3->T().P()=vcg::Point2<ScalarType>(h,0);
+
+#ifndef _MESHLAB
+		///save domain if need for demos
+		if (savedomain)
+		{
+			BaseMesh hlev_mesh;
+			std::vector<FaceType*> faces;
+			FaceType* f=this->_pos.F();
+			int edge=this->_pos.E();
+			faces.push_back(f);
+			faces.push_back(f->FFp(edge));
+			std::vector<VertexType*> HresVert;
+			getHresVertex<FaceType>(faces,HresVert);
+
+			///parametrize H_res mesh respect to diamond
+			std::vector<VertexType*> OrderedVertices;
+			std::vector<FaceType*> OrderedFaces;
+			CopyMeshFromVertices(HresVert,OrderedVertices,OrderedFaces,hlev_mesh);
+			//for (int i=0;i<hlev_mesh.vert.size();i++)
+				//hlev_mesh.vert[i].C()=hlev_mesh.vert[i].OriginalCol;
+
+			vcg::tri::io::ExporterPLY<BaseMesh>::Save(hlev_mesh,"c:/export_submeshes/FLIPHlev3D.ply",vcg::tri::io::Mask::IOM_VERTCOLOR);
+			for (unsigned int i=0;i<hlev_mesh.vert.size();i++)
+			{
+				hlev_mesh.vert[i].P().X()=hlev_mesh.vert[i].T().U();
+				hlev_mesh.vert[i].P().Y()=hlev_mesh.vert[i].T().V();
+				hlev_mesh.vert[i].P().Z()=0;
+			}
+			vcg::tri::io::ExporterPLY<BaseMesh>::Save(hlev_mesh,"c:/export_submeshes/FLIPHlevUV.ply",vcg::tri::io::Mask::IOM_VERTCOLOR);
+		}
+#endif
+
+		ExecuteFlip(*this->_pos.F(),this->_pos.E(),&m);
+		
+		UpdateTopologies(&m);
+		
+		///stars optimization
+		/*int t0=clock();*/
+		/*OptimizeStar<BaseMesh>(v0);
+		OptimizeStar<BaseMesh>(v1);
+		OptimizeStar<BaseMesh>(v2);
+		OptimizeStar<BaseMesh>(v3);*/
+		
+		SmartOptimizeStar<BaseMesh>(v0,m,Accuracy(),EType());
+		SmartOptimizeStar<BaseMesh>(v1,m,Accuracy(),EType());
+		SmartOptimizeStar<BaseMesh>(v2,m,Accuracy(),EType());
+		SmartOptimizeStar<BaseMesh>(v3,m,Accuracy(),EType());	
+		/*int t1=clock();
+		time_opt+=(t1-t0);*/
+	}
+
+	ScalarType ComputePriority()
+	{
+    this->_priority=EdgeDiff();
+		return this->_priority;
+	}
+
+	BaseFace *getF()
+	{return this->_pos.F();}
+
+	int getE()
+	{return this->_pos.E();}
+
+	public:
+	static int &Accuracy()
+	{
+		static int _acc;
+		return _acc;
+	}
+
+};
+
+#endif
diff --git a/src/meshlabplugins/filter_isoparametrization/param_mesh.h b/src/meshlabplugins/filter_isoparametrization/param_mesh.h
index b4ad05baf..d5118fcf1 100644
--- a/src/meshlabplugins/filter_isoparametrization/param_mesh.h
+++ b/src/meshlabplugins/filter_isoparametrization/param_mesh.h
@@ -1,184 +1,184 @@
-#ifndef PARAM_MESH
-#define PARAM_MESH
-
-// stuff to define the mesh
-#include <vcg/simplex/face/component_rt.h>
-#include <vcg/complex/trimesh/base.h>
-#include "iso_parametrization.h"
-
-class BaseVertex;
-class BaseEdge;    
-class BaseFace;
-
-class BaseUsedTypes: public vcg::UsedTypes < vcg::Use<BaseVertex>::AsVertexType,
-                                          vcg::Use<BaseEdge   >::AsEdgeType,
-                                          vcg::Use<BaseFace  >::AsFaceType >{};
-
-
-///AUXILIARY STRUCTURES USED FOR PARAMETRIZATION COMPUTATION
-class BaseVertex  : public vcg::Vertex< BaseUsedTypes,
-	vcg::vertex::VFAdj, 
-	vcg::vertex::Coord3f, 
-	vcg::vertex::Normal3f, 
-	vcg::vertex::Mark, 
-	vcg::vertex::BitFlags,
-	vcg::vertex::Color4b,
-	vcg::vertex::TexCoord2f>
-{
-public: 
-
-	ScalarType area;
-	CoordType RPos;
-	BaseVertex *brother;
-	BaseFace *father;
-	CoordType Bary;
-	//ScalarType Damp;
-
-	BaseVertex()
-	{
-		brother=NULL;
-		//Damp=1;
-		//num_collapse=1;
-	}
-	
-	static const bool Has_Auxiliary(){return true;}
-
-	vcg::Point2<ScalarType> RestUV;
-	
-	vcg::Color4b OriginalCol;
-	//int num_collapse;
-
-	void ImportData(const BaseVertex  & left )
-  {
-    vcg::Vertex< BaseUsedTypes,
-	vcg::vertex::VFAdj, 
-	vcg::vertex::Coord3f, 
-	vcg::vertex::Normal3f, 
-	vcg::vertex::Mark, 
-	vcg::vertex::BitFlags,
-	vcg::vertex::Color4b,
-	vcg::vertex::TexCoord2f>::ImportData(left);
-
-    this->area=left.area;
-	this->RPos=left.RPos;
-	this->brother=left.brother;
-	this->father=left.father;
-	this->Bary=left.Bary;
-  }
-  
-   template < class LeftV>
-	void ImportData(const LeftV  & left )
-  {
-    vcg::Vertex< BaseUsedTypes,
-	vcg::vertex::VFAdj, 
-	vcg::vertex::Coord3f, 
-	vcg::vertex::Normal3f, 
-	vcg::vertex::Mark, 
-	vcg::vertex::BitFlags,
-	vcg::vertex::Color4b,
-	vcg::vertex::TexCoord2f>::ImportData(left);
-  }
-
-  
-};
-
-///class maintaing additional auxiliary data used during the parameterization
-class AuxiliaryVertData{
-public:
-	BaseVertex::ScalarType area;
-	BaseVertex::CoordType RPos;
-	BaseVertex *brother;
-	BaseFace *father;
-	BaseVertex::CoordType Bary;
-	
-	vcg::Point2<BaseVertex::ScalarType> RestUV;
-	
-	vcg::Color4b OriginalCol;
-
-	AuxiliaryVertData()
-	{brother=NULL;}
-};
-
-class AuxiliaryFaceData
-{
-public:
-	std::vector<std::pair<BaseVertex*,vcg::Point3f> > vertices_bary;
-	typedef std::vector<std::pair<BaseVertex*,vcg::Point3f> >::iterator IteVBary;
-	vcg::Color4b group;
-	BaseVertex::ScalarType areadelta;
-	vcg::Color4b colorDivision;
-};
-
-class BaseFace;
-
-class BaseEdge : public vcg::Edge<BaseUsedTypes,vcg::edge::EVAdj> {
-public:
-	inline BaseEdge() {};
-	inline BaseEdge( BaseVertex * v0, BaseVertex * v1)
-	{
-		V(0)=v0;
-		V(1)=v1;
-	}
-	//EdgeBase<BaseVertex,BaseEdge,BaseFace>(v0,v1){};
-	static inline BaseEdge OrderedEdge(BaseVertex* v0,BaseVertex* v1){
-		if(v0<v1) return BaseEdge(v0,v1);
-		else return BaseEdge(v1,v0);
-	}
-};
-
-
-class BaseFace    : public vcg::Face  < BaseUsedTypes,
-	vcg::face::VFAdj, 
-	vcg::face::FFAdj,
-	vcg::face::VertexRef, 
-	vcg::face::BitFlags,
-	vcg::face::EdgePlane,
-	vcg::face::Mark,
-	vcg::face::Normal3f,
-	vcg::face::Color4b>
-{
-public:
-	std::vector<std::pair<BaseVertex*,vcg::Point3f> > vertices_bary;
-	typedef std::vector<std::pair<BaseVertex*,vcg::Point3f> >::iterator IteVBary;
-	vcg::Color4b group;
-	ScalarType areadelta;
-	vcg::Color4b colorDivision;
-
-   template < class LeftV>
-	void ImportData(const LeftV  & left )
-  {
-    vcg::Face  < BaseUsedTypes,
-	vcg::face::VFAdj, 
-	vcg::face::FFAdj,
-	vcg::face::VertexRef, 
-	vcg::face::BitFlags,
-	vcg::face::EdgePlane,
-	vcg::face::Mark,
-	vcg::face::Normal3f,
-	vcg::face::Color4b>::ImportData(left);
-  }
-	
-	void ImportData(const BaseFace  & left )
-  {
-    vcg::Face  < BaseUsedTypes,
-	vcg::face::VFAdj, 
-	vcg::face::FFAdj,
-	vcg::face::VertexRef, 
-	vcg::face::BitFlags,
-	vcg::face::EdgePlane,
-	vcg::face::Mark,
-	vcg::face::Normal3f,
-	vcg::face::Color4b>::ImportData(left);
-    this->vertices_bary = std::vector<std::pair<BaseVertex*,vcg::Point3f> > (left.vertices_bary);
-	this->group=left.group;
-	this->areadelta=left.areadelta;
-	this->colorDivision=left.colorDivision;
-  }
-
- 
-};              
-
-/// the main mesh class 
-class BaseMesh: public vcg::tri::TriMesh<std::vector<BaseVertex>, std::vector<BaseFace> > {};
-
-#endif
+#ifndef PARAM_MESH
+#define PARAM_MESH
+
+// stuff to define the mesh
+#include <vcg/simplex/face/component_rt.h>
+#include <vcg/complex/complex.h>
+#include "iso_parametrization.h"
+
+class BaseVertex;
+class BaseEdge;    
+class BaseFace;
+
+class BaseUsedTypes: public vcg::UsedTypes < vcg::Use<BaseVertex>::AsVertexType,
+                                          vcg::Use<BaseEdge   >::AsEdgeType,
+                                          vcg::Use<BaseFace  >::AsFaceType >{};
+
+
+///AUXILIARY STRUCTURES USED FOR PARAMETRIZATION COMPUTATION
+class BaseVertex  : public vcg::Vertex< BaseUsedTypes,
+	vcg::vertex::VFAdj, 
+	vcg::vertex::Coord3f, 
+	vcg::vertex::Normal3f, 
+	vcg::vertex::Mark, 
+	vcg::vertex::BitFlags,
+	vcg::vertex::Color4b,
+	vcg::vertex::TexCoord2f>
+{
+public: 
+
+	ScalarType area;
+	CoordType RPos;
+	BaseVertex *brother;
+	BaseFace *father;
+	CoordType Bary;
+	//ScalarType Damp;
+
+	BaseVertex()
+	{
+		brother=NULL;
+		//Damp=1;
+		//num_collapse=1;
+	}
+	
+	static const bool Has_Auxiliary(){return true;}
+
+	vcg::Point2<ScalarType> RestUV;
+	
+	vcg::Color4b OriginalCol;
+	//int num_collapse;
+
+	void ImportData(const BaseVertex  & left )
+  {
+    vcg::Vertex< BaseUsedTypes,
+	vcg::vertex::VFAdj, 
+	vcg::vertex::Coord3f, 
+	vcg::vertex::Normal3f, 
+	vcg::vertex::Mark, 
+	vcg::vertex::BitFlags,
+	vcg::vertex::Color4b,
+	vcg::vertex::TexCoord2f>::ImportData(left);
+
+    this->area=left.area;
+	this->RPos=left.RPos;
+	this->brother=left.brother;
+	this->father=left.father;
+	this->Bary=left.Bary;
+  }
+  
+   template < class LeftV>
+	void ImportData(const LeftV  & left )
+  {
+    vcg::Vertex< BaseUsedTypes,
+	vcg::vertex::VFAdj, 
+	vcg::vertex::Coord3f, 
+	vcg::vertex::Normal3f, 
+	vcg::vertex::Mark, 
+	vcg::vertex::BitFlags,
+	vcg::vertex::Color4b,
+	vcg::vertex::TexCoord2f>::ImportData(left);
+  }
+
+  
+};
+
+///class maintaing additional auxiliary data used during the parameterization
+class AuxiliaryVertData{
+public:
+	BaseVertex::ScalarType area;
+	BaseVertex::CoordType RPos;
+	BaseVertex *brother;
+	BaseFace *father;
+	BaseVertex::CoordType Bary;
+	
+	vcg::Point2<BaseVertex::ScalarType> RestUV;
+	
+	vcg::Color4b OriginalCol;
+
+	AuxiliaryVertData()
+	{brother=NULL;}
+};
+
+class AuxiliaryFaceData
+{
+public:
+	std::vector<std::pair<BaseVertex*,vcg::Point3f> > vertices_bary;
+	typedef std::vector<std::pair<BaseVertex*,vcg::Point3f> >::iterator IteVBary;
+	vcg::Color4b group;
+	BaseVertex::ScalarType areadelta;
+	vcg::Color4b colorDivision;
+};
+
+class BaseFace;
+
+class BaseEdge : public vcg::Edge<BaseUsedTypes,vcg::edge::EVAdj> {
+public:
+	inline BaseEdge() {};
+	inline BaseEdge( BaseVertex * v0, BaseVertex * v1)
+	{
+		V(0)=v0;
+		V(1)=v1;
+	}
+	//EdgeBase<BaseVertex,BaseEdge,BaseFace>(v0,v1){};
+	static inline BaseEdge OrderedEdge(BaseVertex* v0,BaseVertex* v1){
+		if(v0<v1) return BaseEdge(v0,v1);
+		else return BaseEdge(v1,v0);
+	}
+};
+
+
+class BaseFace    : public vcg::Face  < BaseUsedTypes,
+	vcg::face::VFAdj, 
+	vcg::face::FFAdj,
+	vcg::face::VertexRef, 
+	vcg::face::BitFlags,
+	vcg::face::EdgePlane,
+	vcg::face::Mark,
+	vcg::face::Normal3f,
+	vcg::face::Color4b>
+{
+public:
+	std::vector<std::pair<BaseVertex*,vcg::Point3f> > vertices_bary;
+	typedef std::vector<std::pair<BaseVertex*,vcg::Point3f> >::iterator IteVBary;
+	vcg::Color4b group;
+	ScalarType areadelta;
+	vcg::Color4b colorDivision;
+
+   template < class LeftV>
+	void ImportData(const LeftV  & left )
+  {
+    vcg::Face  < BaseUsedTypes,
+	vcg::face::VFAdj, 
+	vcg::face::FFAdj,
+	vcg::face::VertexRef, 
+	vcg::face::BitFlags,
+	vcg::face::EdgePlane,
+	vcg::face::Mark,
+	vcg::face::Normal3f,
+	vcg::face::Color4b>::ImportData(left);
+  }
+	
+	void ImportData(const BaseFace  & left )
+  {
+    vcg::Face  < BaseUsedTypes,
+	vcg::face::VFAdj, 
+	vcg::face::FFAdj,
+	vcg::face::VertexRef, 
+	vcg::face::BitFlags,
+	vcg::face::EdgePlane,
+	vcg::face::Mark,
+	vcg::face::Normal3f,
+	vcg::face::Color4b>::ImportData(left);
+    this->vertices_bary = std::vector<std::pair<BaseVertex*,vcg::Point3f> > (left.vertices_bary);
+	this->group=left.group;
+	this->areadelta=left.areadelta;
+	this->colorDivision=left.colorDivision;
+  }
+
+ 
+};              
+
+/// the main mesh class 
+class BaseMesh: public vcg::tri::TriMesh<std::vector<BaseVertex>, std::vector<BaseFace> > {};
+
+#endif
diff --git a/src/meshlabplugins/filter_isoparametrization/parametrizator.h b/src/meshlabplugins/filter_isoparametrization/parametrizator.h
index 1ae81b060..25593df32 100644
--- a/src/meshlabplugins/filter_isoparametrization/parametrizator.h
+++ b/src/meshlabplugins/filter_isoparametrization/parametrizator.h
@@ -1,1277 +1,1277 @@
-#ifndef _PARAMETRIZATOR
-#define _PARAMETRIZATOR
-
-#include <defines.h>
-
-
-#include <param_collapse.h>
-#include <param_flip.h>
-
-
-#include <param_mesh.h>
-#include <iso_parametrization.h>
-
-///auxiliary structures
-
-#include <vcg/complex/trimesh/clean.h>
-#include <vcg/complex/trimesh/allocate.h>
-#include <vcg/complex/trimesh/append.h>
-#include <vcg/complex/trimesh/update/topology.h>
-#include <vcg/complex/trimesh/update/bounding.h>
-
-// update topology
-#include <vcg/complex/trimesh/update/normal.h>
-#include <vcg/complex/trimesh/update/edges.h>
-#include <vcg/complex/trimesh/update/flag.h>
-
-
-// local optimization
-#include <vcg/complex/local_optimization.h>
-
-
-#include <local_parametrization.h>
-#include <mesh_operators.h>
-#include <vcg/space/color4.h>
-#include <dual_coord_optimization.h>
-#include <float.h>
-#include <lm.h>
-#ifndef _MESHLAB
-#include <wrap/io_trimesh/export_ply.h>
-#endif
-//#include <EquilaterizeMesh.h>
-
-#include <opt_patch.h>
-#include <local_optimization.h>
-#include <statistics.h>
-#include <stat_remeshing.h>
-
-//extern int step_global;
-//
-//int time_opt;
-
-///Flip function
-class MyTriEdgeFlip : public ParamEdgeFlip<BaseMesh>{};
-class MyTriEdgeCollapse: public ParamEdgeCollapse<BaseMesh>{};
-
-///THIS CLASS MAINTAINS STRUCTURES WICH ARE USED FOR PARAMETRIZATION
-///TOGHETHER WITH METHOD FOR COLORIZATION FOR VISUALIZATION PURPOSES
-
-class IsoParametrizator{
-
-public:
-	 enum ReturnCode{MultiComponent,
-													NonSizeCons,
-													NonManifoldE,
-													NonManifoldV,
-													NonWatertigh,
-													FailParam,Done};
-	
-
-	BaseMesh final_mesh;
-	BaseMesh base_mesh;
-	typedef BaseMesh::ScalarType ScalarType;
-	typedef BaseMesh::CoordType CoordType;
-	vcg::CallBackPos *cb;
-	EnergyType EType;
-private:
-	
-	void InitVoronoiArea()
-	{
-		///area deviation respect to original
-		for (unsigned int i=0;i<base_mesh.face.size();i++)
-			base_mesh.face[i].areadelta=0;
-
-		for (unsigned int i=0;i<final_mesh.vert.size();i++)
-			final_mesh.vert[i].area=0;
-
-		for (unsigned int i=0;i<final_mesh.face.size();i++)
-		{
-			BaseFace *f=&final_mesh.face[i];
-			ScalarType areaf=vcg::DoubleArea(*f)/2.0;//(((f->V(1)->P()-f->V(0)->P())^(f->V(2)->P()-f->V(0)->P())).Norm())/2.0;
-			f->V(0)->area+=areaf/(ScalarType)3.0;
-			f->V(1)->area+=areaf/(ScalarType)3.0;
-			f->V(2)->area+=areaf/(ScalarType)3.0;
-		}
-	}
-
-	template <class MeshType>
-	void InitializeStructures(MeshType *mesh)
-	{
-		///cleaning of initial mesh
-		/*int dup = */vcg::tri::Clean<MeshType>::RemoveDuplicateVertex(*mesh);
-		/*int unref =  */vcg::tri::Clean<MeshType>::RemoveUnreferencedVertex(*mesh);
-
-		vcg::tri::Allocator<MeshType>::CompactFaceVector(*mesh);
-		vcg::tri::Allocator<MeshType>::CompactVertexVector(*mesh);
-
-		///copy
-		base_mesh.Clear();
-		final_mesh.Clear();
-		vcg::tri::Append<BaseMesh,MeshType>::Mesh(base_mesh,*mesh);
-		vcg::tri::Append<BaseMesh,MeshType>::Mesh(final_mesh,*mesh);
-
-		///update auxiliary structures
-		UpdateStructures(&base_mesh);
-		UpdateStructures(&final_mesh);
-		vcg::tri::UpdateTopology<BaseMesh>::TestFaceFace(base_mesh);
-		vcg::tri::UpdateTopology<BaseMesh>::TestFaceFace(final_mesh);
-
-		///initialization of statistics
-		//stat.Init(&base_mesh,&final_mesh);
-
-		///copy original color
-		for (unsigned int i=0;i<final_mesh.vert.size();i++)
-			final_mesh.vert[i].OriginalCol=final_mesh.vert[i].C();
-		
-		///set brother vertices and default father
-		/*unsigned int i=0;*/
-		for (unsigned int i=0;i<base_mesh.vert.size();i++)
-		{
-			base_mesh.vert[i].brother=&final_mesh.vert[i];
-			base_mesh.vert[i].RPos=base_mesh.vert[i].P();
-		}
-
-		/*///area deviation respect to original
-		for (unsigned int i=0;i<base_mesh.face.size();i++)
-			base_mesh.face[i].areadelta=0;
-
-		for (unsigned int i=0;i<final_mesh.vert.size();i++)
-			final_mesh.vert[i].area=0;*/
-		
-		for (unsigned int i=0;i<base_mesh.vert.size();i++){
-			base_mesh.vert[i].brother=&final_mesh.vert[i];
-			//final_mesh.vert[i].father=base_mesh.vert[i].VFp();
-			//assert(!base_mesh.vert[i].VFp()->IsD());
-			CoordType bary=CoordType(0,0,0);
-			bary.V(base_mesh.vert[i].VFi())=1;
-			//final_mesh.vert[i].Bary=bary;
-			AssingFather(final_mesh.vert[i],base_mesh.vert[i].VFp(),bary,base_mesh);
-		}
-
-		///initialize area per vertex
-	
-		for (unsigned int i=0;i<final_mesh.vert.size();i++){
-			BaseFace* father=final_mesh.vert[i].father;
-			CoordType bary=final_mesh.vert[i].Bary;
-			father->vertices_bary.push_back(std::pair<BaseVertex*,vcg::Point3f>(&final_mesh.vert[i],bary));
-		}
-
-		///testing everithing is ok
-		for (unsigned int i=0;i<final_mesh.vert.size();i++)
-		{
-			final_mesh.vert[i].RPos=final_mesh.vert[i].P();
-			CoordType test=ProjectPos(final_mesh.vert[i]);
-			assert((test-final_mesh.vert[i].P()).Norm()<0.000001);
-		}	
-
-		////initialization for decimation
-		//base_mesh.en=0;
-		InitIMark();
-		for (unsigned int i=0;i<base_mesh.vert.size();i++)
-			base_mesh.vert[i].ClearFlags();
-		for (unsigned int i=0;i<base_mesh.face.size();i++)
-			base_mesh.face[i].ClearFlags();
-		InitVoronoiArea();
-	}
-
-	void InitIMark()
-	{
-    vcg::tri::IMark(base_mesh)=0;
-    vcg::tri::InitFaceIMark(base_mesh);
-    vcg::tri::InitVertexIMark(base_mesh);
-	}
-	
-
-	void ParaDecimate(const int &targetFaces,
-					  const int &interval,
-					  bool execute_flip=false)
-	{
-		vcg::LocalOptimization<BaseMesh> DeciSession(base_mesh);
-		DeciSession.Init<MyTriEdgeCollapse >();
-		MyTriEdgeCollapse::Accuracy()=accuracy;
-		MyTriEdgeCollapse::HresMesh()=&final_mesh;
-		PatchesOptimizer<BaseMesh>::HresMesh()=&final_mesh;
-		PatchesOptimizer<BaseMesh>::BaseMesh()=&base_mesh;
-
-		MyTriEdgeFlip::Accuracy()=accuracy;
-		
-		int flip_todo=4;
-		int next_flip_num=targetFaces;
-		std::vector<int> stop_points;
-
-		if (execute_flip)
-		{
-			stop_points.resize(flip_todo+2);///number of flips + save stack point + final stop
-
-			for (int i=0;i<flip_todo;i++)
-			{
-				next_flip_num=(int)((ScalarType)next_flip_num*flip_factor);
-				stop_points[i]=next_flip_num;
-			}	
-			stop_points[flip_todo]=targetFaces+interval;
-			stop_points[flip_todo+1]=targetFaces;
-			std::sort(stop_points.begin(),stop_points.end());
-		}
-		else
-		{
-			stop_points.resize(2);
-			stop_points[0]=targetFaces;
-			stop_points[1]=targetFaces+interval;
-		}
-
-		///find the point where save stack is defined 
-		int pos_stack=-1;
-		for (unsigned int i=0;i<stop_points.size();i++)
-		{
-			if (stop_points[i]==(targetFaces+interval))
-				pos_stack=i;
-		}
-		
-
-		assert(pos_stack!=-1);
-
-		bool do_flip=false;
-		bool save_status=false;
-		int curr_limit=stop_points.size()-1;
-		bool not_heap_empty=true;
-		//bool check_status=false;
-		while ((base_mesh.fn>targetFaces)&&(not_heap_empty))
-		{
-			do_flip=false;
-
-			int curr_num=base_mesh.fn;
-				
-			int next_num;
-			if (!save_status)
-				next_num=curr_num-1000;
-			else
-				next_num=curr_num-2;
-			
-			if ((curr_limit>=0)&&(next_num<stop_points[curr_limit]))
-			{
-				next_num=stop_points[curr_limit];
-				
-				if (curr_limit==pos_stack)
-					save_status=true;
-				else
-				if ((curr_limit!=0)&&(execute_flip))
-					do_flip=true;
-
-				curr_limit--;
-			}
-			
-		
-
-			DeciSession.SetTargetSimplices(next_num);
-			not_heap_empty=DeciSession.DoOptimization();
-
-		
-
-			if (do_flip)
-			{
-				FlipStep();
-				vcg::tri::UpdateTopology<BaseMesh>::FaceFace(base_mesh);
-				vcg::tri::UpdateTopology<BaseMesh>::VertexFace(base_mesh);
-				InitIMark();
-				DeciSession.h.clear();
-				DeciSession.Init<MyTriEdgeCollapse >();
-				if (flip_todo>0)
-				{
-					next_flip_num=(int)(((ScalarType)next_flip_num)/flip_factor);
-					flip_todo--;
-				}
-			}
-			/*#ifndef _MESHLAB
-			
-			#endif*/
-			PrintAttributes();
-			if (save_status)
-			{
-				#ifndef _MESHLAB
-				printf("SAVING CURRENT STATUS....face_num: %d\n",curr_num);
-				#endif
-				SaveCurrentStatus();
-				InitIMark();
-				DeciSession.h.clear();
-				DeciSession.Init<MyTriEdgeCollapse >();
-			}
-			
-			testParametrization<BaseMesh>(base_mesh,final_mesh);
-			
-		}
-
-		
-	}
-
-	///ASSOCIATE SURVIVED VERTEX FROM DECIMATION
-	void AssociateRemaining()
-	{
-		printf("\n ASSOCIATE REMAINING \n");
-		for (unsigned int i=0;i<base_mesh.vert.size();i++)
-			if (base_mesh.vert[i].brother!=NULL)
-			{
-				BaseVertex* v=&base_mesh.vert[i];
-				BaseVertex* vb=v->brother;
-				vcg::face::VFIterator<BaseFace> vfi2(v);
-				///take the face that has lower number of vertices
-				BaseFace *fmin=vfi2.F();
-				int index=vfi2.I();
-        size_t sizeMin=fmin->vertices_bary.size();
-				while (!vfi2.End())
-				{
-					BaseFace *f=vfi2.F();
-					if (f->vertices_bary.size()<sizeMin)
-					{
-						sizeMin=f->vertices_bary.size();
-						fmin=f;
-						index=vfi2.I();
-					}
-          ++vfi2;
-				}
-				CoordType bary=CoordType(0,0,0);
-				bary[index]=1.f;
-				fmin->vertices_bary.push_back(std::pair<BaseVertex*,vcg::Point3f>(vb,bary));
-				AssingFather(*vb,fmin,bary,base_mesh);
-				/*vb->father=f;
-				assert(!f->IsD());
-				vb->Bary=bary;*/
-				v->brother=NULL;
-			}
-	}
-
-	struct vert_para
-		{
-			ScalarType dist;
-			BaseVertex *v;
-      bool operator <(const vert_para &other) const
-			{return (dist>other.dist);}
-		};
-
-	void FinalOptimization()
-	{
-		char ret[200];
-		sprintf(ret," PERFORM GLOBAL OPTIMIZATION initializing... ");
-		(*cb)(0,ret);
-
-		
-
-		std::vector<vert_para> ord_vertex;
-		ord_vertex.resize(base_mesh.vn);
-		for (unsigned int i=0;i<base_mesh.vert.size();i++)
-			if (!base_mesh.vert[i].IsD())
-			{
-				BaseVertex *v=&base_mesh.vert[i];
-				ScalarType val=StarDistorsion<BaseMesh>(&base_mesh.vert[i]);
-				//printf("i: %d\n",i);
-				ord_vertex[i].dist=val;
-				ord_vertex[i].v=v;
-			}
-		
-		std::sort(ord_vertex.begin(),ord_vertex.end());
-		for (unsigned int i=0;i<ord_vertex.size();i++)
-		{
-				printf("%3.3f\n",ord_vertex[i].dist);
-				SmartOptimizeStar<BaseMesh>(ord_vertex[i].v,base_mesh,MyTriEdgeCollapse::Accuracy(),EType);
-		}	
-	}
-
-
-	template <class MeshType>
-	ReturnCode InitBaseMesh(MeshType *mesh,
-		const int &targetFaces,
-		const int &interval,
-		bool execute_flip=true,
-		bool test_interpolation=true)
-	{
-    vcg::tri::UpdateFlags<MeshType>::VertexClearV(*mesh);
-    vcg::tri::UpdateFlags<MeshType>::FaceClearV(*mesh);
-
-    ///TEST PRECONDITIONS
-    ReturnCode ret=Preconditions(*mesh);
-		
-    if (ret!=Done) return ret;
-
-		///INITIALIZATION
-		InitializeStructures<MeshType>(mesh);
-		
-		///DECIMATION & PARAMETRIZATION
-		ParaDecimate(targetFaces,interval,execute_flip);
-
-		///SET BEST FIND STOP POINT
-		bool isOK=SetBestStatus(test_interpolation);
-		if ((!isOK)&&(test_interpolation))
-			return FailParam;
-
-		///THEN CLEAR STACK
-		ClearStack();
-
-		///LAST FLIP STEP
-		if (execute_flip)
-			FlipStep();
-
-		vcg::tri::UpdateTopology<BaseMesh>::FaceFace(base_mesh);
-		vcg::tri::UpdateTopology<BaseMesh>::VertexFace(base_mesh);
-		vcg::tri::UpdateTopology<BaseMesh>::TestVertexFace(base_mesh); ///TEST
-
-		UpdateStructures(&base_mesh);
-		#ifndef _MESHLAB
-		if (execute_flip)
-		{
-			printf("\n POST LAST FLIP: \n");
-			PrintAttributes();
-		}
-		#endif
-		
-		///ASSOCIATE REMAINING VERTICES TO ONE FACE
-		AssociateRemaining();
-		
-		///LAST OPTIMIZATION STEP ON STARS
-		if (execute_flip)
-			FinalOptimization();
-
-		#ifndef _MESHLAB	
-		if (execute_flip)
-		{
-			printf("\n POST STAR OPT: \n");
-			PrintAttributes();
-		}
-		#endif
-		return Done;
-	}
-
-	void CompactBaseDomain()
-	{
-		/*testParametrization<BaseMesh>(base_mesh,final_mesh);
-		system("pause");*/
-		vcg::tri::Allocator<BaseMesh>::CompactVertexVector(base_mesh);
-		vcg::tri::Allocator<BaseMesh>::CompactFaceVector(base_mesh);
-		UpdateStructures(&base_mesh);
-		///reassing
-		//for (int i=0;i<(int)base_mesh.face.size();i++)
-		for (int i=0;i<(int)base_mesh.face.size();i++)
-		{
-			int size=base_mesh.face[i].vertices_bary.size();
-			/*assert(size>0);*/
-			for (int j=0;j<size;j++)
-			{
-				BaseVertex* son=base_mesh.face[i].vertices_bary[j].first;
-				CoordType bary=base_mesh.face[i].vertices_bary[j].second;
-				/*son->father=&base_mesh.face[i];
-				assert(!base_mesh.face[i].IsD());
-				son->Bary=bary;*/
-				AssingFather(*son,&base_mesh.face[i],bary,base_mesh);
-			}
-		}
-		/*testParametrization<BaseMesh>(base_mesh,final_mesh);
-		system("pause");*/
-	}
-
-	///save the current status of the parameterization
-	void SaveCurrentStatus()
-	{
-		///copy
-		ParaStack.push_back(ParaInfo());
-		ParaStack.back().AbsMesh=new BaseMesh();
-		BaseMesh *mesh=ParaStack.back().AbsMesh;
-		CompactBaseDomain();
-
-		vcg::tri::Append<BaseMesh,BaseMesh>::Mesh(*mesh,base_mesh);
-
-	
-		for (unsigned int i=0;i<base_mesh.vert.size();i++)
-				mesh->vert[i].RPos=base_mesh.vert[i].RPos;
-		
-		///copy linking for parameterization informations
-		int k=0;
-		for (unsigned int i=0;i<base_mesh.face.size();i++)
-		{
-			if (!base_mesh.face[i].IsD())
-			{
-				int size=base_mesh.face[i].vertices_bary.size();
-				mesh->face[k].vertices_bary.resize(size);
-				for (int j=0;j<size;j++)
-				{
-					mesh->face[k].vertices_bary[j].first=base_mesh.face[i].vertices_bary[j].first;
-					mesh->face[k].vertices_bary[j].second=base_mesh.face[i].vertices_bary[j].second;
-				}
-				k++;
-			}
-		}
-		//ParaStack.push_back(ParaInfo());
-		/*ParaStack.back().AbsMesh=mesh;*/
-		ScalarType valL2=ApproxL2Error(final_mesh);
-		ParaStack.back().L2=valL2;
-		ScalarType val0=ApproxAreaDistortion<BaseMesh>(final_mesh,mesh->fn);
-		ParaStack.back().AreaDist=val0;
-		ScalarType val1=ApproxAngleDistortion<BaseMesh>(final_mesh);
-		ParaStack.back().AngleDist=val1;
-		ParaStack.back().AggrDist=geomAverage<ScalarType>(val0+(ScalarType)1.0,val1+(ScalarType)1.0,3,1)-(ScalarType)1;
-		ParaStack.back().Regular=NumRegular<BaseMesh>(*mesh);
-		//ParaStack.back().distorsion=geomAverage<double>(val0,val1,3,1);
-		ScalarType val2=ParaStack.back().AggrDist;
-		ParaStack.back().num_faces=mesh->fn;
-		ParaStack.back().ratio=val2*sqrt((ScalarType)mesh->fn);
-	}
-
-	void RestoreStatus(const int &index_status)
-	{
-		///delete current base mesh
-		base_mesh.Clear();
-		BaseMesh *to_restore=ParaStack[index_status].AbsMesh;
-	
-		///restore saved abstract mesh and link
-		vcg::tri::Append<BaseMesh,BaseMesh>::Mesh(base_mesh,*to_restore);
-		for (unsigned int i=0;i<to_restore->face.size();i++)
-		{
-			int size=to_restore->face[i].vertices_bary.size();
-			base_mesh.face[i].vertices_bary.resize(size);
-			for (int j=0;j<size;j++)
-			{
-				BaseVertex * vert=to_restore->face[i].vertices_bary[j].first;
-				CoordType bary=to_restore->face[i].vertices_bary[j].second;
-#ifdef _DEBUG
-				bool done=NormalizeBaryCoords(bary);
-				assert(done);
-#else
-				NormalizeBaryCoords(bary);
-#endif
-				base_mesh.face[i].vertices_bary[j].first=vert;
-				base_mesh.face[i].vertices_bary[j].second=bary;
-
-				AssingFather(*vert,&base_mesh.face[i],bary,base_mesh);
-
-				//vert->father=&base_mesh.face[i];
-				//assert(!base_mesh.face[i].IsD());
-				//vert->Bary=bary;
-			}
-		}
-		UpdateTopologies<BaseMesh>(&base_mesh);
-
-		///copy rest pos
-		for (unsigned int i=0;i<to_restore->vert.size();i++)
-		{
-			base_mesh.vert[i].RPos=to_restore->vert[i].RPos;
-			base_mesh.vert[i].P()=to_restore->vert[i].P();
-		}
-		/*///clear stack of meshes
-		ClearStack();*/
-	}
-
-	///clear the durrent stack
-	void ClearStack()
-	{
-		for (unsigned int i=0;i<ParaStack.size();i++)
-			delete(ParaStack[i].AbsMesh);
-		ParaStack.clear();
-	}
-
-	ScalarType GetStatusVal(const int &index)
-	{
-		switch (SMode)
-		{
-		case (SM_Area): return ParaStack[index].AreaDist;
-			break;
-		case (SM_Angle):return ParaStack[index].AngleDist;
-			break;
-		case (SM_Corr):return ParaStack[index].AggrDist;
-			break;
-		case (SM_Reg):return (ScalarType)ParaStack[index].Regular;
-			break;
-		case (SM_Smallest):return (ScalarType)ParaStack[index].num_faces;
-			break;
-		case (SM_L2):return ParaStack[index].L2;
-			break;
-		default:return ParaStack[index].ratio;
-			break;
-		}
-	}
-	
-	///return true if possible to construct an Isoparametrization
-	bool TestInterpolation()
-	{
-			ParamMesh para_mesh1;
-			AbstractMesh abs_mesh1;
-			ExportMeshes(para_mesh1,abs_mesh1);
-		
-			///constrauct an ISOPARAM
-			IsoParametrization IsoParam1;
-			return(IsoParam1.Init(&abs_mesh1,&para_mesh1));
-	}
-
-	///set the best value considering the ratio value
-	bool SetBestStatus(bool test_interpolation)
-	{
-		std::sort(ParaStack.begin(),ParaStack.end());
-		int indexmin=0;
-		bool isOK_interp;
-
-		if (test_interpolation)
-			isOK_interp=false;
-		else
-			isOK_interp=true;
-
-		RestoreStatus(indexmin);
-		if (test_interpolation)
-		{
-			while ((!isOK_interp)&&(indexmin<(int)ParaStack.size()))
-			{
-				isOK_interp=TestInterpolation();
-				if (!isOK_interp)
-				{
-					indexmin++;
-					if (indexmin<(int)ParaStack.size())
-						RestoreStatus(indexmin);
-				}
-			}	
-		} 
-
-		///clear stack of meshes
-	
-
-		
-#ifndef _MESHLAB
-		for (unsigned int i=0;i<ParaStack.size();i++)
-		{
-
-			printf("faces %d, Area %.4f, Angle %.4f, Corr %.4f, non Reg %d,L2 %.4f,Heuristic %.4f\n",
-				ParaStack[i].num_faces,
-				ParaStack[i].AreaDist,
-				ParaStack[i].AngleDist,
-				ParaStack[i].AggrDist,
-				ParaStack[i].Regular,
-				ParaStack[i].L2,
-				ParaStack[i].ratio);
-		}
-		if ((isOK_interp)||(!test_interpolation))
-			printf("Choosen to stop at %d faces \n",ParaStack[indexmin].num_faces);
-		else
-			printf("Not a right Interpolation Domain is found");
-#endif
-		
-		ClearStack();
-		isOK_interp=TestInterpolation();
-		return (isOK_interp);
-	}
-
-public:
-
-	enum StopMode{
-		SM_Euristic,
-		SM_Area,
-		SM_Angle,
-		SM_Corr,
-		SM_Reg,
-		SM_Smallest,
-		SM_L2
-	};
-
-	///parameters
-	StopMode SMode;
-	int lower_limit;
-	int interval;
-	int accuracy;
-	//edn parameters
-
-	MyTriEdgeCollapse *next_oper; 
-	MyTriEdgeFlip *next_flip;
-	BaryOptimizatorDual<BaseMesh> *BaryOptDemo;
-	vcg::LocalOptimization<BaseMesh> *FlipSession;
-	
-	int TimeStepDeci,TimeStepFlip;
-
-	struct ParaInfo
-	{
-		ScalarType AggrDist;
-		ScalarType AreaDist;
-		ScalarType AngleDist;
-		int Regular;
-		int num_faces;
-		ScalarType ratio;
-		ScalarType L2;
-		BaseMesh * AbsMesh;
-
-		static StopMode& SM()
-		{
-			static StopMode S;
-			return S;
-		}
-
-    inline bool operator < (const ParaInfo &P_info) const{
-			switch (SM())
-			{
-			case (SM_Area): return AreaDist<P_info.AreaDist;
-				break;
-			case (SM_Angle):return AngleDist<P_info.AngleDist;
-				break;
-			case (SM_Corr):return AggrDist<P_info.AggrDist;
-				break;
-			case (SM_Reg):return Regular<P_info.Regular;
-				break;
-			case (SM_Smallest):return num_faces<P_info.num_faces;
-				break;
-			case (SM_L2):return L2<P_info.L2;
-				break;
-			default:return ratio<P_info.ratio;
-				break;
-			}
-		}
-
-	};
-
-	std::vector<ParaInfo> ParaStack;
-
-	///PRECONDITIONS
-	template <class MeshType>
-	ReturnCode Preconditions(MeshType &mesh)
-	{
-		bool b;
-		vcg::tri::UpdateTopology<MeshType>::FaceFace(mesh);
-    if(vcg::tri::Clean<MeshType>::CountNonManifoldEdgeFF(mesh)>0 ) return NonManifoldE;
-    if(vcg::tri::Clean<MeshType>::CountNonManifoldVertexFF(mesh)>0 ) return NonManifoldV;
-
-		b=vcg::tri::Clean<MeshType>::IsSizeConsistent(mesh);
-		if (!b)	return NonSizeCons;
-
-    int cc=vcg::tri::Clean<MeshType>::CountConnectedComponents(mesh);
-    if(cc>1) return MultiComponent;
-
-    int boundaryEdgeNum, internalEdgeNum;
-    vcg::tri::Clean<MeshType>::CountEdges(mesh,internalEdgeNum,boundaryEdgeNum);
-    if(boundaryEdgeNum>0) return NonWatertigh;
-
-		return Done;
-	}
-
-	///perform a global optimization step
-	void GlobalOptimizeStep()
-	{
-#ifndef _MESHLAB
-	  printf("\n GLOBAL OPTIMIZATION \n");
-#endif
-	  BaryOptimizatorDual<BaseMesh> BaryOpt;
-	  BaryOpt.Init(base_mesh,final_mesh,cb,accuracy,EType);
-	  BaryOpt.Optimize(4.0/(double)accuracy,accuracy*4);
-#ifndef _MESHLAB
-	  printf("\n POST DUAL OPT:	\n");
-	  PrintAttributes();
-#endif
-	}
-
-	template <class MeshType>
-	void ScaleMesh(MeshType &m,
-								 const ScalarType &factor)
-	{
-    for (size_t i=0;i<m.vert.size();i++)
-			if (!m.vert[i].IsD())
-				m.vert[i].P()*=factor;
-	}
-	
-	template <class MeshType>
-	void TranslateMesh(MeshType &m,const typename MeshType::CoordType &vect)
-	{
-    for (size_t i=0;i<m.vert.size();i++)
-			if (!m.vert[i].IsD())
-				m.vert[i].P()+=vect;
-	}
-
-	///PARAMETRIZATION FUNCTIONS 
-	///initialize the mesh 
-	template <class MeshType>
-	ReturnCode Parametrize(MeshType *mesh,bool Two_steps=true,EnergyType _EType=EN_EXTMips)
-	{		
-		EType=_EType;
-		MyTriEdgeCollapse::EType()=EType;
-		MyTriEdgeFlip::EType()=EType;
-
-		///clean unreferenced vertices
-		vcg::tri::Clean<MeshType>::RemoveUnreferencedVertex(*mesh);
-		/*bool done;*/
-		const int limit0=15000;//00;
-		const int limit1=30000;
-		
-		vcg::tri::UpdateBounding<MeshType>::Box(*mesh);
-		ScalarType factor=100.0/mesh->bbox.Diag();
-		CoordType transl=-mesh->bbox.Center();
-		TranslateMesh(*mesh,transl);
-		ScaleMesh(*mesh,factor);
-		if ((!Two_steps)||(lower_limit>limit0)||(mesh->fn<limit1))
-		{
-			ReturnCode res=InitBaseMesh<MeshType>(mesh,lower_limit,interval,true,true);	
-			ScaleMesh(*mesh,1.0/factor);
-			TranslateMesh(*mesh,-transl);
-			if (res!=Done)
-				return res;
-		}
-		else
-		{
-			///do a first parametrization step
-			printf("\n STEP 1 \n");
-			InitVoronoiArea();
-			ReturnCode res=InitBaseMesh<MeshType>(mesh,limit0,1,false,false);
-			ScaleMesh(*mesh,1.0/factor);
-			TranslateMesh(*mesh,-transl);
-			if (res!=Done)
-				return res;
-
-			ParamMesh para_mesh0;
-			AbstractMesh abs_mesh0;
-			//AbstractMesh abs_mesh_test;
-			ExportMeshes(para_mesh0,abs_mesh0);
-
-			printf("\n STEP 2 \n");
-			res=InitBaseMesh<AbstractMesh>(&abs_mesh0,lower_limit,interval,true,true);
-			if (res!=Done)
-				return res;
-			
-			
-			ParamMesh para_mesh1;
-			AbstractMesh abs_mesh1;
-			ExportMeshes(para_mesh1,abs_mesh1);
-
-			
-
-			///constrauct an ISOPARAM
-			printf("\n STEP 2.5 \n");
-			IsoParametrization IsoParam1;
-			bool done=IsoParam1.Init(&abs_mesh1,&para_mesh1,true);
-			
-			if (!done)
-				return FailParam;
-			
-			printf("\n merging 0 \n");
-			///copy initial mesh 
-			final_mesh.Clear();
-			base_mesh.Clear();
-			vcg::tri::Append<BaseMesh,ParamMesh>::Mesh(final_mesh,para_mesh0);
-			vcg::tri::Append<BaseMesh,AbstractMesh>::Mesh(base_mesh,abs_mesh1);
-			///scale by a factor
-			
-			UpdateTopologies<BaseMesh>(&final_mesh);
-			UpdateTopologies<BaseMesh>(&base_mesh);
-
-			for (int i=0;i<(int)base_mesh.vert.size();i++)
-				base_mesh.vert[i].RPos=abs_mesh1.vert[i].P();
-			for (int i=0;i<(int)final_mesh.vert.size();i++)
-				final_mesh.vert[i].RPos=para_mesh0.vert[i].P();
-
-			///finally merge in between
-			for (int i=0;i<(int)para_mesh0.vert.size();i++)
-			{
-				///get the index of the first parametrization process
-				int Index0=para_mesh0.vert[i].T().N();
-				///find the parametrization coordinates
-				vcg::Point2<ScalarType> p2bary=para_mesh0.vert[i].T().P();
-				CoordType bary0=CoordType (p2bary.X(),p2bary.Y(),1-p2bary.X()-p2bary.Y());
-				bool isOK=NormalizeBaryCoords(bary0);
-				assert(isOK);
-        assert(size_t(Index0)<para_mesh1.face.size());
-
-				///get the correspondent face
-				ParamFace *f1=&para_mesh1.face[Index0];
-				int I_final=-1;
-				vcg::Point2<ScalarType> UV_final;
-				IsoParam1.Phi(f1,bary0,I_final,UV_final);
-        assert(size_t(I_final)<abs_mesh1.face.size());
-		
-				CoordType bary2=CoordType(UV_final.X(),UV_final.Y(),1-UV_final.X()-UV_final.Y());
-				isOK=NormalizeBaryCoords(bary2);
-				assert(isOK);
-				//final_mesh.vert[i].father=&base_mesh.face[I_final];
-				//assert(!base_mesh.face[I_final].IsD());
-				//final_mesh.vert[i].Bary=bary2;
-				AssingFather(final_mesh.vert[i],&base_mesh.face[I_final],bary2,base_mesh);
-			}
-
-			///set father to son link
-			for (int i=0;i<(int)final_mesh.vert.size();i++)
-			{
-				BaseFace* base_f=final_mesh.vert[i].father;
-				CoordType bary=final_mesh.vert[i].Bary;
-				assert((bary.X()>=0)&&(bary.Y()>=0));
-				assert((bary.X()<=1)&&(bary.Y()<=1));
-				assert(bary.X()+bary.Y()<=1.0001);
-				base_f->vertices_bary.push_back(std::pair<BaseVertex *,CoordType>(&final_mesh.vert[i],bary));
-			}
-		 InitVoronoiArea();
-		 FinalOptimization();
-		 printf("STEP 3 \n");
-		}
-		///finally perform the final optimization step
-		InitVoronoiArea();
-		//FinalOptimization();
-		GlobalOptimizeStep();
-
-		ScaleMesh(final_mesh,1.0/factor);
-		TranslateMesh(final_mesh,-transl);
-		ScaleMesh(base_mesh,1.0/factor);
-		TranslateMesh(base_mesh,-transl);
-		return Done;
-	}
-
-	///perform one or more flip steps
-	void FlipStep()
-	{
-#ifndef _MESHLAB
-		printf("\n STARTING FLIP SESSION \n");
-#endif
-		InitIMark();
-		FlipSession=new vcg::LocalOptimization<BaseMesh>(base_mesh);
-		FlipSession->Init<MyTriEdgeFlip>();	
-		/*bool b=*/FlipSession->DoOptimization();
-#ifndef _MESHLAB
-		printf("\n END FLIP SESSION %d edges \n",FlipSession->nPerfmormedOps);
-#endif
-		UpdateTopologies(&base_mesh);
-	}
-
-	///equilateralize patch lenght and areas
-	void EquiPatches()
-	{
-		PatchesOptimizer<BaseMesh> DomOpt(base_mesh,final_mesh);
-		DomOpt.OptimizePatches();
-		PrintAttributes();
-	}
-	
-	/// I/O FUNCTIONS
-	void SaveMCP(char* filename)
-	{
-		/*Warp(0);*/
-		FILE *f;
-		f=fopen(filename,"w+");
-		std::map<BaseFace*,int> facemap;
-		std::map<BaseVertex*,int> vertexmap;
-		typedef std::map<BaseVertex*,int>::iterator iteMapVert;
-		typedef std::map<BaseFace*,int>::iterator iteMapFace;
-
-		///add vertices
-		fprintf(f,"%d,%d \n",base_mesh.fn,base_mesh.vn);
-		int index=0;
-		for (unsigned int i=0;i<base_mesh.vert.size();i++)
-		{
-			BaseVertex* vert=&base_mesh.vert[i];
-			if (!vert->IsD())
-			{
-				vertexmap.insert(std::pair<BaseVertex*,int>(vert,index));
-				CoordType pos=vert->P();
-				CoordType RPos=vert->RPos;
-				fprintf(f,"%f,%f,%f;%f,%f,%f \n",pos.X(),pos.Y(),pos.Z(),RPos.X(),RPos.Y(),RPos.Z());
-				index++;
-			}
-		}
-
-		///add faces
-		index=0;
-		for (unsigned int i=0;i<base_mesh.face.size();i++)
-		{
-			BaseFace* face=&base_mesh.face[i];
-			if (!face->IsD())
-			{
-				BaseVertex* v0=face->V(0);
-				BaseVertex* v1=face->V(1);
-				BaseVertex* v2=face->V(2);
-				iteMapVert vertIte;
-				vertIte=vertexmap.find(v0);
-				assert(vertIte!=vertexmap.end());
-				int index0=(*vertIte).second;
-				vertIte=vertexmap.find(v1);
-				assert(vertIte!=vertexmap.end());
-				int index1=(*vertIte).second;
-				vertIte=vertexmap.find(v2);
-				assert(vertIte!=vertexmap.end());
-				int index2=(*vertIte).second;
-				assert((index0!=index1)&&(index1!=index2));
-				fprintf(f,"%d,%d,%d \n",index0,index1,index2);
-				facemap.insert(std::pair<BaseFace*,int>(face,index));
-				index++;
-			}
-		}
-
-		///high resolution mesh
-		fprintf(f,"%d,%d \n",final_mesh.fn,final_mesh.vn);
-
-		///add vertices
-		vertexmap.clear();
-		index=0;
-		for (unsigned int i=0;i<final_mesh.vert.size();i++)
-		{
-			BaseVertex* vert=&final_mesh.vert[i];
-			if (!vert->IsD())
-			{
-				vertexmap.insert(std::pair<BaseVertex*,int>(vert,index));
-				CoordType pos=vert->P();
-				CoordType bary=vert->Bary;
-				BaseFace* father=vert->father;
-				iteMapFace IteF=facemap.find(father);
-				assert (IteF!=facemap.end());
-				int indexface=(*IteF).second;
-				fprintf(f,"%f,%f,%f;%f,%f,%f;%d,%d,%d;%d \n",
-				pos.X(),pos.Y(),pos.Z(),bary.X(),bary.Y(),bary.Z(),
-				vert->OriginalCol.X(),vert->OriginalCol.Y(),vert->OriginalCol.Z(),
-				indexface);
-				index++;
-			}
-		}
-
-		///add faces
-		for (unsigned int i=0;i<final_mesh.face.size();i++)
-		{
-			BaseFace* face=&final_mesh.face[i];
-			if (!face->IsD())
-			{
-				BaseVertex* v0=face->V(0);
-				BaseVertex* v1=face->V(1);
-				BaseVertex* v2=face->V(2);
-				iteMapVert vertIte;
-				vertIte=vertexmap.find(v0);
-				assert(vertIte!=vertexmap.end());
-				int index0=(*vertIte).second;
-				vertIte=vertexmap.find(v1);
-				assert(vertIte!=vertexmap.end());
-				int index1=(*vertIte).second;
-				vertIte=vertexmap.find(v2);
-				assert(vertIte!=vertexmap.end());
-				int index2=(*vertIte).second;
-				assert((index0!=index1)&&(index1!=index2));
-				fprintf(f,"%d,%d,%d \n",index0,index1,index2);
-			}
-		}
-		fclose(f);
-	}
-
-	int LoadMCP(char* filename)
-	{
-		FILE *f=NULL;              
-		f=fopen(filename,"r");
-		if (f==NULL)
-			return -1;
-		/*std::map<BaseFace*,int> facemap;
-		std::map<BaseVertex*,int> vertexmap;
-		typedef std::map<BaseVertex*,int>::iterator iteMapVert;
-		typedef std::map<BaseFace*,int>::iterator iteMapFace;*/
-
-		
-
-		///add vertices
-		base_mesh.Clear();
-		fscanf(f,"%d,%d \n",&base_mesh.fn,&base_mesh.vn);
-		base_mesh.vert.resize(base_mesh.vn);
-		base_mesh.face.resize(base_mesh.fn);
-
-		for (unsigned int i=0;i<base_mesh.vert.size();i++)
-		{
-			BaseVertex* vert=&base_mesh.vert[i];
-			CoordType pos;
-			CoordType RPos;
-			fscanf(f,"%f,%f,%f;%f,%f,%f \n",&pos.X(),&pos.Y(),&pos.Z(),&RPos.X(),&RPos.Y(),&RPos.Z());
-			vert->P()=pos;
-			vert->RPos=RPos;
-		}
-
-		
-
-		///add faces
-		for (unsigned int i=0;i<base_mesh.face.size();i++)
-		{
-			BaseFace* face=&base_mesh.face[i];
-			if (!face->IsD())
-			{
-				int index0,index1,index2;
-				fscanf(f,"%d,%d,%d \n",&index0,&index1,&index2);
-				base_mesh.face[i].V(0)=&base_mesh.vert[index0];
-				base_mesh.face[i].V(1)=&base_mesh.vert[index1];
-				base_mesh.face[i].V(2)=&base_mesh.vert[index2];
-				base_mesh.face[i].group=vcg::Color4b(rand()%200,rand()%200,rand()%200,255);
-			}
-		}
-		
-		///high resolution mesh
-		fscanf(f,"%d,%d \n",&final_mesh.fn,&final_mesh.vn);
-		final_mesh.vert.resize(final_mesh.vn);
-		final_mesh.face.resize(final_mesh.fn);
-
-		///add vertices
-		for (unsigned int i=0;i<final_mesh.vert.size();i++)
-		{
-			BaseVertex* vert=&final_mesh.vert[i];
-			CoordType pos;
-			CoordType bary;
-			vcg::Color4b col;
-			int index_face;
-			int col0,col1,col2;
-			fscanf(f,"%f,%f,%f;%f,%f,%f;%d,%d,%d;%d \n",
-				  &pos.X(),&pos.Y(),&pos.Z(),
-				  &bary.X(),&bary.Y(),&bary.Z(),
-				  &col0,&col1,&col2,
-				  &index_face);
-			vert->P()=pos;
-			vert->RPos=pos;
-			vert->Bary=bary;
-			vert->father=&base_mesh.face[index_face];
-			assert(!base_mesh.face[index_face].IsD());
-			col=vcg::Color4b(col0,col1,col2,255);
-			vert->OriginalCol=col;
-			/*if (i==final_mesh.vert.size()-1)
-			{
-				printf("sukka %d \n",index_face);
-				char test;
-				scanf ("%c",&test);
-			}*/
-
-		}
-
-		///add faces
-		for (unsigned int i=0;i<final_mesh.face.size();i++)
-		{
-			//BaseFace* face=&final_mesh.face[i];
-			
-			int index0,index1,index2;
-			fscanf(f,"%d,%d,%d \n",&index0,&index1,&index2);
-			final_mesh.face[i].V(0)=&final_mesh.vert[index0];
-			final_mesh.face[i].V(1)=&final_mesh.vert[index1];
-			final_mesh.face[i].V(2)=&final_mesh.vert[index2];
-			
-		}
-		fclose(f);
-		
-		///update structures
-		UpdateStructures(&base_mesh);
-		UpdateStructures(&final_mesh);
-		//Colo
-		///clear father and bary
-		for (unsigned int i=0;i<base_mesh.face.size();i++)
-			base_mesh.face[i].vertices_bary.resize(0);
-
-		///set face-vertex link
-		for (unsigned int i=0;i<final_mesh.vert.size();i++)
-		{
-			BaseVertex *v=&final_mesh.vert[i];
-			BaseFace *f=v->father;
-			CoordType bary=v->Bary;
-			f->vertices_bary.push_back(std::pair<BaseVertex *,CoordType>(v,bary));
-		}
-		
-		//ColorByParametrization();
-		PrintAttributes();
-		//printf("faces:%5d AREA  distorsion:%lf\n",base_mesh.fn,ApproxAreaDistortion<BaseMesh>(final_mesh,base_mesh.fn));
-		//printf("faces:%5d ANGLE distorsion:%lf\n",base_mesh.fn,ApproxAngleDistortion<BaseMesh>(final_mesh));
-		
-		vcg::tri::UpdateBounding<BaseMesh>::Box(final_mesh);
-
-		///area perr vertex
-		for (unsigned int i=0;i<final_mesh.vert.size();i++)
-			//AuxHPara[i].area=0;
-			final_mesh.vert[i].area=0;
-
-		
-		for (unsigned int i=0;i<final_mesh.face.size();i++)
-		{
-			BaseFace *f=&final_mesh.face[i];
-			ScalarType areaf=(((f->V(1)->P()-f->V(0)->P())^(f->V(2)->P()-f->V(0)->P())).Norm())/(ScalarType)2.0;
-			/*AuxHPara[f->V(0)].area+=areaf/3.0;
-			AuxHPara[f->V(1)].area+=areaf/3.0;
-			AuxHPara[f->V(2)].area+=areaf/3.0;*/
-			f->V(0)->area+=areaf/(ScalarType)3.0;
-			f->V(1)->area+=areaf/(ScalarType)3.0;
-			f->V(2)->area+=areaf/(ScalarType)3.0;
-		}
-
-		return 0;
-	}
-	
-	void ExportMeshes(ParamMesh &para_mesh,AbstractMesh &abs_mesh)
-	{
-		para_mesh.Clear();
-		abs_mesh.Clear();
-
-		///copy meshes
-		vcg::tri::Append<AbstractMesh,BaseMesh>::Mesh(abs_mesh,base_mesh);
-		vcg::tri::Append<ParamMesh,BaseMesh>::Mesh(para_mesh,final_mesh);
-
-		///copy additional values
-		for (unsigned int i=0;i<base_mesh.vert.size();i++)
-		{
-			assert (!base_mesh.vert[i].IsD());
-			abs_mesh.vert[i].RPos=base_mesh.vert[i].RPos;
-		}
-
-		for (unsigned int i=0;i<final_mesh.vert.size();i++)
-			para_mesh.vert[i].RPos=final_mesh.vert[i].RPos;
-
-		///save in a table face-faces correspondences
-		std::map<BaseFace*,int> faceMap;
-		for (unsigned int i=0;i<base_mesh.face.size();i++)
-			faceMap.insert(std::pair<BaseFace*,int>(&base_mesh.face[i],i));
-
-		///then reassing with new mesh
-		for (unsigned int i=0;i<final_mesh.vert.size();i++)
-		{
-			std::map<BaseFace*,int>::iterator cur  = faceMap.find(final_mesh.vert[i].father);
-			assert(cur!= faceMap.end());
-			CoordType bary=final_mesh.vert[i].Bary;
-			int index=(*cur).second;
-			para_mesh.vert[i].T().N()=index;
-#ifdef _DEBUG
-			bool done=NormalizeBaryCoords(bary);
-			assert(done);
-#else
-			NormalizeBaryCoords(bary);
-#endif
-			para_mesh.vert[i].T().U()=bary.X();
-			para_mesh.vert[i].T().V()=bary.Y();
-			
-		}
-	}
-
-	//int draw_mode;
-	
-	void PrintAttributes()
-	{
-		int done=(final_mesh.fn-base_mesh.fn);
-		int total=(final_mesh.fn-lower_limit);
-		ScalarType ratio=(ScalarType)done/total;
-		ratio=pow(ratio,3);
-		int percent=(int)(ratio*(ScalarType)100);
-		ScalarType areaD=ApproxAreaDistortion<BaseMesh>(final_mesh,base_mesh.fn);
-		ScalarType angleD=ApproxAngleDistortion<BaseMesh>(final_mesh);
-		char ret[200];
-		sprintf(ret," GATHERING ABSTRACT DOMAIN faces:%5d AREA  distorsion:%4f ; ANGLE distorsion:%4f ",base_mesh.fn,areaD,angleD);
-		(*cb)(percent,ret);
-	}
-
-	void SetParameters(vcg::CallBackPos *_cb,
-					   const int &_lower_limit=100,
-					   const int &_interval=50,
-					   StopMode _SMode=SM_Euristic,
-					   const int &_accuracy=1)
-	{
-		lower_limit=_lower_limit;
-		interval=_interval;
-		accuracy=_accuracy;
-		SMode=_SMode;
-		ParaInfo::SM()=_SMode;
-		cb=_cb;
-	}
-	
-	void getValues(ScalarType &aggregate,
-						ScalarType &L2,
-						int &n_faces)
-	{
-	L2=ApproxL2Error(final_mesh);
-	ScalarType val0=ApproxAreaDistortion<BaseMesh>(final_mesh,base_mesh.fn);
-	ScalarType val1=ApproxAngleDistortion<BaseMesh>(final_mesh);
-	aggregate=geomAverage<ScalarType>(val0+1.0,val1+1.0,3,1)-1;
-	n_faces=base_mesh.fn;
-	}
-
-	IsoParametrizator()
-	{
-		///parameters
-		SMode=SM_Euristic;
-		lower_limit=40;
-		interval=50;
-		accuracy=1;
-	}
-
-};
-
-#endif
+#ifndef _PARAMETRIZATOR
+#define _PARAMETRIZATOR
+
+#include <defines.h>
+
+
+#include <param_collapse.h>
+#include <param_flip.h>
+
+
+#include <param_mesh.h>
+#include <iso_parametrization.h>
+
+///auxiliary structures
+
+#include <vcg/complex/algorithms/clean.h>
+#include <vcg/complex/allocate.h>
+#include <vcg/complex/append.h>
+#include <vcg/complex/algorithms/update/topology.h>
+#include <vcg/complex/algorithms/update/bounding.h>
+
+// update topology
+#include <vcg/complex/algorithms/update/normal.h>
+#include <vcg/complex/algorithms/update/edges.h>
+#include <vcg/complex/algorithms/update/flag.h>
+
+
+// local optimization
+#include <vcg/complex/algorithms/local_optimization.h>
+
+
+#include <local_parametrization.h>
+#include <mesh_operators.h>
+#include <vcg/space/color4.h>
+#include <dual_coord_optimization.h>
+#include <float.h>
+#include <lm.h>
+#ifndef _MESHLAB
+#include <wrap/io_trimesh/export_ply.h>
+#endif
+//#include <EquilaterizeMesh.h>
+
+#include <opt_patch.h>
+#include <local_optimization.h>
+#include <statistics.h>
+#include <stat_remeshing.h>
+
+//extern int step_global;
+//
+//int time_opt;
+
+///Flip function
+class MyTriEdgeFlip : public ParamEdgeFlip<BaseMesh>{};
+class MyTriEdgeCollapse: public ParamEdgeCollapse<BaseMesh>{};
+
+///THIS CLASS MAINTAINS STRUCTURES WICH ARE USED FOR PARAMETRIZATION
+///TOGHETHER WITH METHOD FOR COLORIZATION FOR VISUALIZATION PURPOSES
+
+class IsoParametrizator{
+
+public:
+	 enum ReturnCode{MultiComponent,
+													NonSizeCons,
+													NonManifoldE,
+													NonManifoldV,
+													NonWatertigh,
+													FailParam,Done};
+	
+
+	BaseMesh final_mesh;
+	BaseMesh base_mesh;
+	typedef BaseMesh::ScalarType ScalarType;
+	typedef BaseMesh::CoordType CoordType;
+	vcg::CallBackPos *cb;
+	EnergyType EType;
+private:
+	
+	void InitVoronoiArea()
+	{
+		///area deviation respect to original
+		for (unsigned int i=0;i<base_mesh.face.size();i++)
+			base_mesh.face[i].areadelta=0;
+
+		for (unsigned int i=0;i<final_mesh.vert.size();i++)
+			final_mesh.vert[i].area=0;
+
+		for (unsigned int i=0;i<final_mesh.face.size();i++)
+		{
+			BaseFace *f=&final_mesh.face[i];
+			ScalarType areaf=vcg::DoubleArea(*f)/2.0;//(((f->V(1)->P()-f->V(0)->P())^(f->V(2)->P()-f->V(0)->P())).Norm())/2.0;
+			f->V(0)->area+=areaf/(ScalarType)3.0;
+			f->V(1)->area+=areaf/(ScalarType)3.0;
+			f->V(2)->area+=areaf/(ScalarType)3.0;
+		}
+	}
+
+	template <class MeshType>
+	void InitializeStructures(MeshType *mesh)
+	{
+		///cleaning of initial mesh
+		/*int dup = */vcg::tri::Clean<MeshType>::RemoveDuplicateVertex(*mesh);
+		/*int unref =  */vcg::tri::Clean<MeshType>::RemoveUnreferencedVertex(*mesh);
+
+		vcg::tri::Allocator<MeshType>::CompactFaceVector(*mesh);
+		vcg::tri::Allocator<MeshType>::CompactVertexVector(*mesh);
+
+		///copy
+		base_mesh.Clear();
+		final_mesh.Clear();
+		vcg::tri::Append<BaseMesh,MeshType>::Mesh(base_mesh,*mesh);
+		vcg::tri::Append<BaseMesh,MeshType>::Mesh(final_mesh,*mesh);
+
+		///update auxiliary structures
+		UpdateStructures(&base_mesh);
+		UpdateStructures(&final_mesh);
+		vcg::tri::UpdateTopology<BaseMesh>::TestFaceFace(base_mesh);
+		vcg::tri::UpdateTopology<BaseMesh>::TestFaceFace(final_mesh);
+
+		///initialization of statistics
+		//stat.Init(&base_mesh,&final_mesh);
+
+		///copy original color
+		for (unsigned int i=0;i<final_mesh.vert.size();i++)
+			final_mesh.vert[i].OriginalCol=final_mesh.vert[i].C();
+		
+		///set brother vertices and default father
+		/*unsigned int i=0;*/
+		for (unsigned int i=0;i<base_mesh.vert.size();i++)
+		{
+			base_mesh.vert[i].brother=&final_mesh.vert[i];
+			base_mesh.vert[i].RPos=base_mesh.vert[i].P();
+		}
+
+		/*///area deviation respect to original
+		for (unsigned int i=0;i<base_mesh.face.size();i++)
+			base_mesh.face[i].areadelta=0;
+
+		for (unsigned int i=0;i<final_mesh.vert.size();i++)
+			final_mesh.vert[i].area=0;*/
+		
+		for (unsigned int i=0;i<base_mesh.vert.size();i++){
+			base_mesh.vert[i].brother=&final_mesh.vert[i];
+			//final_mesh.vert[i].father=base_mesh.vert[i].VFp();
+			//assert(!base_mesh.vert[i].VFp()->IsD());
+			CoordType bary=CoordType(0,0,0);
+			bary.V(base_mesh.vert[i].VFi())=1;
+			//final_mesh.vert[i].Bary=bary;
+			AssingFather(final_mesh.vert[i],base_mesh.vert[i].VFp(),bary,base_mesh);
+		}
+
+		///initialize area per vertex
+	
+		for (unsigned int i=0;i<final_mesh.vert.size();i++){
+			BaseFace* father=final_mesh.vert[i].father;
+			CoordType bary=final_mesh.vert[i].Bary;
+			father->vertices_bary.push_back(std::pair<BaseVertex*,vcg::Point3f>(&final_mesh.vert[i],bary));
+		}
+
+		///testing everithing is ok
+		for (unsigned int i=0;i<final_mesh.vert.size();i++)
+		{
+			final_mesh.vert[i].RPos=final_mesh.vert[i].P();
+			CoordType test=ProjectPos(final_mesh.vert[i]);
+			assert((test-final_mesh.vert[i].P()).Norm()<0.000001);
+		}	
+
+		////initialization for decimation
+		//base_mesh.en=0;
+		InitIMark();
+		for (unsigned int i=0;i<base_mesh.vert.size();i++)
+			base_mesh.vert[i].ClearFlags();
+		for (unsigned int i=0;i<base_mesh.face.size();i++)
+			base_mesh.face[i].ClearFlags();
+		InitVoronoiArea();
+	}
+
+	void InitIMark()
+	{
+    vcg::tri::IMark(base_mesh)=0;
+    vcg::tri::InitFaceIMark(base_mesh);
+    vcg::tri::InitVertexIMark(base_mesh);
+	}
+	
+
+	void ParaDecimate(const int &targetFaces,
+					  const int &interval,
+					  bool execute_flip=false)
+	{
+		vcg::LocalOptimization<BaseMesh> DeciSession(base_mesh);
+		DeciSession.Init<MyTriEdgeCollapse >();
+		MyTriEdgeCollapse::Accuracy()=accuracy;
+		MyTriEdgeCollapse::HresMesh()=&final_mesh;
+		PatchesOptimizer<BaseMesh>::HresMesh()=&final_mesh;
+		PatchesOptimizer<BaseMesh>::BaseMesh()=&base_mesh;
+
+		MyTriEdgeFlip::Accuracy()=accuracy;
+		
+		int flip_todo=4;
+		int next_flip_num=targetFaces;
+		std::vector<int> stop_points;
+
+		if (execute_flip)
+		{
+			stop_points.resize(flip_todo+2);///number of flips + save stack point + final stop
+
+			for (int i=0;i<flip_todo;i++)
+			{
+				next_flip_num=(int)((ScalarType)next_flip_num*flip_factor);
+				stop_points[i]=next_flip_num;
+			}	
+			stop_points[flip_todo]=targetFaces+interval;
+			stop_points[flip_todo+1]=targetFaces;
+			std::sort(stop_points.begin(),stop_points.end());
+		}
+		else
+		{
+			stop_points.resize(2);
+			stop_points[0]=targetFaces;
+			stop_points[1]=targetFaces+interval;
+		}
+
+		///find the point where save stack is defined 
+		int pos_stack=-1;
+		for (unsigned int i=0;i<stop_points.size();i++)
+		{
+			if (stop_points[i]==(targetFaces+interval))
+				pos_stack=i;
+		}
+		
+
+		assert(pos_stack!=-1);
+
+		bool do_flip=false;
+		bool save_status=false;
+		int curr_limit=stop_points.size()-1;
+		bool not_heap_empty=true;
+		//bool check_status=false;
+		while ((base_mesh.fn>targetFaces)&&(not_heap_empty))
+		{
+			do_flip=false;
+
+			int curr_num=base_mesh.fn;
+				
+			int next_num;
+			if (!save_status)
+				next_num=curr_num-1000;
+			else
+				next_num=curr_num-2;
+			
+			if ((curr_limit>=0)&&(next_num<stop_points[curr_limit]))
+			{
+				next_num=stop_points[curr_limit];
+				
+				if (curr_limit==pos_stack)
+					save_status=true;
+				else
+				if ((curr_limit!=0)&&(execute_flip))
+					do_flip=true;
+
+				curr_limit--;
+			}
+			
+		
+
+			DeciSession.SetTargetSimplices(next_num);
+			not_heap_empty=DeciSession.DoOptimization();
+
+		
+
+			if (do_flip)
+			{
+				FlipStep();
+				vcg::tri::UpdateTopology<BaseMesh>::FaceFace(base_mesh);
+				vcg::tri::UpdateTopology<BaseMesh>::VertexFace(base_mesh);
+				InitIMark();
+				DeciSession.h.clear();
+				DeciSession.Init<MyTriEdgeCollapse >();
+				if (flip_todo>0)
+				{
+					next_flip_num=(int)(((ScalarType)next_flip_num)/flip_factor);
+					flip_todo--;
+				}
+			}
+			/*#ifndef _MESHLAB
+			
+			#endif*/
+			PrintAttributes();
+			if (save_status)
+			{
+				#ifndef _MESHLAB
+				printf("SAVING CURRENT STATUS....face_num: %d\n",curr_num);
+				#endif
+				SaveCurrentStatus();
+				InitIMark();
+				DeciSession.h.clear();
+				DeciSession.Init<MyTriEdgeCollapse >();
+			}
+			
+			testParametrization<BaseMesh>(base_mesh,final_mesh);
+			
+		}
+
+		
+	}
+
+	///ASSOCIATE SURVIVED VERTEX FROM DECIMATION
+	void AssociateRemaining()
+	{
+		printf("\n ASSOCIATE REMAINING \n");
+		for (unsigned int i=0;i<base_mesh.vert.size();i++)
+			if (base_mesh.vert[i].brother!=NULL)
+			{
+				BaseVertex* v=&base_mesh.vert[i];
+				BaseVertex* vb=v->brother;
+				vcg::face::VFIterator<BaseFace> vfi2(v);
+				///take the face that has lower number of vertices
+				BaseFace *fmin=vfi2.F();
+				int index=vfi2.I();
+        size_t sizeMin=fmin->vertices_bary.size();
+				while (!vfi2.End())
+				{
+					BaseFace *f=vfi2.F();
+					if (f->vertices_bary.size()<sizeMin)
+					{
+						sizeMin=f->vertices_bary.size();
+						fmin=f;
+						index=vfi2.I();
+					}
+          ++vfi2;
+				}
+				CoordType bary=CoordType(0,0,0);
+				bary[index]=1.f;
+				fmin->vertices_bary.push_back(std::pair<BaseVertex*,vcg::Point3f>(vb,bary));
+				AssingFather(*vb,fmin,bary,base_mesh);
+				/*vb->father=f;
+				assert(!f->IsD());
+				vb->Bary=bary;*/
+				v->brother=NULL;
+			}
+	}
+
+	struct vert_para
+		{
+			ScalarType dist;
+			BaseVertex *v;
+      bool operator <(const vert_para &other) const
+			{return (dist>other.dist);}
+		};
+
+	void FinalOptimization()
+	{
+		char ret[200];
+		sprintf(ret," PERFORM GLOBAL OPTIMIZATION initializing... ");
+		(*cb)(0,ret);
+
+		
+
+		std::vector<vert_para> ord_vertex;
+		ord_vertex.resize(base_mesh.vn);
+		for (unsigned int i=0;i<base_mesh.vert.size();i++)
+			if (!base_mesh.vert[i].IsD())
+			{
+				BaseVertex *v=&base_mesh.vert[i];
+				ScalarType val=StarDistorsion<BaseMesh>(&base_mesh.vert[i]);
+				//printf("i: %d\n",i);
+				ord_vertex[i].dist=val;
+				ord_vertex[i].v=v;
+			}
+		
+		std::sort(ord_vertex.begin(),ord_vertex.end());
+		for (unsigned int i=0;i<ord_vertex.size();i++)
+		{
+				printf("%3.3f\n",ord_vertex[i].dist);
+				SmartOptimizeStar<BaseMesh>(ord_vertex[i].v,base_mesh,MyTriEdgeCollapse::Accuracy(),EType);
+		}	
+	}
+
+
+	template <class MeshType>
+	ReturnCode InitBaseMesh(MeshType *mesh,
+		const int &targetFaces,
+		const int &interval,
+		bool execute_flip=true,
+		bool test_interpolation=true)
+	{
+    vcg::tri::UpdateFlags<MeshType>::VertexClearV(*mesh);
+    vcg::tri::UpdateFlags<MeshType>::FaceClearV(*mesh);
+
+    ///TEST PRECONDITIONS
+    ReturnCode ret=Preconditions(*mesh);
+		
+    if (ret!=Done) return ret;
+
+		///INITIALIZATION
+		InitializeStructures<MeshType>(mesh);
+		
+		///DECIMATION & PARAMETRIZATION
+		ParaDecimate(targetFaces,interval,execute_flip);
+
+		///SET BEST FIND STOP POINT
+		bool isOK=SetBestStatus(test_interpolation);
+		if ((!isOK)&&(test_interpolation))
+			return FailParam;
+
+		///THEN CLEAR STACK
+		ClearStack();
+
+		///LAST FLIP STEP
+		if (execute_flip)
+			FlipStep();
+
+		vcg::tri::UpdateTopology<BaseMesh>::FaceFace(base_mesh);
+		vcg::tri::UpdateTopology<BaseMesh>::VertexFace(base_mesh);
+		vcg::tri::UpdateTopology<BaseMesh>::TestVertexFace(base_mesh); ///TEST
+
+		UpdateStructures(&base_mesh);
+		#ifndef _MESHLAB
+		if (execute_flip)
+		{
+			printf("\n POST LAST FLIP: \n");
+			PrintAttributes();
+		}
+		#endif
+		
+		///ASSOCIATE REMAINING VERTICES TO ONE FACE
+		AssociateRemaining();
+		
+		///LAST OPTIMIZATION STEP ON STARS
+		if (execute_flip)
+			FinalOptimization();
+
+		#ifndef _MESHLAB	
+		if (execute_flip)
+		{
+			printf("\n POST STAR OPT: \n");
+			PrintAttributes();
+		}
+		#endif
+		return Done;
+	}
+
+	void CompactBaseDomain()
+	{
+		/*testParametrization<BaseMesh>(base_mesh,final_mesh);
+		system("pause");*/
+		vcg::tri::Allocator<BaseMesh>::CompactVertexVector(base_mesh);
+		vcg::tri::Allocator<BaseMesh>::CompactFaceVector(base_mesh);
+		UpdateStructures(&base_mesh);
+		///reassing
+		//for (int i=0;i<(int)base_mesh.face.size();i++)
+		for (int i=0;i<(int)base_mesh.face.size();i++)
+		{
+			int size=base_mesh.face[i].vertices_bary.size();
+			/*assert(size>0);*/
+			for (int j=0;j<size;j++)
+			{
+				BaseVertex* son=base_mesh.face[i].vertices_bary[j].first;
+				CoordType bary=base_mesh.face[i].vertices_bary[j].second;
+				/*son->father=&base_mesh.face[i];
+				assert(!base_mesh.face[i].IsD());
+				son->Bary=bary;*/
+				AssingFather(*son,&base_mesh.face[i],bary,base_mesh);
+			}
+		}
+		/*testParametrization<BaseMesh>(base_mesh,final_mesh);
+		system("pause");*/
+	}
+
+	///save the current status of the parameterization
+	void SaveCurrentStatus()
+	{
+		///copy
+		ParaStack.push_back(ParaInfo());
+		ParaStack.back().AbsMesh=new BaseMesh();
+		BaseMesh *mesh=ParaStack.back().AbsMesh;
+		CompactBaseDomain();
+
+		vcg::tri::Append<BaseMesh,BaseMesh>::Mesh(*mesh,base_mesh);
+
+	
+		for (unsigned int i=0;i<base_mesh.vert.size();i++)
+				mesh->vert[i].RPos=base_mesh.vert[i].RPos;
+		
+		///copy linking for parameterization informations
+		int k=0;
+		for (unsigned int i=0;i<base_mesh.face.size();i++)
+		{
+			if (!base_mesh.face[i].IsD())
+			{
+				int size=base_mesh.face[i].vertices_bary.size();
+				mesh->face[k].vertices_bary.resize(size);
+				for (int j=0;j<size;j++)
+				{
+					mesh->face[k].vertices_bary[j].first=base_mesh.face[i].vertices_bary[j].first;
+					mesh->face[k].vertices_bary[j].second=base_mesh.face[i].vertices_bary[j].second;
+				}
+				k++;
+			}
+		}
+		//ParaStack.push_back(ParaInfo());
+		/*ParaStack.back().AbsMesh=mesh;*/
+		ScalarType valL2=ApproxL2Error(final_mesh);
+		ParaStack.back().L2=valL2;
+		ScalarType val0=ApproxAreaDistortion<BaseMesh>(final_mesh,mesh->fn);
+		ParaStack.back().AreaDist=val0;
+		ScalarType val1=ApproxAngleDistortion<BaseMesh>(final_mesh);
+		ParaStack.back().AngleDist=val1;
+		ParaStack.back().AggrDist=geomAverage<ScalarType>(val0+(ScalarType)1.0,val1+(ScalarType)1.0,3,1)-(ScalarType)1;
+		ParaStack.back().Regular=NumRegular<BaseMesh>(*mesh);
+		//ParaStack.back().distorsion=geomAverage<double>(val0,val1,3,1);
+		ScalarType val2=ParaStack.back().AggrDist;
+		ParaStack.back().num_faces=mesh->fn;
+		ParaStack.back().ratio=val2*sqrt((ScalarType)mesh->fn);
+	}
+
+	void RestoreStatus(const int &index_status)
+	{
+		///delete current base mesh
+		base_mesh.Clear();
+		BaseMesh *to_restore=ParaStack[index_status].AbsMesh;
+	
+		///restore saved abstract mesh and link
+		vcg::tri::Append<BaseMesh,BaseMesh>::Mesh(base_mesh,*to_restore);
+		for (unsigned int i=0;i<to_restore->face.size();i++)
+		{
+			int size=to_restore->face[i].vertices_bary.size();
+			base_mesh.face[i].vertices_bary.resize(size);
+			for (int j=0;j<size;j++)
+			{
+				BaseVertex * vert=to_restore->face[i].vertices_bary[j].first;
+				CoordType bary=to_restore->face[i].vertices_bary[j].second;
+#ifdef _DEBUG
+				bool done=NormalizeBaryCoords(bary);
+				assert(done);
+#else
+				NormalizeBaryCoords(bary);
+#endif
+				base_mesh.face[i].vertices_bary[j].first=vert;
+				base_mesh.face[i].vertices_bary[j].second=bary;
+
+				AssingFather(*vert,&base_mesh.face[i],bary,base_mesh);
+
+				//vert->father=&base_mesh.face[i];
+				//assert(!base_mesh.face[i].IsD());
+				//vert->Bary=bary;
+			}
+		}
+		UpdateTopologies<BaseMesh>(&base_mesh);
+
+		///copy rest pos
+		for (unsigned int i=0;i<to_restore->vert.size();i++)
+		{
+			base_mesh.vert[i].RPos=to_restore->vert[i].RPos;
+			base_mesh.vert[i].P()=to_restore->vert[i].P();
+		}
+		/*///clear stack of meshes
+		ClearStack();*/
+	}
+
+	///clear the durrent stack
+	void ClearStack()
+	{
+		for (unsigned int i=0;i<ParaStack.size();i++)
+			delete(ParaStack[i].AbsMesh);
+		ParaStack.clear();
+	}
+
+	ScalarType GetStatusVal(const int &index)
+	{
+		switch (SMode)
+		{
+		case (SM_Area): return ParaStack[index].AreaDist;
+			break;
+		case (SM_Angle):return ParaStack[index].AngleDist;
+			break;
+		case (SM_Corr):return ParaStack[index].AggrDist;
+			break;
+		case (SM_Reg):return (ScalarType)ParaStack[index].Regular;
+			break;
+		case (SM_Smallest):return (ScalarType)ParaStack[index].num_faces;
+			break;
+		case (SM_L2):return ParaStack[index].L2;
+			break;
+		default:return ParaStack[index].ratio;
+			break;
+		}
+	}
+	
+	///return true if possible to construct an Isoparametrization
+	bool TestInterpolation()
+	{
+			ParamMesh para_mesh1;
+			AbstractMesh abs_mesh1;
+			ExportMeshes(para_mesh1,abs_mesh1);
+		
+			///constrauct an ISOPARAM
+			IsoParametrization IsoParam1;
+			return(IsoParam1.Init(&abs_mesh1,&para_mesh1));
+	}
+
+	///set the best value considering the ratio value
+	bool SetBestStatus(bool test_interpolation)
+	{
+		std::sort(ParaStack.begin(),ParaStack.end());
+		int indexmin=0;
+		bool isOK_interp;
+
+		if (test_interpolation)
+			isOK_interp=false;
+		else
+			isOK_interp=true;
+
+		RestoreStatus(indexmin);
+		if (test_interpolation)
+		{
+			while ((!isOK_interp)&&(indexmin<(int)ParaStack.size()))
+			{
+				isOK_interp=TestInterpolation();
+				if (!isOK_interp)
+				{
+					indexmin++;
+					if (indexmin<(int)ParaStack.size())
+						RestoreStatus(indexmin);
+				}
+			}	
+		} 
+
+		///clear stack of meshes
+	
+
+		
+#ifndef _MESHLAB
+		for (unsigned int i=0;i<ParaStack.size();i++)
+		{
+
+			printf("faces %d, Area %.4f, Angle %.4f, Corr %.4f, non Reg %d,L2 %.4f,Heuristic %.4f\n",
+				ParaStack[i].num_faces,
+				ParaStack[i].AreaDist,
+				ParaStack[i].AngleDist,
+				ParaStack[i].AggrDist,
+				ParaStack[i].Regular,
+				ParaStack[i].L2,
+				ParaStack[i].ratio);
+		}
+		if ((isOK_interp)||(!test_interpolation))
+			printf("Choosen to stop at %d faces \n",ParaStack[indexmin].num_faces);
+		else
+			printf("Not a right Interpolation Domain is found");
+#endif
+		
+		ClearStack();
+		isOK_interp=TestInterpolation();
+		return (isOK_interp);
+	}
+
+public:
+
+	enum StopMode{
+		SM_Euristic,
+		SM_Area,
+		SM_Angle,
+		SM_Corr,
+		SM_Reg,
+		SM_Smallest,
+		SM_L2
+	};
+
+	///parameters
+	StopMode SMode;
+	int lower_limit;
+	int interval;
+	int accuracy;
+	//edn parameters
+
+	MyTriEdgeCollapse *next_oper; 
+	MyTriEdgeFlip *next_flip;
+	BaryOptimizatorDual<BaseMesh> *BaryOptDemo;
+	vcg::LocalOptimization<BaseMesh> *FlipSession;
+	
+	int TimeStepDeci,TimeStepFlip;
+
+	struct ParaInfo
+	{
+		ScalarType AggrDist;
+		ScalarType AreaDist;
+		ScalarType AngleDist;
+		int Regular;
+		int num_faces;
+		ScalarType ratio;
+		ScalarType L2;
+		BaseMesh * AbsMesh;
+
+		static StopMode& SM()
+		{
+			static StopMode S;
+			return S;
+		}
+
+    inline bool operator < (const ParaInfo &P_info) const{
+			switch (SM())
+			{
+			case (SM_Area): return AreaDist<P_info.AreaDist;
+				break;
+			case (SM_Angle):return AngleDist<P_info.AngleDist;
+				break;
+			case (SM_Corr):return AggrDist<P_info.AggrDist;
+				break;
+			case (SM_Reg):return Regular<P_info.Regular;
+				break;
+			case (SM_Smallest):return num_faces<P_info.num_faces;
+				break;
+			case (SM_L2):return L2<P_info.L2;
+				break;
+			default:return ratio<P_info.ratio;
+				break;
+			}
+		}
+
+	};
+
+	std::vector<ParaInfo> ParaStack;
+
+	///PRECONDITIONS
+	template <class MeshType>
+	ReturnCode Preconditions(MeshType &mesh)
+	{
+		bool b;
+		vcg::tri::UpdateTopology<MeshType>::FaceFace(mesh);
+    if(vcg::tri::Clean<MeshType>::CountNonManifoldEdgeFF(mesh)>0 ) return NonManifoldE;
+    if(vcg::tri::Clean<MeshType>::CountNonManifoldVertexFF(mesh)>0 ) return NonManifoldV;
+
+		b=vcg::tri::Clean<MeshType>::IsSizeConsistent(mesh);
+		if (!b)	return NonSizeCons;
+
+    int cc=vcg::tri::Clean<MeshType>::CountConnectedComponents(mesh);
+    if(cc>1) return MultiComponent;
+
+    int boundaryEdgeNum, internalEdgeNum;
+    vcg::tri::Clean<MeshType>::CountEdges(mesh,internalEdgeNum,boundaryEdgeNum);
+    if(boundaryEdgeNum>0) return NonWatertigh;
+
+		return Done;
+	}
+
+	///perform a global optimization step
+	void GlobalOptimizeStep()
+	{
+#ifndef _MESHLAB
+	  printf("\n GLOBAL OPTIMIZATION \n");
+#endif
+	  BaryOptimizatorDual<BaseMesh> BaryOpt;
+	  BaryOpt.Init(base_mesh,final_mesh,cb,accuracy,EType);
+	  BaryOpt.Optimize(4.0/(double)accuracy,accuracy*4);
+#ifndef _MESHLAB
+	  printf("\n POST DUAL OPT:	\n");
+	  PrintAttributes();
+#endif
+	}
+
+	template <class MeshType>
+	void ScaleMesh(MeshType &m,
+								 const ScalarType &factor)
+	{
+    for (size_t i=0;i<m.vert.size();i++)
+			if (!m.vert[i].IsD())
+				m.vert[i].P()*=factor;
+	}
+	
+	template <class MeshType>
+	void TranslateMesh(MeshType &m,const typename MeshType::CoordType &vect)
+	{
+    for (size_t i=0;i<m.vert.size();i++)
+			if (!m.vert[i].IsD())
+				m.vert[i].P()+=vect;
+	}
+
+	///PARAMETRIZATION FUNCTIONS 
+	///initialize the mesh 
+	template <class MeshType>
+	ReturnCode Parametrize(MeshType *mesh,bool Two_steps=true,EnergyType _EType=EN_EXTMips)
+	{		
+		EType=_EType;
+		MyTriEdgeCollapse::EType()=EType;
+		MyTriEdgeFlip::EType()=EType;
+
+		///clean unreferenced vertices
+		vcg::tri::Clean<MeshType>::RemoveUnreferencedVertex(*mesh);
+		/*bool done;*/
+		const int limit0=15000;//00;
+		const int limit1=30000;
+		
+		vcg::tri::UpdateBounding<MeshType>::Box(*mesh);
+		ScalarType factor=100.0/mesh->bbox.Diag();
+		CoordType transl=-mesh->bbox.Center();
+		TranslateMesh(*mesh,transl);
+		ScaleMesh(*mesh,factor);
+		if ((!Two_steps)||(lower_limit>limit0)||(mesh->fn<limit1))
+		{
+			ReturnCode res=InitBaseMesh<MeshType>(mesh,lower_limit,interval,true,true);	
+			ScaleMesh(*mesh,1.0/factor);
+			TranslateMesh(*mesh,-transl);
+			if (res!=Done)
+				return res;
+		}
+		else
+		{
+			///do a first parametrization step
+			printf("\n STEP 1 \n");
+			InitVoronoiArea();
+			ReturnCode res=InitBaseMesh<MeshType>(mesh,limit0,1,false,false);
+			ScaleMesh(*mesh,1.0/factor);
+			TranslateMesh(*mesh,-transl);
+			if (res!=Done)
+				return res;
+
+			ParamMesh para_mesh0;
+			AbstractMesh abs_mesh0;
+			//AbstractMesh abs_mesh_test;
+			ExportMeshes(para_mesh0,abs_mesh0);
+
+			printf("\n STEP 2 \n");
+			res=InitBaseMesh<AbstractMesh>(&abs_mesh0,lower_limit,interval,true,true);
+			if (res!=Done)
+				return res;
+			
+			
+			ParamMesh para_mesh1;
+			AbstractMesh abs_mesh1;
+			ExportMeshes(para_mesh1,abs_mesh1);
+
+			
+
+			///constrauct an ISOPARAM
+			printf("\n STEP 2.5 \n");
+			IsoParametrization IsoParam1;
+			bool done=IsoParam1.Init(&abs_mesh1,&para_mesh1,true);
+			
+			if (!done)
+				return FailParam;
+			
+			printf("\n merging 0 \n");
+			///copy initial mesh 
+			final_mesh.Clear();
+			base_mesh.Clear();
+			vcg::tri::Append<BaseMesh,ParamMesh>::Mesh(final_mesh,para_mesh0);
+			vcg::tri::Append<BaseMesh,AbstractMesh>::Mesh(base_mesh,abs_mesh1);
+			///scale by a factor
+			
+			UpdateTopologies<BaseMesh>(&final_mesh);
+			UpdateTopologies<BaseMesh>(&base_mesh);
+
+			for (int i=0;i<(int)base_mesh.vert.size();i++)
+				base_mesh.vert[i].RPos=abs_mesh1.vert[i].P();
+			for (int i=0;i<(int)final_mesh.vert.size();i++)
+				final_mesh.vert[i].RPos=para_mesh0.vert[i].P();
+
+			///finally merge in between
+			for (int i=0;i<(int)para_mesh0.vert.size();i++)
+			{
+				///get the index of the first parametrization process
+				int Index0=para_mesh0.vert[i].T().N();
+				///find the parametrization coordinates
+				vcg::Point2<ScalarType> p2bary=para_mesh0.vert[i].T().P();
+				CoordType bary0=CoordType (p2bary.X(),p2bary.Y(),1-p2bary.X()-p2bary.Y());
+				bool isOK=NormalizeBaryCoords(bary0);
+				assert(isOK);
+        assert(size_t(Index0)<para_mesh1.face.size());
+
+				///get the correspondent face
+				ParamFace *f1=&para_mesh1.face[Index0];
+				int I_final=-1;
+				vcg::Point2<ScalarType> UV_final;
+				IsoParam1.Phi(f1,bary0,I_final,UV_final);
+        assert(size_t(I_final)<abs_mesh1.face.size());
+		
+				CoordType bary2=CoordType(UV_final.X(),UV_final.Y(),1-UV_final.X()-UV_final.Y());
+				isOK=NormalizeBaryCoords(bary2);
+				assert(isOK);
+				//final_mesh.vert[i].father=&base_mesh.face[I_final];
+				//assert(!base_mesh.face[I_final].IsD());
+				//final_mesh.vert[i].Bary=bary2;
+				AssingFather(final_mesh.vert[i],&base_mesh.face[I_final],bary2,base_mesh);
+			}
+
+			///set father to son link
+			for (int i=0;i<(int)final_mesh.vert.size();i++)
+			{
+				BaseFace* base_f=final_mesh.vert[i].father;
+				CoordType bary=final_mesh.vert[i].Bary;
+				assert((bary.X()>=0)&&(bary.Y()>=0));
+				assert((bary.X()<=1)&&(bary.Y()<=1));
+				assert(bary.X()+bary.Y()<=1.0001);
+				base_f->vertices_bary.push_back(std::pair<BaseVertex *,CoordType>(&final_mesh.vert[i],bary));
+			}
+		 InitVoronoiArea();
+		 FinalOptimization();
+		 printf("STEP 3 \n");
+		}
+		///finally perform the final optimization step
+		InitVoronoiArea();
+		//FinalOptimization();
+		GlobalOptimizeStep();
+
+		ScaleMesh(final_mesh,1.0/factor);
+		TranslateMesh(final_mesh,-transl);
+		ScaleMesh(base_mesh,1.0/factor);
+		TranslateMesh(base_mesh,-transl);
+		return Done;
+	}
+
+	///perform one or more flip steps
+	void FlipStep()
+	{
+#ifndef _MESHLAB
+		printf("\n STARTING FLIP SESSION \n");
+#endif
+		InitIMark();
+		FlipSession=new vcg::LocalOptimization<BaseMesh>(base_mesh);
+		FlipSession->Init<MyTriEdgeFlip>();	
+		/*bool b=*/FlipSession->DoOptimization();
+#ifndef _MESHLAB
+		printf("\n END FLIP SESSION %d edges \n",FlipSession->nPerfmormedOps);
+#endif
+		UpdateTopologies(&base_mesh);
+	}
+
+	///equilateralize patch lenght and areas
+	void EquiPatches()
+	{
+		PatchesOptimizer<BaseMesh> DomOpt(base_mesh,final_mesh);
+		DomOpt.OptimizePatches();
+		PrintAttributes();
+	}
+	
+	/// I/O FUNCTIONS
+	void SaveMCP(char* filename)
+	{
+		/*Warp(0);*/
+		FILE *f;
+		f=fopen(filename,"w+");
+		std::map<BaseFace*,int> facemap;
+		std::map<BaseVertex*,int> vertexmap;
+		typedef std::map<BaseVertex*,int>::iterator iteMapVert;
+		typedef std::map<BaseFace*,int>::iterator iteMapFace;
+
+		///add vertices
+		fprintf(f,"%d,%d \n",base_mesh.fn,base_mesh.vn);
+		int index=0;
+		for (unsigned int i=0;i<base_mesh.vert.size();i++)
+		{
+			BaseVertex* vert=&base_mesh.vert[i];
+			if (!vert->IsD())
+			{
+				vertexmap.insert(std::pair<BaseVertex*,int>(vert,index));
+				CoordType pos=vert->P();
+				CoordType RPos=vert->RPos;
+				fprintf(f,"%f,%f,%f;%f,%f,%f \n",pos.X(),pos.Y(),pos.Z(),RPos.X(),RPos.Y(),RPos.Z());
+				index++;
+			}
+		}
+
+		///add faces
+		index=0;
+		for (unsigned int i=0;i<base_mesh.face.size();i++)
+		{
+			BaseFace* face=&base_mesh.face[i];
+			if (!face->IsD())
+			{
+				BaseVertex* v0=face->V(0);
+				BaseVertex* v1=face->V(1);
+				BaseVertex* v2=face->V(2);
+				iteMapVert vertIte;
+				vertIte=vertexmap.find(v0);
+				assert(vertIte!=vertexmap.end());
+				int index0=(*vertIte).second;
+				vertIte=vertexmap.find(v1);
+				assert(vertIte!=vertexmap.end());
+				int index1=(*vertIte).second;
+				vertIte=vertexmap.find(v2);
+				assert(vertIte!=vertexmap.end());
+				int index2=(*vertIte).second;
+				assert((index0!=index1)&&(index1!=index2));
+				fprintf(f,"%d,%d,%d \n",index0,index1,index2);
+				facemap.insert(std::pair<BaseFace*,int>(face,index));
+				index++;
+			}
+		}
+
+		///high resolution mesh
+		fprintf(f,"%d,%d \n",final_mesh.fn,final_mesh.vn);
+
+		///add vertices
+		vertexmap.clear();
+		index=0;
+		for (unsigned int i=0;i<final_mesh.vert.size();i++)
+		{
+			BaseVertex* vert=&final_mesh.vert[i];
+			if (!vert->IsD())
+			{
+				vertexmap.insert(std::pair<BaseVertex*,int>(vert,index));
+				CoordType pos=vert->P();
+				CoordType bary=vert->Bary;
+				BaseFace* father=vert->father;
+				iteMapFace IteF=facemap.find(father);
+				assert (IteF!=facemap.end());
+				int indexface=(*IteF).second;
+				fprintf(f,"%f,%f,%f;%f,%f,%f;%d,%d,%d;%d \n",
+				pos.X(),pos.Y(),pos.Z(),bary.X(),bary.Y(),bary.Z(),
+				vert->OriginalCol.X(),vert->OriginalCol.Y(),vert->OriginalCol.Z(),
+				indexface);
+				index++;
+			}
+		}
+
+		///add faces
+		for (unsigned int i=0;i<final_mesh.face.size();i++)
+		{
+			BaseFace* face=&final_mesh.face[i];
+			if (!face->IsD())
+			{
+				BaseVertex* v0=face->V(0);
+				BaseVertex* v1=face->V(1);
+				BaseVertex* v2=face->V(2);
+				iteMapVert vertIte;
+				vertIte=vertexmap.find(v0);
+				assert(vertIte!=vertexmap.end());
+				int index0=(*vertIte).second;
+				vertIte=vertexmap.find(v1);
+				assert(vertIte!=vertexmap.end());
+				int index1=(*vertIte).second;
+				vertIte=vertexmap.find(v2);
+				assert(vertIte!=vertexmap.end());
+				int index2=(*vertIte).second;
+				assert((index0!=index1)&&(index1!=index2));
+				fprintf(f,"%d,%d,%d \n",index0,index1,index2);
+			}
+		}
+		fclose(f);
+	}
+
+	int LoadMCP(char* filename)
+	{
+		FILE *f=NULL;              
+		f=fopen(filename,"r");
+		if (f==NULL)
+			return -1;
+		/*std::map<BaseFace*,int> facemap;
+		std::map<BaseVertex*,int> vertexmap;
+		typedef std::map<BaseVertex*,int>::iterator iteMapVert;
+		typedef std::map<BaseFace*,int>::iterator iteMapFace;*/
+
+		
+
+		///add vertices
+		base_mesh.Clear();
+		fscanf(f,"%d,%d \n",&base_mesh.fn,&base_mesh.vn);
+		base_mesh.vert.resize(base_mesh.vn);
+		base_mesh.face.resize(base_mesh.fn);
+
+		for (unsigned int i=0;i<base_mesh.vert.size();i++)
+		{
+			BaseVertex* vert=&base_mesh.vert[i];
+			CoordType pos;
+			CoordType RPos;
+			fscanf(f,"%f,%f,%f;%f,%f,%f \n",&pos.X(),&pos.Y(),&pos.Z(),&RPos.X(),&RPos.Y(),&RPos.Z());
+			vert->P()=pos;
+			vert->RPos=RPos;
+		}
+
+		
+
+		///add faces
+		for (unsigned int i=0;i<base_mesh.face.size();i++)
+		{
+			BaseFace* face=&base_mesh.face[i];
+			if (!face->IsD())
+			{
+				int index0,index1,index2;
+				fscanf(f,"%d,%d,%d \n",&index0,&index1,&index2);
+				base_mesh.face[i].V(0)=&base_mesh.vert[index0];
+				base_mesh.face[i].V(1)=&base_mesh.vert[index1];
+				base_mesh.face[i].V(2)=&base_mesh.vert[index2];
+				base_mesh.face[i].group=vcg::Color4b(rand()%200,rand()%200,rand()%200,255);
+			}
+		}
+		
+		///high resolution mesh
+		fscanf(f,"%d,%d \n",&final_mesh.fn,&final_mesh.vn);
+		final_mesh.vert.resize(final_mesh.vn);
+		final_mesh.face.resize(final_mesh.fn);
+
+		///add vertices
+		for (unsigned int i=0;i<final_mesh.vert.size();i++)
+		{
+			BaseVertex* vert=&final_mesh.vert[i];
+			CoordType pos;
+			CoordType bary;
+			vcg::Color4b col;
+			int index_face;
+			int col0,col1,col2;
+			fscanf(f,"%f,%f,%f;%f,%f,%f;%d,%d,%d;%d \n",
+				  &pos.X(),&pos.Y(),&pos.Z(),
+				  &bary.X(),&bary.Y(),&bary.Z(),
+				  &col0,&col1,&col2,
+				  &index_face);
+			vert->P()=pos;
+			vert->RPos=pos;
+			vert->Bary=bary;
+			vert->father=&base_mesh.face[index_face];
+			assert(!base_mesh.face[index_face].IsD());
+			col=vcg::Color4b(col0,col1,col2,255);
+			vert->OriginalCol=col;
+			/*if (i==final_mesh.vert.size()-1)
+			{
+				printf("sukka %d \n",index_face);
+				char test;
+				scanf ("%c",&test);
+			}*/
+
+		}
+
+		///add faces
+		for (unsigned int i=0;i<final_mesh.face.size();i++)
+		{
+			//BaseFace* face=&final_mesh.face[i];
+			
+			int index0,index1,index2;
+			fscanf(f,"%d,%d,%d \n",&index0,&index1,&index2);
+			final_mesh.face[i].V(0)=&final_mesh.vert[index0];
+			final_mesh.face[i].V(1)=&final_mesh.vert[index1];
+			final_mesh.face[i].V(2)=&final_mesh.vert[index2];
+			
+		}
+		fclose(f);
+		
+		///update structures
+		UpdateStructures(&base_mesh);
+		UpdateStructures(&final_mesh);
+		//Colo
+		///clear father and bary
+		for (unsigned int i=0;i<base_mesh.face.size();i++)
+			base_mesh.face[i].vertices_bary.resize(0);
+
+		///set face-vertex link
+		for (unsigned int i=0;i<final_mesh.vert.size();i++)
+		{
+			BaseVertex *v=&final_mesh.vert[i];
+			BaseFace *f=v->father;
+			CoordType bary=v->Bary;
+			f->vertices_bary.push_back(std::pair<BaseVertex *,CoordType>(v,bary));
+		}
+		
+		//ColorByParametrization();
+		PrintAttributes();
+		//printf("faces:%5d AREA  distorsion:%lf\n",base_mesh.fn,ApproxAreaDistortion<BaseMesh>(final_mesh,base_mesh.fn));
+		//printf("faces:%5d ANGLE distorsion:%lf\n",base_mesh.fn,ApproxAngleDistortion<BaseMesh>(final_mesh));
+		
+		vcg::tri::UpdateBounding<BaseMesh>::Box(final_mesh);
+
+		///area perr vertex
+		for (unsigned int i=0;i<final_mesh.vert.size();i++)
+			//AuxHPara[i].area=0;
+			final_mesh.vert[i].area=0;
+
+		
+		for (unsigned int i=0;i<final_mesh.face.size();i++)
+		{
+			BaseFace *f=&final_mesh.face[i];
+			ScalarType areaf=(((f->V(1)->P()-f->V(0)->P())^(f->V(2)->P()-f->V(0)->P())).Norm())/(ScalarType)2.0;
+			/*AuxHPara[f->V(0)].area+=areaf/3.0;
+			AuxHPara[f->V(1)].area+=areaf/3.0;
+			AuxHPara[f->V(2)].area+=areaf/3.0;*/
+			f->V(0)->area+=areaf/(ScalarType)3.0;
+			f->V(1)->area+=areaf/(ScalarType)3.0;
+			f->V(2)->area+=areaf/(ScalarType)3.0;
+		}
+
+		return 0;
+	}
+	
+	void ExportMeshes(ParamMesh &para_mesh,AbstractMesh &abs_mesh)
+	{
+		para_mesh.Clear();
+		abs_mesh.Clear();
+
+		///copy meshes
+		vcg::tri::Append<AbstractMesh,BaseMesh>::Mesh(abs_mesh,base_mesh);
+		vcg::tri::Append<ParamMesh,BaseMesh>::Mesh(para_mesh,final_mesh);
+
+		///copy additional values
+		for (unsigned int i=0;i<base_mesh.vert.size();i++)
+		{
+			assert (!base_mesh.vert[i].IsD());
+			abs_mesh.vert[i].RPos=base_mesh.vert[i].RPos;
+		}
+
+		for (unsigned int i=0;i<final_mesh.vert.size();i++)
+			para_mesh.vert[i].RPos=final_mesh.vert[i].RPos;
+
+		///save in a table face-faces correspondences
+		std::map<BaseFace*,int> faceMap;
+		for (unsigned int i=0;i<base_mesh.face.size();i++)
+			faceMap.insert(std::pair<BaseFace*,int>(&base_mesh.face[i],i));
+
+		///then reassing with new mesh
+		for (unsigned int i=0;i<final_mesh.vert.size();i++)
+		{
+			std::map<BaseFace*,int>::iterator cur  = faceMap.find(final_mesh.vert[i].father);
+			assert(cur!= faceMap.end());
+			CoordType bary=final_mesh.vert[i].Bary;
+			int index=(*cur).second;
+			para_mesh.vert[i].T().N()=index;
+#ifdef _DEBUG
+			bool done=NormalizeBaryCoords(bary);
+			assert(done);
+#else
+			NormalizeBaryCoords(bary);
+#endif
+			para_mesh.vert[i].T().U()=bary.X();
+			para_mesh.vert[i].T().V()=bary.Y();
+			
+		}
+	}
+
+	//int draw_mode;
+	
+	void PrintAttributes()
+	{
+		int done=(final_mesh.fn-base_mesh.fn);
+		int total=(final_mesh.fn-lower_limit);
+		ScalarType ratio=(ScalarType)done/total;
+		ratio=pow(ratio,3);
+		int percent=(int)(ratio*(ScalarType)100);
+		ScalarType areaD=ApproxAreaDistortion<BaseMesh>(final_mesh,base_mesh.fn);
+		ScalarType angleD=ApproxAngleDistortion<BaseMesh>(final_mesh);
+		char ret[200];
+		sprintf(ret," GATHERING ABSTRACT DOMAIN faces:%5d AREA  distorsion:%4f ; ANGLE distorsion:%4f ",base_mesh.fn,areaD,angleD);
+		(*cb)(percent,ret);
+	}
+
+	void SetParameters(vcg::CallBackPos *_cb,
+					   const int &_lower_limit=100,
+					   const int &_interval=50,
+					   StopMode _SMode=SM_Euristic,
+					   const int &_accuracy=1)
+	{
+		lower_limit=_lower_limit;
+		interval=_interval;
+		accuracy=_accuracy;
+		SMode=_SMode;
+		ParaInfo::SM()=_SMode;
+		cb=_cb;
+	}
+	
+	void getValues(ScalarType &aggregate,
+						ScalarType &L2,
+						int &n_faces)
+	{
+	L2=ApproxL2Error(final_mesh);
+	ScalarType val0=ApproxAreaDistortion<BaseMesh>(final_mesh,base_mesh.fn);
+	ScalarType val1=ApproxAngleDistortion<BaseMesh>(final_mesh);
+	aggregate=geomAverage<ScalarType>(val0+1.0,val1+1.0,3,1)-1;
+	n_faces=base_mesh.fn;
+	}
+
+	IsoParametrizator()
+	{
+		///parameters
+		SMode=SM_Euristic;
+		lower_limit=40;
+		interval=50;
+		accuracy=1;
+	}
+
+};
+
+#endif
diff --git a/src/meshlabplugins/filter_isoparametrization/stat_remeshing.h b/src/meshlabplugins/filter_isoparametrization/stat_remeshing.h
index 65faecb0f..9e2d76f8a 100644
--- a/src/meshlabplugins/filter_isoparametrization/stat_remeshing.h
+++ b/src/meshlabplugins/filter_isoparametrization/stat_remeshing.h
@@ -1,343 +1,343 @@
-#include <vcg/complex/trimesh/update/topology.h>
-#include <vcg/complex/trimesh/update/flag.h>
-#include <vcg/space/triangle3.h>
-#include <wrap/io_trimesh/import_ply.h>
-#include <wrap/io_trimesh/export_ply.h>
-#include <vcg/simplex/face/pos.h>
-#include <vcg/math/histogram.h>
-
-#ifndef STAT_REMESHING
-#define STAT_REMESHING
-
-#define PI 3.14159265
-
-
-
-//return moltiplication of aspect ratio of faces of the mesh
-///to see if add + normalize is better
-template <class MeshType>
-typename MeshType::ScalarType MinimumAspectRatio(const MeshType &mesh)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::CoordType CoordType;
-	ScalarType res=1.f;
-        typename MeshType::ConstFaceIterator Fi;
-	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
-		if ((!(*Fi).IsD()))
-		{
-			ScalarType test=vcg::QualityRadii((*Fi).P(0),(*Fi).P(1),(*Fi).P(2));
-			if (test<res)
-				res=test;
-		}
-	return (res);
-}
-
-//return moltiplication of aspect ratio of faces of the mesh
-///to see if add + normalize is better
-template <class MeshType>
-typename MeshType::ScalarType MinimumArea(const MeshType &mesh)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::CoordType CoordType;
-	ScalarType res=10000.f;
-        typename MeshType::ConstFaceIterator Fi;
-	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
-		if ((!(*Fi).IsD()))
-		{
-			ScalarType test=vcg::DoubleArea(*Fi)/2.0;
-			if (test<res)
-				res=test;
-		}
-	return (res);
-}
-
-//return moltiplication of aspect ratio of faces of the mesh
-///to see if add + normalize is better
-template <class MeshType>
-typename MeshType::ScalarType MaximumArea(const MeshType &mesh)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::CoordType CoordType;
-	ScalarType res=0.f;
-        typename MeshType::ConstFaceIterator Fi;
-	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
-		if ((!(*Fi).IsD()))
-		{
-			ScalarType test=vcg::DoubleArea(*Fi)/2.0;
-			if (test>res)
-				res=test;
-		}
-	return (res);
-}
-
-//return moltiplication of aspect ratio of faces of the mesh
-///to see if add + normalize is better
-template <class FaceType>
-typename FaceType::ScalarType MinAngleFace(const FaceType &f)
-{
-	typedef typename FaceType::ScalarType ScalarType;
-	typedef typename FaceType::CoordType CoordType;
-	ScalarType res=360.0;
-	for (int i=0;i<3;i++)
-	{
-                CoordType v0=f.P((i+1)%3)-f.P(i);
-                CoordType v1=f.P((i+2)%3)-f.P(i);
-		v0.Normalize();
-		v1.Normalize();
-		ScalarType angle=acos(v0*v1)* 180.0 / PI;
-		if (angle<res)
-				res=angle;
-	}
-	assert(res<=60.0);
-	return (res);
-}
-
-//return moltiplication of aspect ratio of faces of the mesh
-///to see if add + normalize is better
-template <class FaceType>
-typename FaceType::ScalarType MaxAngleFace(const FaceType &f)
-{
-	typedef typename FaceType::ScalarType ScalarType;
-	typedef typename FaceType::CoordType CoordType;
-	ScalarType res=0;
-	for (int i=0;i<3;i++)
-	{
-                CoordType v0=f.P((i+1)%3)-f.P(i);
-                CoordType v1=f.P((i+2)%3)-f.P(i);
-		v0.Normalize();
-		v1.Normalize();
-		ScalarType angle=acos(v0*v1)* 180.0 / PI;
-		if (angle>res)
-				res=angle;
-	}
-	return (res);
-}
-
-template <class MeshType>
-typename MeshType::ScalarType MinAngle(const MeshType &mesh)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::CoordType CoordType;
-	ScalarType res=360.0;
-        typename MeshType::ConstFaceIterator Fi;
-	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
-		if ((!(*Fi).IsD()))
-		{
-			ScalarType testAngle=MinAngleFace(*Fi);
-			if (testAngle<res)
-				res=testAngle;
-		}
-	return (res);
-}
-
-template <class MeshType>
-typename MeshType::ScalarType MaxAngle(const MeshType &mesh)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::CoordType CoordType;
-	ScalarType res=0;
-        typename MeshType::ConstFaceIterator Fi;
-	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
-		if ((!(*Fi).IsD()))
-		{
-			ScalarType testAngle=MaxAngleFace(*Fi);
-			if (testAngle>res)
-				res=testAngle;
-		}
-	return (res);
-}
-
-template <class MeshType>
-void MaxMinEdge(const MeshType &mesh,typename MeshType::ScalarType &min,
-				typename MeshType::ScalarType &max)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::CoordType CoordType;
-	min=10000.0;
-	max=0.0;
-        typename MeshType::ConstFaceIterator Fi;
-	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
-		if ((!(*Fi).IsD()))
-		{
-
-			for (int i=0;i<3;i++)
-			{
-                                typename MeshType::VertexType* v0=(*Fi).V(i);
-                                typename MeshType::VertexType* v1=(*Fi).V((i+1)%3);
-				if (v0>v1)
-				{
-					ScalarType dist=(v0->P()-v1->P()).Norm();
-					if (dist<min)
-						min=dist;
-					if (dist>max)
-						max=dist;
-				}
-			}
-		}
-}
-////return moltiplication of aspect ratio of faces of the mesh
-/////to see if add + normalize is better
-//template <class MeshType>
-//ScalarType AverageMinAngle(const MeshType &mesh)
-//{
-//	ScalarType res=0;
-//	MeshType::ConstFaceIterator Fi;
-//	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
-//		if ((!(*Fi).IsD()))
-//		{
-//			ScalarType testAngle=MinAngleFace(*Fi);
-//			res+=testAngle;
-//		}
-//	return (res/((ScalarType)mesh.fn));
-//}
-
-template <class MeshType>
-void StatAspectRatio(MeshType &mesh, 
-		  typename MeshType::ScalarType &min,
-		  typename MeshType::ScalarType &average,
-		  typename MeshType::ScalarType &stand_dev)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-
-	vcg::Histogram<ScalarType> HAspectRatio;
-	
-	ScalarType minRatio=MinimumAspectRatio(mesh);
-	ScalarType maxRatio=1.f;
-	HAspectRatio.SetRange(minRatio,maxRatio,500);
-
-	
-        typename MeshType::FaceIterator Fi;
-	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
-			HAspectRatio.Add(vcg::QualityRadii((*Fi).P(0),(*Fi).P(1),(*Fi).P(2)));
-			
-	average=HAspectRatio.Avg();
-	stand_dev=HAspectRatio.StandardDeviation();
-	min=minRatio;
-}
-
-template <class MeshType>
-void StatArea(MeshType &mesh, 
-		 typename MeshType::ScalarType &min,
-		 typename MeshType::ScalarType &max,
-		 typename MeshType::ScalarType &average,
-		 typename MeshType::ScalarType &stand_dev)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::CoordType CoordType;
-
-	vcg::Histogram<ScalarType> HArea;
-	
-	ScalarType minArea=MinimumArea(mesh);
-	ScalarType maxArea=MaximumArea(mesh);
-	HArea.SetRange(minArea,maxArea,500);
-
-	
-        typename MeshType::FaceIterator Fi;
-	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
-	{
-		CoordType p0=(*Fi).P0(0);
-		CoordType p1=(*Fi).P1(0);
-		CoordType p2=(*Fi).P2(0);
-		ScalarType area=((p1-p0)^(p2-p0)).Norm()/2.0;
-		HArea.Add(area);
-	}
-			
-	average=HArea.Avg();
-	stand_dev=HArea.StandardDeviation();
-	min=minArea;
-	max=maxArea;
-}
-
-template <class MeshType>
-void StatAngle(MeshType &mesh, 
-		 typename MeshType::ScalarType &min,
-		 typename MeshType::ScalarType &max,
-		 typename MeshType::ScalarType &average,
-		 typename MeshType::ScalarType &stand_dev)
-{
-
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::VertexType VertexType;
-
-	vcg::Histogram<ScalarType> HAngle;
-	
-	ScalarType minAngle=MinAngle(mesh);
-	ScalarType maxAngle=MaxAngle(mesh);
-	HAngle.SetRange(minAngle,maxAngle,500);
-
-	
-        typename MeshType::FaceIterator Fi;
-	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
-		HAngle.Add(MinAngleFace((*Fi)));
-			
-	average=HAngle.Avg();
-	stand_dev=HAngle.StandardDeviation();
-	min=minAngle;
-	max=maxAngle;
-}
-
-template <class MeshType>
-void StatEdge(MeshType &mesh, 
-		 typename MeshType::ScalarType &min,
-		 typename MeshType::ScalarType &max,
-		 typename MeshType::ScalarType &average,
-		 typename MeshType::ScalarType &stand_dev)
-{
-	typedef typename MeshType::ScalarType ScalarType;
-	typedef typename MeshType::VertexType VertexType;
-
-	vcg::Histogram<ScalarType> HEdge;
-	
-	ScalarType minEdge;
-	ScalarType maxEdge;
-	MaxMinEdge(mesh,minEdge,maxEdge);
-	HEdge.SetRange(minEdge,maxEdge,500);
-
-	typedef typename MeshType::ScalarType ScalarType;
-        typename MeshType::FaceIterator Fi;
-	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
-	{
-		for (int i=0;i<3;i++)
-		{
-                                VertexType* v0=(*Fi).V(i);
-                                VertexType* v1=(*Fi).V((i+1)%3);
-				if ((v0>v1)||((*Fi).FFp(i)==&(*Fi)))
-				{
-					ScalarType dist=(v0->P()-v1->P()).Norm();
-					HEdge.Add(dist);
-				}
-		}
-	}
-
-	average=HEdge.Avg();
-	stand_dev=HEdge.StandardDeviation();
-	min=minEdge;
-	max=maxEdge;
-}
-
-template <class MeshType>
-int NumRegular(MeshType &mesh)
-{
-	typedef typename MeshType::FaceType FaceType;
-	///update topology
-	vcg::tri::UpdateTopology<MeshType>::VertexFace(mesh);
-        typename MeshType::VertexIterator Vi;
-	int irregular=0;
-	for (Vi=mesh.vert.begin();Vi!=mesh.vert.end();Vi++)
-	{
-		if ((!(*Vi).IsD())&&(!(*Vi).IsB()))
-		{
-			vcg::face::VFIterator<FaceType> VFI(&(*Vi));
-			int num=0;
-			while (!(VFI.End()))
-			{
-				num++;
-				++VFI;
-			}
-			if (num!=6)
-				irregular++;
-			}
-	}
-	return irregular;
-}
-#endif
+#include <vcg/complex/algorithms/update/topology.h>
+#include <vcg/complex/algorithms/update/flag.h>
+#include <vcg/space/triangle3.h>
+#include <wrap/io_trimesh/import_ply.h>
+#include <wrap/io_trimesh/export_ply.h>
+#include <vcg/simplex/face/pos.h>
+#include <vcg/math/histogram.h>
+
+#ifndef STAT_REMESHING
+#define STAT_REMESHING
+
+#define PI 3.14159265
+
+
+
+//return moltiplication of aspect ratio of faces of the mesh
+///to see if add + normalize is better
+template <class MeshType>
+typename MeshType::ScalarType MinimumAspectRatio(const MeshType &mesh)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::CoordType CoordType;
+	ScalarType res=1.f;
+        typename MeshType::ConstFaceIterator Fi;
+	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
+		if ((!(*Fi).IsD()))
+		{
+			ScalarType test=vcg::QualityRadii((*Fi).P(0),(*Fi).P(1),(*Fi).P(2));
+			if (test<res)
+				res=test;
+		}
+	return (res);
+}
+
+//return moltiplication of aspect ratio of faces of the mesh
+///to see if add + normalize is better
+template <class MeshType>
+typename MeshType::ScalarType MinimumArea(const MeshType &mesh)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::CoordType CoordType;
+	ScalarType res=10000.f;
+        typename MeshType::ConstFaceIterator Fi;
+	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
+		if ((!(*Fi).IsD()))
+		{
+			ScalarType test=vcg::DoubleArea(*Fi)/2.0;
+			if (test<res)
+				res=test;
+		}
+	return (res);
+}
+
+//return moltiplication of aspect ratio of faces of the mesh
+///to see if add + normalize is better
+template <class MeshType>
+typename MeshType::ScalarType MaximumArea(const MeshType &mesh)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::CoordType CoordType;
+	ScalarType res=0.f;
+        typename MeshType::ConstFaceIterator Fi;
+	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
+		if ((!(*Fi).IsD()))
+		{
+			ScalarType test=vcg::DoubleArea(*Fi)/2.0;
+			if (test>res)
+				res=test;
+		}
+	return (res);
+}
+
+//return moltiplication of aspect ratio of faces of the mesh
+///to see if add + normalize is better
+template <class FaceType>
+typename FaceType::ScalarType MinAngleFace(const FaceType &f)
+{
+	typedef typename FaceType::ScalarType ScalarType;
+	typedef typename FaceType::CoordType CoordType;
+	ScalarType res=360.0;
+	for (int i=0;i<3;i++)
+	{
+                CoordType v0=f.P((i+1)%3)-f.P(i);
+                CoordType v1=f.P((i+2)%3)-f.P(i);
+		v0.Normalize();
+		v1.Normalize();
+		ScalarType angle=acos(v0*v1)* 180.0 / PI;
+		if (angle<res)
+				res=angle;
+	}
+	assert(res<=60.0);
+	return (res);
+}
+
+//return moltiplication of aspect ratio of faces of the mesh
+///to see if add + normalize is better
+template <class FaceType>
+typename FaceType::ScalarType MaxAngleFace(const FaceType &f)
+{
+	typedef typename FaceType::ScalarType ScalarType;
+	typedef typename FaceType::CoordType CoordType;
+	ScalarType res=0;
+	for (int i=0;i<3;i++)
+	{
+                CoordType v0=f.P((i+1)%3)-f.P(i);
+                CoordType v1=f.P((i+2)%3)-f.P(i);
+		v0.Normalize();
+		v1.Normalize();
+		ScalarType angle=acos(v0*v1)* 180.0 / PI;
+		if (angle>res)
+				res=angle;
+	}
+	return (res);
+}
+
+template <class MeshType>
+typename MeshType::ScalarType MinAngle(const MeshType &mesh)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::CoordType CoordType;
+	ScalarType res=360.0;
+        typename MeshType::ConstFaceIterator Fi;
+	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
+		if ((!(*Fi).IsD()))
+		{
+			ScalarType testAngle=MinAngleFace(*Fi);
+			if (testAngle<res)
+				res=testAngle;
+		}
+	return (res);
+}
+
+template <class MeshType>
+typename MeshType::ScalarType MaxAngle(const MeshType &mesh)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::CoordType CoordType;
+	ScalarType res=0;
+        typename MeshType::ConstFaceIterator Fi;
+	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
+		if ((!(*Fi).IsD()))
+		{
+			ScalarType testAngle=MaxAngleFace(*Fi);
+			if (testAngle>res)
+				res=testAngle;
+		}
+	return (res);
+}
+
+template <class MeshType>
+void MaxMinEdge(const MeshType &mesh,typename MeshType::ScalarType &min,
+				typename MeshType::ScalarType &max)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::CoordType CoordType;
+	min=10000.0;
+	max=0.0;
+        typename MeshType::ConstFaceIterator Fi;
+	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
+		if ((!(*Fi).IsD()))
+		{
+
+			for (int i=0;i<3;i++)
+			{
+                                typename MeshType::VertexType* v0=(*Fi).V(i);
+                                typename MeshType::VertexType* v1=(*Fi).V((i+1)%3);
+				if (v0>v1)
+				{
+					ScalarType dist=(v0->P()-v1->P()).Norm();
+					if (dist<min)
+						min=dist;
+					if (dist>max)
+						max=dist;
+				}
+			}
+		}
+}
+////return moltiplication of aspect ratio of faces of the mesh
+/////to see if add + normalize is better
+//template <class MeshType>
+//ScalarType AverageMinAngle(const MeshType &mesh)
+//{
+//	ScalarType res=0;
+//	MeshType::ConstFaceIterator Fi;
+//	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
+//		if ((!(*Fi).IsD()))
+//		{
+//			ScalarType testAngle=MinAngleFace(*Fi);
+//			res+=testAngle;
+//		}
+//	return (res/((ScalarType)mesh.fn));
+//}
+
+template <class MeshType>
+void StatAspectRatio(MeshType &mesh, 
+		  typename MeshType::ScalarType &min,
+		  typename MeshType::ScalarType &average,
+		  typename MeshType::ScalarType &stand_dev)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+
+	vcg::Histogram<ScalarType> HAspectRatio;
+	
+	ScalarType minRatio=MinimumAspectRatio(mesh);
+	ScalarType maxRatio=1.f;
+	HAspectRatio.SetRange(minRatio,maxRatio,500);
+
+	
+        typename MeshType::FaceIterator Fi;
+	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
+			HAspectRatio.Add(vcg::QualityRadii((*Fi).P(0),(*Fi).P(1),(*Fi).P(2)));
+			
+	average=HAspectRatio.Avg();
+	stand_dev=HAspectRatio.StandardDeviation();
+	min=minRatio;
+}
+
+template <class MeshType>
+void StatArea(MeshType &mesh, 
+		 typename MeshType::ScalarType &min,
+		 typename MeshType::ScalarType &max,
+		 typename MeshType::ScalarType &average,
+		 typename MeshType::ScalarType &stand_dev)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::CoordType CoordType;
+
+	vcg::Histogram<ScalarType> HArea;
+	
+	ScalarType minArea=MinimumArea(mesh);
+	ScalarType maxArea=MaximumArea(mesh);
+	HArea.SetRange(minArea,maxArea,500);
+
+	
+        typename MeshType::FaceIterator Fi;
+	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
+	{
+		CoordType p0=(*Fi).P0(0);
+		CoordType p1=(*Fi).P1(0);
+		CoordType p2=(*Fi).P2(0);
+		ScalarType area=((p1-p0)^(p2-p0)).Norm()/2.0;
+		HArea.Add(area);
+	}
+			
+	average=HArea.Avg();
+	stand_dev=HArea.StandardDeviation();
+	min=minArea;
+	max=maxArea;
+}
+
+template <class MeshType>
+void StatAngle(MeshType &mesh, 
+		 typename MeshType::ScalarType &min,
+		 typename MeshType::ScalarType &max,
+		 typename MeshType::ScalarType &average,
+		 typename MeshType::ScalarType &stand_dev)
+{
+
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::VertexType VertexType;
+
+	vcg::Histogram<ScalarType> HAngle;
+	
+	ScalarType minAngle=MinAngle(mesh);
+	ScalarType maxAngle=MaxAngle(mesh);
+	HAngle.SetRange(minAngle,maxAngle,500);
+
+	
+        typename MeshType::FaceIterator Fi;
+	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
+		HAngle.Add(MinAngleFace((*Fi)));
+			
+	average=HAngle.Avg();
+	stand_dev=HAngle.StandardDeviation();
+	min=minAngle;
+	max=maxAngle;
+}
+
+template <class MeshType>
+void StatEdge(MeshType &mesh, 
+		 typename MeshType::ScalarType &min,
+		 typename MeshType::ScalarType &max,
+		 typename MeshType::ScalarType &average,
+		 typename MeshType::ScalarType &stand_dev)
+{
+	typedef typename MeshType::ScalarType ScalarType;
+	typedef typename MeshType::VertexType VertexType;
+
+	vcg::Histogram<ScalarType> HEdge;
+	
+	ScalarType minEdge;
+	ScalarType maxEdge;
+	MaxMinEdge(mesh,minEdge,maxEdge);
+	HEdge.SetRange(minEdge,maxEdge,500);
+
+	typedef typename MeshType::ScalarType ScalarType;
+        typename MeshType::FaceIterator Fi;
+	for (Fi=mesh.face.begin();Fi!=mesh.face.end();Fi++)
+	{
+		for (int i=0;i<3;i++)
+		{
+                                VertexType* v0=(*Fi).V(i);
+                                VertexType* v1=(*Fi).V((i+1)%3);
+				if ((v0>v1)||((*Fi).FFp(i)==&(*Fi)))
+				{
+					ScalarType dist=(v0->P()-v1->P()).Norm();
+					HEdge.Add(dist);
+				}
+		}
+	}
+
+	average=HEdge.Avg();
+	stand_dev=HEdge.StandardDeviation();
+	min=minEdge;
+	max=maxEdge;
+}
+
+template <class MeshType>
+int NumRegular(MeshType &mesh)
+{
+	typedef typename MeshType::FaceType FaceType;
+	///update topology
+	vcg::tri::UpdateTopology<MeshType>::VertexFace(mesh);
+        typename MeshType::VertexIterator Vi;
+	int irregular=0;
+	for (Vi=mesh.vert.begin();Vi!=mesh.vert.end();Vi++)
+	{
+		if ((!(*Vi).IsD())&&(!(*Vi).IsB()))
+		{
+			vcg::face::VFIterator<FaceType> VFI(&(*Vi));
+			int num=0;
+			while (!(VFI.End()))
+			{
+				num++;
+				++VFI;
+			}
+			if (num!=6)
+				irregular++;
+			}
+	}
+	return irregular;
+}
+#endif
diff --git a/src/meshlabplugins/filter_isoparametrization/tangent_space.h b/src/meshlabplugins/filter_isoparametrization/tangent_space.h
index e41ded393..62be560eb 100644
--- a/src/meshlabplugins/filter_isoparametrization/tangent_space.h
+++ b/src/meshlabplugins/filter_isoparametrization/tangent_space.h
@@ -1,498 +1,498 @@
-#ifndef _ISO_TANGENTSPACE
-#define _ISO_TANGENTSPACE
-#include "iso_parametrization.h"
-#include <vcg/complex/trimesh/update/curvature.h>
-#include <vcg/complex/trimesh/update/normal.h>
-
-class TangentSpace{
-	typedef IsoParametrization::CoordType CoordType;
-	typedef IsoParametrization::ScalarType ScalarType;
-	
-
-	vcg::SimpleTempData<typename ParamMesh::VertContainer,vcg::Matrix33<ScalarType> > *ProjMatrix;
-	
-public:
-	IsoParametrization *isoParam;
-	
-
-  bool isoParamTheta(int i, vcg::Point2<ScalarType> p, vcg::Point3<ScalarType> &res) const{
-    return isoParam->Theta(i,p,res);
-  }
-
-	//
-  void Theta(int i,
-		const vcg::Point2<ScalarType> &UV,
-		CoordType &pos3D){
-      isoParamTheta(i,UV,pos3D);
-  }
-	
-	bool Theta(const int &I,
-		const vcg::Point2<ScalarType> &alpha_beta, // alphaBeta
-		std::vector<ParamFace*> &face,
-		std::vector<CoordType> &baryVal)
-	{
-      int ret=isoParam->Theta(I,alpha_beta,face,baryVal);
-			return (ret!=-1);
-  }
-
-	///initialize the sampler 
-	void Init(IsoParametrization *_isoParam,ScalarType radius=(ScalarType)0.1)
-	{
-		isoParam=_isoParam;
-		ProjMatrix   = new vcg::SimpleTempData<typename ParamMesh::VertContainer,vcg::Matrix33<ScalarType> > (isoParam->ParaMesh()->vert);
-		
-		InitProjectionMatrix(radius);
-		vcg::tri::UpdateNormals<ParamMesh>::PerFaceNormalized(*isoParam->ParaMesh());
-		vcg::tri::UpdateCurvature<ParamMesh>::PrincipalDirectionsNormalCycles(*isoParam->ParaMesh());
-	}
-	
-	///given an initial position in parametric space (I0,bary0)
-	///and a 2D vector (vect) expressed in parametric space modify the final 
-	///position (I1,bary1) abd return true if everithing was ok, false otherwise
-	bool Sum(const int &I0,const vcg::Point2<ScalarType> &bary0,
-			 const vcg::Point2<ScalarType> &vect,
-			 int &I1,vcg::Point2<ScalarType> &bary1,int &domain) const
-	{
-    
-		
-		vcg::Point2<ScalarType> dest=bary0+vect;
-      //vect[0]*Xaxis + vect[1]*Yaxis;
-		ScalarType alpha=dest.X();
-		ScalarType beta=dest.Y();
-		///point inside the face
-		if ((alpha>=0)&&(alpha<=1)&&(beta>=0)&&(beta<=1)&&((alpha+beta)<=1))
-		{
-			bary1=dest;
-			I1=I0;
-			domain=0;
-			return true;
-		}
-		
-		///control edges
-		int edge=-1;
-		if ((alpha<=1)&&(beta<=1)&&((alpha+beta)>=1))
-			edge=0;
-		else
-		if ((alpha<=0)&&(beta<=1)&&((alpha+beta)>=0))
-			edge=1;
-		else
-		if ((alpha<=1)&&(beta<=0)&&((alpha+beta)>=0))
-			edge=2;
-		if (edge!=-1)
-		{
-			int DiamIndex=isoParam->GetDiamond(I0,edge);
-			vcg::Point2<ScalarType> UVDiam;
-			///transform to diamond coordinates
-			isoParam->GE1(I0,dest,DiamIndex,UVDiam);
-			///trasform back to I,alpha,beta
-			isoParam->inv_GE1(DiamIndex,UVDiam,I1,bary1);
-			domain=1;
-			return true;
-		}
-		int star=-1;
-		ScalarType gamma=(1-alpha-beta);
-		if ((alpha>beta)&&(alpha>gamma))
-			star=0;
-		else
-		if ((beta>alpha)&&(beta>gamma))
-			star=1;
-		else
-			star=2;
-
-		///get the index of star
-		int StarIndex=isoParam->GetStarIndex(I0,star);
-		vcg::Point2<ScalarType> UVHstar;
-		///transform to UV
-		bool found=isoParam->GE0(I0,dest,StarIndex,UVHstar);
-		///trasform back to I,alpha,beta
-		if (!found)
-			return false;
-		found=isoParam->inv_GE0(StarIndex,UVHstar,I1,bary1);
-		/*AbstractFace* f0=&isoParam->AbsMesh()->face[I0];
-			AbstractFace* f1=&isoParam->AbsMesh()->face[I1];
-			AbstractVertex *v0=f0->V(0);
-			AbstractVertex *v1=f0->V(1);
-			AbstractVertex *v2=f0->V(2);
-			AbstractVertex *v3=f1->V(0);
-			AbstractVertex *v4=f1->V(1);
-			AbstractVertex *v5=f1->V(2);*/
-		domain=2;
-		return found;
-	}
-	
-	///given two positions in parametric space (I0,bary0) and (I1,bary1)
-	///modify the 2D vector (vect) and return true if everithing was ok, false otherwise
-	bool Sub(const int &I0,const vcg::Point2<ScalarType> &bary0,
-			 const int &I1,const vcg::Point2<ScalarType> &bary1,
-			 vcg::Point2<ScalarType> &vect,int &num) const
-	{
-		int IndexDomain;
-		num=isoParam->InterpolationSpace(I0,I1,IndexDomain);
-		///is a face
-		if (num==0)
-		{
-			//printf("F");
-			assert(I0==I1);
-			vect=bary0-bary1;
-			return true;
-		}
-		else
-		///a diamond
-		if (num==1)
-		{
-			//printf("D");
-			///tranform in UV space
-			vcg::Point2<ScalarType> UVDiam;
-			isoParam->GE1(I1,bary1,IndexDomain,UVDiam);
-			///then find bary coords wich respect to the first face
-			vcg::Point2<ScalarType> bary2;
-			isoParam->inv_GE1_fixedI(IndexDomain,UVDiam,I0,bary2);
-			vect=bary0-bary2;
-			return true;
-		}
-		else
-		///a star
-		if (num==2)
-		{
-			//printf("S");
-			///tranform in UV space
-			vcg::Point2<ScalarType> UVStar;
-			isoParam->GE0(I1,bary1,IndexDomain,UVStar);
-			///then find bary coords wich respect to the first face
-			vcg::Point2<ScalarType> bary2;
-			isoParam->inv_GE0_fixedI(IndexDomain,UVStar,I0,bary2);
-			vect=bary0-bary2;
-			
-			return true;
-		}
-		else 
-			return false;
-	}
-	
-	bool TangentDir(const int &I,const vcg::Point2<ScalarType> &bary,
-			   CoordType &XAxis,CoordType &YAxis,ScalarType radius=(ScalarType)0.5) const
-	{
-		///3d position of origin
-		//CoordType origin;
-		//isoParam->Theta(I,bary,origin);
-
-    // two axis in alpha-beta space that will be orthogonal in UV-Space
-		const ScalarType h=(ScalarType)2.0/sqrt((ScalarType)3.0);
-		vcg::Point2<ScalarType> XP=vcg::Point2<ScalarType>(1,0);
-		vcg::Point2<ScalarType> YP=vcg::Point2<ScalarType>(-0.5,h);
-		
-		XP*=radius;
-		YP*=radius;
-		vcg::Point2<ScalarType> XM=-XP;
-		vcg::Point2<ScalarType> YM=-YP;
-		//Yaxis.Normalize();
-		
-		vcg::Point2<ScalarType> bary0,bary1,bary2,bary3;
-		int I0,I1,I2,I3;
-		CoordType X0,X1,Y0,Y1;
-		///find paraCoords of four neighbors
-		int domain;
-		bool done=true;
-    done&=Sum(I,bary,XP,I0,bary0,domain);
-		done&=Sum(I,bary,XM,I1,bary1,domain);
-		done&=Sum(I,bary,YP,I2,bary2,domain);
-		done&=Sum(I,bary,YM,I3,bary3,domain);
-		if (!done)
-			return false;
-
-		//if (I0!=I1 || I1!=I2 || I2!=I3) return false;
-
-		///get 3d position
-		isoParamTheta(I0,bary0,X0);
-		isoParamTheta(I1,bary1,X1);
-		isoParamTheta(I2,bary2,Y0);
-		isoParamTheta(I3,bary3,Y1);
-		
-		
-		///average .. considering one is opposite respect to the other
-		XAxis=(X0-X1)/(ScalarType)2.0;
-		YAxis=(Y0-Y1)/(ScalarType)2.0;
-		///final scaling 
-		XAxis/=radius;
-		YAxis/=radius;
-		return true;
-	}
-
-	void Test(int Sample=100,int Ite=100) 
-	{
-		int max=isoParam->AbsMesh()->face.size();
-		for (int I=0;I<max;I++)
-		{
-			printf("\n TESTING %d \n",I);
-			for (int i=0;i<Sample;i++)
-			{
-				for (int j=0;j<Sample;j++)
-				{
-					if ((i+j)<Sample)
-					{
-						ScalarType alpha=(ScalarType)i/(ScalarType)Sample;
-						ScalarType beta=(ScalarType)j/(ScalarType)Sample;
-						assert((alpha+beta)<=1.0);
-						vcg::Point2<ScalarType> bary=vcg::Point2<ScalarType>(alpha,beta);
-						assert((bary.X()>=0)&&(bary.X()<=1));
-						assert((bary.Y()>=0)&&(bary.Y()<=1));
-						assert((bary.X()+bary.Y()<=1));
-						
-						for (int k=0;k<Ite;k++)
-						{
-							ScalarType d0=((ScalarType)(rand()%1000));
-							ScalarType d1=((ScalarType)(rand()%1000));
-							vcg::Point2<ScalarType> vect=vcg::Point2<ScalarType>(d0,d1);
-							vect.Normalize();
-							ScalarType norm=(ScalarType)0.05;//((ScalarType)(rand()%1000))/(ScalarType)2000;
-							assert(norm<1);
-							vect*=norm;
-							int I1;
-							vcg::Point2<ScalarType> bary1;
-							vcg::Point2<ScalarType> vect1;
-							int domain0;
-							bool b1=Sum(I,bary,vect,I1,bary1,domain0);
-							assert(b1);
-
-							assert((bary1.X()>=0)&&(bary1.X()<=1));
-							assert((bary1.Y()>=0)&&(bary1.Y()<=1));
-							if(!((bary1.X()+bary1.Y())<=1.00001))
-							{
-								printf("\n SUM %.4f \n",bary1.X()+bary1.Y());
-								assert(0);
-							}
-							assert(I1<max);
-							int domain;
-							bool b2=Sub(I,bary,I1,bary1,vect1,domain);
-							assert(b2);
-							ScalarType diff=(vect1+vect).Norm();
-							if (domain0==0)
-								assert(domain==0);
-							if ((domain0==1)&&(domain==2))
-								assert(0);
-							/*if (domain0!=domain)
-								assert(0);*/
-							if (diff>0.001)
-							{
-								printf("\n DIFF %.4f domain SUM %d domain SUB %d \n",diff,domain0,domain);
-								//assert(0);
-							}
-							//assert(fabs(vect1.X()-vect.X())<0.0001);
-							//assert(fabs(vect1.Y()-vect.Y())<0.0001);
-							
-						}
-					}
-				}
-			}
-		}
-	}
-	
-	void InitProjectionMatrix(ScalarType radius=(ScalarType)0.1)
-	{
-		for (int i=0;i<isoParam->ParaMesh()->vert.size();i++)
-		{
-			int I=isoParam->ParaMesh()->vert[i].T().N();
-			vcg::Point2<ScalarType> bary=isoParam->ParaMesh()->vert[i].T().P();
-			
-			CoordType origin;
-			isoParamTheta(I,bary,origin);
-			CoordType XAxis,YAxis; // tangent axis in 3D Object space
-			///get tangent directions
-			
-			bool done=TangentDir(I,bary,XAxis,YAxis,(ScalarType)0.1);
-			if (!done)
-			{
-				(*ProjMatrix)[i].SetIdentity();
-				continue;
-			}
-		
-			// must compute res2d such that:  res2d.X() * XAxis + res2d.Y() * YAxis + dontCare * ZAxis = vect3d
-			CoordType ZAxis = -(XAxis^YAxis).Normalize()*XAxis.Norm();
-			
-			(*ProjMatrix)[i].SetColumn(0,XAxis);
-			(*ProjMatrix)[i].SetColumn(1,YAxis);
-			(*ProjMatrix)[i].SetColumn(2,ZAxis);
-			vcg::Invert((*ProjMatrix)[i]);
-		}
-	}
-
-	void GetCurvature(const int &I,const vcg::Point2<ScalarType> &alpha_beta,
-					  CoordType &d1,CoordType &d2,ScalarType &k1,ScalarType &k2)
-	{
-		ParamFace* face=NULL;
-		CoordType baryVal;
-		isoParam->Theta(I,alpha_beta,face,baryVal);
-		ParamVertex *v0=face->V(0);
-		ParamVertex *v1=face->V(1);
-		ParamVertex *v2=face->V(2);
-		d1=v0->PD1()*baryVal.X()+v1->PD1()*baryVal.Y()+v2->PD1()*baryVal.Z();
-		d2=v0->PD2()*baryVal.X()+v1->PD2()*baryVal.Y()+v2->PD2()*baryVal.Z();
-		k1=v0->K1()*baryVal.X()+v1->K1()*baryVal.Y()+v2->K1()*baryVal.Z();
-		k2=v0->K2()*baryVal.X()+v1->K2()*baryVal.Y()+v2->K2()*baryVal.Z();
-	}
-
-	void GetProjectionMatrix(const int &I,const vcg::Point2<ScalarType> &alpha_beta,
-						     vcg::Matrix33<ScalarType> &projMatr) const
-	{
-		ParamFace* face=NULL;
-		CoordType baryVal;
-		int dom=isoParam->Theta(I,alpha_beta,face,baryVal);
-		if (dom==-1)
-		{
-			projMatr.SetIdentity();
-			return;
-		}
-		ParamVertex *v0=face->V(0);
-		ParamVertex *v1=face->V(1);
-		ParamVertex *v2=face->V(2);
-
-		projMatr=(*ProjMatrix)[v0]*baryVal.X();
-		projMatr+=(*ProjMatrix)[v1]*baryVal.Y();
-		projMatr+=(*ProjMatrix)[v2]*baryVal.Z();
-	}
-
-	
-	bool Project(const int &I,const vcg::Point2<ScalarType> &bary,
-				 const CoordType &vect3d, // in object space
-				 vcg::Point2<ScalarType> &res2d) const
-	{
-		vcg::Matrix33f m;
-		GetProjectionMatrix(I,bary,m);
-
-		ScalarType deltaX=vect3d*m.GetRow(0);
-		ScalarType deltaY=vect3d*m.GetRow(1);
-		
-		// two axis in alpha-beta space that will be orthogonal in UV-Space
-		const ScalarType h=(ScalarType)2.0/sqrt((ScalarType)3.0);
-		vcg::Point2<ScalarType> XP=vcg::Point2<ScalarType>(1,0);
-		vcg::Point2<ScalarType> YP=vcg::Point2<ScalarType>(-0.5,h);
-		res2d = XP*deltaX + YP*deltaY;
-		//res2d=vcg::Point2<ScalarType>(deltaX,deltaY);
-
-		return true;
-	}
-
-	 // WEIGHTED INTERPOLATION OF POINTS IN TANGENT SPACE 
-	///	weights MUST be normalized
-	bool Interpolate(const int &I0,const vcg::Point2<ScalarType> &alpha_beta0,
-					 const int &I1,const vcg::Point2<ScalarType> &alpha_beta1,
-					 ScalarType weight,
-					 int &I_res,
-					 vcg::Point2<ScalarType> &alpha_beta_res)
-	{
-		int IndexDomain;
-		int kind=isoParam->InterpolationSpace(I0,I1,IndexDomain);
-		if (kind==-1)
-			return false;
-
-		vcg::Point2<ScalarType> transformed0,transformed1;
-		
-		///interpolate in a face
-		if (kind==0)
-		{
-			isoParam->GE2(IndexDomain,alpha_beta0,transformed0);
-			isoParam->GE2(IndexDomain,alpha_beta1,transformed1);
-		}
-		else
-		///interpolate in a diamond
-		if (kind==1)
-		{				
-			isoParam->GE1(I0,alpha_beta0,IndexDomain,transformed0);		
-			isoParam->GE1(I1,alpha_beta1,IndexDomain,transformed1);		
-		}
-		else
-		{
-			isoParam->GE0(I0,alpha_beta0,IndexDomain,transformed0);
-			isoParam->GE0(I1,alpha_beta1,IndexDomain,transformed1);
-		}
-
-		vcg::Point2<ScalarType> UV_interp=transformed0*weight+transformed1*(1.0-weight);
-		///FINALLY......
-		///transform back to alpha,beta,I
-		if (kind==0)
-		{
-			isoParam->inv_GE2(IndexDomain,UV_interp,alpha_beta_res);
-			I_res=IndexDomain;
-		}
-		else
-		if (kind==1)
-		{
-			isoParam->inv_GE1(IndexDomain,UV_interp,I_res,alpha_beta_res);
-		}
-		else
-			isoParam->inv_GE0(IndexDomain,UV_interp,I_res,alpha_beta_res);
-		return true;
-	}
-
-	ScalarType AbstractArea()
-	{
-		ScalarType Cnum=sqrt(3.0)/4.0;
-		return(isoParam->AbsMesh()->fn*Cnum);
-	}
-
-    // WEIGHTED INTERPOLATION OF POINTS IN TANGENT SPACE 
-	///	weights MUST be normalized
-	bool Interpolate(const std::vector<int> &I,
-					 const std::vector<vcg::Point2<ScalarType> > &alpha_beta,
-					 const std::vector<ScalarType> &weights,
-					 int &I_res,
-					 vcg::Point2<ScalarType> &alpha_beta_res,
-					 int *num=NULL)
-	{
-		int size;
-		if (num==NULL)
-			size=alpha_beta.size();
-		else
-			size=*num;
-
-		int IndexDomain;
-		int kind=isoParam->InterpolationSpace(I,IndexDomain,num);
-		if (kind==-1)
-			return false;
-
-		std::vector<vcg::Point2<ScalarType> > transformed;
-		transformed.resize(size);
-		
-		///interpolate in a face
-		if (kind==0)
-		{
-			for (int i=0;i<size;i++)
-				isoParam->GE2(IndexDomain,alpha_beta[i],transformed[i]);
-		}
-		else
-		///interpolate in a diamond
-		if (kind==1)
-		{				
-			for (int i=0;i<size;i++)
-				isoParam->GE1(I[i],alpha_beta[i],IndexDomain,transformed[i]);		
-		}
-		else
-		{
-			for (int i=0;i<size;i++)
-				bool b0=isoParam->GE0(I[i],alpha_beta[i],IndexDomain,transformed[i]);
-		}
-
-		/// do the interpolation
-		vcg::Point2<ScalarType> UV_interp=vcg::Point2<ScalarType>(0,0);
-		for (int i=0;i<size;i++)
-			UV_interp+=(transformed[i]*weights[i]);
-		
-		///FINALLY......
-		///transform back to alpha,beta,I
-		if (kind==0)
-		{
-			isoParam->inv_GE2(IndexDomain,UV_interp,alpha_beta_res);
-			I_res=IndexDomain;
-		}
-		else
-		if (kind==1)
-		{
-			isoParam->inv_GE1(IndexDomain,UV_interp,I_res,alpha_beta_res);
-		}
-		else
-			isoParam->inv_GE0(IndexDomain,UV_interp,I_res,alpha_beta_res);
-		return true;
-	}
-
-};
-#endif
+#ifndef _ISO_TANGENTSPACE
+#define _ISO_TANGENTSPACE
+#include "iso_parametrization.h"
+#include <vcg/complex/algorithms/update/curvature.h>
+#include <vcg/complex/algorithms/update/normal.h>
+
+class TangentSpace{
+	typedef IsoParametrization::CoordType CoordType;
+	typedef IsoParametrization::ScalarType ScalarType;
+	
+
+	vcg::SimpleTempData<typename ParamMesh::VertContainer,vcg::Matrix33<ScalarType> > *ProjMatrix;
+	
+public:
+	IsoParametrization *isoParam;
+	
+
+  bool isoParamTheta(int i, vcg::Point2<ScalarType> p, vcg::Point3<ScalarType> &res) const{
+    return isoParam->Theta(i,p,res);
+  }
+
+	//
+  void Theta(int i,
+		const vcg::Point2<ScalarType> &UV,
+		CoordType &pos3D){
+      isoParamTheta(i,UV,pos3D);
+  }
+	
+	bool Theta(const int &I,
+		const vcg::Point2<ScalarType> &alpha_beta, // alphaBeta
+		std::vector<ParamFace*> &face,
+		std::vector<CoordType> &baryVal)
+	{
+      int ret=isoParam->Theta(I,alpha_beta,face,baryVal);
+			return (ret!=-1);
+  }
+
+	///initialize the sampler 
+	void Init(IsoParametrization *_isoParam,ScalarType radius=(ScalarType)0.1)
+	{
+		isoParam=_isoParam;
+		ProjMatrix   = new vcg::SimpleTempData<typename ParamMesh::VertContainer,vcg::Matrix33<ScalarType> > (isoParam->ParaMesh()->vert);
+		
+		InitProjectionMatrix(radius);
+		vcg::tri::UpdateNormals<ParamMesh>::PerFaceNormalized(*isoParam->ParaMesh());
+		vcg::tri::UpdateCurvature<ParamMesh>::PrincipalDirectionsNormalCycles(*isoParam->ParaMesh());
+	}
+	
+	///given an initial position in parametric space (I0,bary0)
+	///and a 2D vector (vect) expressed in parametric space modify the final 
+	///position (I1,bary1) abd return true if everithing was ok, false otherwise
+	bool Sum(const int &I0,const vcg::Point2<ScalarType> &bary0,
+			 const vcg::Point2<ScalarType> &vect,
+			 int &I1,vcg::Point2<ScalarType> &bary1,int &domain) const
+	{
+    
+		
+		vcg::Point2<ScalarType> dest=bary0+vect;
+      //vect[0]*Xaxis + vect[1]*Yaxis;
+		ScalarType alpha=dest.X();
+		ScalarType beta=dest.Y();
+		///point inside the face
+		if ((alpha>=0)&&(alpha<=1)&&(beta>=0)&&(beta<=1)&&((alpha+beta)<=1))
+		{
+			bary1=dest;
+			I1=I0;
+			domain=0;
+			return true;
+		}
+		
+		///control edges
+		int edge=-1;
+		if ((alpha<=1)&&(beta<=1)&&((alpha+beta)>=1))
+			edge=0;
+		else
+		if ((alpha<=0)&&(beta<=1)&&((alpha+beta)>=0))
+			edge=1;
+		else
+		if ((alpha<=1)&&(beta<=0)&&((alpha+beta)>=0))
+			edge=2;
+		if (edge!=-1)
+		{
+			int DiamIndex=isoParam->GetDiamond(I0,edge);
+			vcg::Point2<ScalarType> UVDiam;
+			///transform to diamond coordinates
+			isoParam->GE1(I0,dest,DiamIndex,UVDiam);
+			///trasform back to I,alpha,beta
+			isoParam->inv_GE1(DiamIndex,UVDiam,I1,bary1);
+			domain=1;
+			return true;
+		}
+		int star=-1;
+		ScalarType gamma=(1-alpha-beta);
+		if ((alpha>beta)&&(alpha>gamma))
+			star=0;
+		else
+		if ((beta>alpha)&&(beta>gamma))
+			star=1;
+		else
+			star=2;
+
+		///get the index of star
+		int StarIndex=isoParam->GetStarIndex(I0,star);
+		vcg::Point2<ScalarType> UVHstar;
+		///transform to UV
+		bool found=isoParam->GE0(I0,dest,StarIndex,UVHstar);
+		///trasform back to I,alpha,beta
+		if (!found)
+			return false;
+		found=isoParam->inv_GE0(StarIndex,UVHstar,I1,bary1);
+		/*AbstractFace* f0=&isoParam->AbsMesh()->face[I0];
+			AbstractFace* f1=&isoParam->AbsMesh()->face[I1];
+			AbstractVertex *v0=f0->V(0);
+			AbstractVertex *v1=f0->V(1);
+			AbstractVertex *v2=f0->V(2);
+			AbstractVertex *v3=f1->V(0);
+			AbstractVertex *v4=f1->V(1);
+			AbstractVertex *v5=f1->V(2);*/
+		domain=2;
+		return found;
+	}
+	
+	///given two positions in parametric space (I0,bary0) and (I1,bary1)
+	///modify the 2D vector (vect) and return true if everithing was ok, false otherwise
+	bool Sub(const int &I0,const vcg::Point2<ScalarType> &bary0,
+			 const int &I1,const vcg::Point2<ScalarType> &bary1,
+			 vcg::Point2<ScalarType> &vect,int &num) const
+	{
+		int IndexDomain;
+		num=isoParam->InterpolationSpace(I0,I1,IndexDomain);
+		///is a face
+		if (num==0)
+		{
+			//printf("F");
+			assert(I0==I1);
+			vect=bary0-bary1;
+			return true;
+		}
+		else
+		///a diamond
+		if (num==1)
+		{
+			//printf("D");
+			///tranform in UV space
+			vcg::Point2<ScalarType> UVDiam;
+			isoParam->GE1(I1,bary1,IndexDomain,UVDiam);
+			///then find bary coords wich respect to the first face
+			vcg::Point2<ScalarType> bary2;
+			isoParam->inv_GE1_fixedI(IndexDomain,UVDiam,I0,bary2);
+			vect=bary0-bary2;
+			return true;
+		}
+		else
+		///a star
+		if (num==2)
+		{
+			//printf("S");
+			///tranform in UV space
+			vcg::Point2<ScalarType> UVStar;
+			isoParam->GE0(I1,bary1,IndexDomain,UVStar);
+			///then find bary coords wich respect to the first face
+			vcg::Point2<ScalarType> bary2;
+			isoParam->inv_GE0_fixedI(IndexDomain,UVStar,I0,bary2);
+			vect=bary0-bary2;
+			
+			return true;
+		}
+		else 
+			return false;
+	}
+	
+	bool TangentDir(const int &I,const vcg::Point2<ScalarType> &bary,
+			   CoordType &XAxis,CoordType &YAxis,ScalarType radius=(ScalarType)0.5) const
+	{
+		///3d position of origin
+		//CoordType origin;
+		//isoParam->Theta(I,bary,origin);
+
+    // two axis in alpha-beta space that will be orthogonal in UV-Space
+		const ScalarType h=(ScalarType)2.0/sqrt((ScalarType)3.0);
+		vcg::Point2<ScalarType> XP=vcg::Point2<ScalarType>(1,0);
+		vcg::Point2<ScalarType> YP=vcg::Point2<ScalarType>(-0.5,h);
+		
+		XP*=radius;
+		YP*=radius;
+		vcg::Point2<ScalarType> XM=-XP;
+		vcg::Point2<ScalarType> YM=-YP;
+		//Yaxis.Normalize();
+		
+		vcg::Point2<ScalarType> bary0,bary1,bary2,bary3;
+		int I0,I1,I2,I3;
+		CoordType X0,X1,Y0,Y1;
+		///find paraCoords of four neighbors
+		int domain;
+		bool done=true;
+    done&=Sum(I,bary,XP,I0,bary0,domain);
+		done&=Sum(I,bary,XM,I1,bary1,domain);
+		done&=Sum(I,bary,YP,I2,bary2,domain);
+		done&=Sum(I,bary,YM,I3,bary3,domain);
+		if (!done)
+			return false;
+
+		//if (I0!=I1 || I1!=I2 || I2!=I3) return false;
+
+		///get 3d position
+		isoParamTheta(I0,bary0,X0);
+		isoParamTheta(I1,bary1,X1);
+		isoParamTheta(I2,bary2,Y0);
+		isoParamTheta(I3,bary3,Y1);
+		
+		
+		///average .. considering one is opposite respect to the other
+		XAxis=(X0-X1)/(ScalarType)2.0;
+		YAxis=(Y0-Y1)/(ScalarType)2.0;
+		///final scaling 
+		XAxis/=radius;
+		YAxis/=radius;
+		return true;
+	}
+
+	void Test(int Sample=100,int Ite=100) 
+	{
+		int max=isoParam->AbsMesh()->face.size();
+		for (int I=0;I<max;I++)
+		{
+			printf("\n TESTING %d \n",I);
+			for (int i=0;i<Sample;i++)
+			{
+				for (int j=0;j<Sample;j++)
+				{
+					if ((i+j)<Sample)
+					{
+						ScalarType alpha=(ScalarType)i/(ScalarType)Sample;
+						ScalarType beta=(ScalarType)j/(ScalarType)Sample;
+						assert((alpha+beta)<=1.0);
+						vcg::Point2<ScalarType> bary=vcg::Point2<ScalarType>(alpha,beta);
+						assert((bary.X()>=0)&&(bary.X()<=1));
+						assert((bary.Y()>=0)&&(bary.Y()<=1));
+						assert((bary.X()+bary.Y()<=1));
+						
+						for (int k=0;k<Ite;k++)
+						{
+							ScalarType d0=((ScalarType)(rand()%1000));
+							ScalarType d1=((ScalarType)(rand()%1000));
+							vcg::Point2<ScalarType> vect=vcg::Point2<ScalarType>(d0,d1);
+							vect.Normalize();
+							ScalarType norm=(ScalarType)0.05;//((ScalarType)(rand()%1000))/(ScalarType)2000;
+							assert(norm<1);
+							vect*=norm;
+							int I1;
+							vcg::Point2<ScalarType> bary1;
+							vcg::Point2<ScalarType> vect1;
+							int domain0;
+							bool b1=Sum(I,bary,vect,I1,bary1,domain0);
+							assert(b1);
+
+							assert((bary1.X()>=0)&&(bary1.X()<=1));
+							assert((bary1.Y()>=0)&&(bary1.Y()<=1));
+							if(!((bary1.X()+bary1.Y())<=1.00001))
+							{
+								printf("\n SUM %.4f \n",bary1.X()+bary1.Y());
+								assert(0);
+							}
+							assert(I1<max);
+							int domain;
+							bool b2=Sub(I,bary,I1,bary1,vect1,domain);
+							assert(b2);
+							ScalarType diff=(vect1+vect).Norm();
+							if (domain0==0)
+								assert(domain==0);
+							if ((domain0==1)&&(domain==2))
+								assert(0);
+							/*if (domain0!=domain)
+								assert(0);*/
+							if (diff>0.001)
+							{
+								printf("\n DIFF %.4f domain SUM %d domain SUB %d \n",diff,domain0,domain);
+								//assert(0);
+							}
+							//assert(fabs(vect1.X()-vect.X())<0.0001);
+							//assert(fabs(vect1.Y()-vect.Y())<0.0001);
+							
+						}
+					}
+				}
+			}
+		}
+	}
+	
+	void InitProjectionMatrix(ScalarType radius=(ScalarType)0.1)
+	{
+		for (int i=0;i<isoParam->ParaMesh()->vert.size();i++)
+		{
+			int I=isoParam->ParaMesh()->vert[i].T().N();
+			vcg::Point2<ScalarType> bary=isoParam->ParaMesh()->vert[i].T().P();
+			
+			CoordType origin;
+			isoParamTheta(I,bary,origin);
+			CoordType XAxis,YAxis; // tangent axis in 3D Object space
+			///get tangent directions
+			
+			bool done=TangentDir(I,bary,XAxis,YAxis,(ScalarType)0.1);
+			if (!done)
+			{
+				(*ProjMatrix)[i].SetIdentity();
+				continue;
+			}
+		
+			// must compute res2d such that:  res2d.X() * XAxis + res2d.Y() * YAxis + dontCare * ZAxis = vect3d
+			CoordType ZAxis = -(XAxis^YAxis).Normalize()*XAxis.Norm();
+			
+			(*ProjMatrix)[i].SetColumn(0,XAxis);
+			(*ProjMatrix)[i].SetColumn(1,YAxis);
+			(*ProjMatrix)[i].SetColumn(2,ZAxis);
+			vcg::Invert((*ProjMatrix)[i]);
+		}
+	}
+
+	void GetCurvature(const int &I,const vcg::Point2<ScalarType> &alpha_beta,
+					  CoordType &d1,CoordType &d2,ScalarType &k1,ScalarType &k2)
+	{
+		ParamFace* face=NULL;
+		CoordType baryVal;
+		isoParam->Theta(I,alpha_beta,face,baryVal);
+		ParamVertex *v0=face->V(0);
+		ParamVertex *v1=face->V(1);
+		ParamVertex *v2=face->V(2);
+		d1=v0->PD1()*baryVal.X()+v1->PD1()*baryVal.Y()+v2->PD1()*baryVal.Z();
+		d2=v0->PD2()*baryVal.X()+v1->PD2()*baryVal.Y()+v2->PD2()*baryVal.Z();
+		k1=v0->K1()*baryVal.X()+v1->K1()*baryVal.Y()+v2->K1()*baryVal.Z();
+		k2=v0->K2()*baryVal.X()+v1->K2()*baryVal.Y()+v2->K2()*baryVal.Z();
+	}
+
+	void GetProjectionMatrix(const int &I,const vcg::Point2<ScalarType> &alpha_beta,
+						     vcg::Matrix33<ScalarType> &projMatr) const
+	{
+		ParamFace* face=NULL;
+		CoordType baryVal;
+		int dom=isoParam->Theta(I,alpha_beta,face,baryVal);
+		if (dom==-1)
+		{
+			projMatr.SetIdentity();
+			return;
+		}
+		ParamVertex *v0=face->V(0);
+		ParamVertex *v1=face->V(1);
+		ParamVertex *v2=face->V(2);
+
+		projMatr=(*ProjMatrix)[v0]*baryVal.X();
+		projMatr+=(*ProjMatrix)[v1]*baryVal.Y();
+		projMatr+=(*ProjMatrix)[v2]*baryVal.Z();
+	}
+
+	
+	bool Project(const int &I,const vcg::Point2<ScalarType> &bary,
+				 const CoordType &vect3d, // in object space
+				 vcg::Point2<ScalarType> &res2d) const
+	{
+		vcg::Matrix33f m;
+		GetProjectionMatrix(I,bary,m);
+
+		ScalarType deltaX=vect3d*m.GetRow(0);
+		ScalarType deltaY=vect3d*m.GetRow(1);
+		
+		// two axis in alpha-beta space that will be orthogonal in UV-Space
+		const ScalarType h=(ScalarType)2.0/sqrt((ScalarType)3.0);
+		vcg::Point2<ScalarType> XP=vcg::Point2<ScalarType>(1,0);
+		vcg::Point2<ScalarType> YP=vcg::Point2<ScalarType>(-0.5,h);
+		res2d = XP*deltaX + YP*deltaY;
+		//res2d=vcg::Point2<ScalarType>(deltaX,deltaY);
+
+		return true;
+	}
+
+	 // WEIGHTED INTERPOLATION OF POINTS IN TANGENT SPACE 
+	///	weights MUST be normalized
+	bool Interpolate(const int &I0,const vcg::Point2<ScalarType> &alpha_beta0,
+					 const int &I1,const vcg::Point2<ScalarType> &alpha_beta1,
+					 ScalarType weight,
+					 int &I_res,
+					 vcg::Point2<ScalarType> &alpha_beta_res)
+	{
+		int IndexDomain;
+		int kind=isoParam->InterpolationSpace(I0,I1,IndexDomain);
+		if (kind==-1)
+			return false;
+
+		vcg::Point2<ScalarType> transformed0,transformed1;
+		
+		///interpolate in a face
+		if (kind==0)
+		{
+			isoParam->GE2(IndexDomain,alpha_beta0,transformed0);
+			isoParam->GE2(IndexDomain,alpha_beta1,transformed1);
+		}
+		else
+		///interpolate in a diamond
+		if (kind==1)
+		{				
+			isoParam->GE1(I0,alpha_beta0,IndexDomain,transformed0);		
+			isoParam->GE1(I1,alpha_beta1,IndexDomain,transformed1);		
+		}
+		else
+		{
+			isoParam->GE0(I0,alpha_beta0,IndexDomain,transformed0);
+			isoParam->GE0(I1,alpha_beta1,IndexDomain,transformed1);
+		}
+
+		vcg::Point2<ScalarType> UV_interp=transformed0*weight+transformed1*(1.0-weight);
+		///FINALLY......
+		///transform back to alpha,beta,I
+		if (kind==0)
+		{
+			isoParam->inv_GE2(IndexDomain,UV_interp,alpha_beta_res);
+			I_res=IndexDomain;
+		}
+		else
+		if (kind==1)
+		{
+			isoParam->inv_GE1(IndexDomain,UV_interp,I_res,alpha_beta_res);
+		}
+		else
+			isoParam->inv_GE0(IndexDomain,UV_interp,I_res,alpha_beta_res);
+		return true;
+	}
+
+	ScalarType AbstractArea()
+	{
+		ScalarType Cnum=sqrt(3.0)/4.0;
+		return(isoParam->AbsMesh()->fn*Cnum);
+	}
+
+    // WEIGHTED INTERPOLATION OF POINTS IN TANGENT SPACE 
+	///	weights MUST be normalized
+	bool Interpolate(const std::vector<int> &I,
+					 const std::vector<vcg::Point2<ScalarType> > &alpha_beta,
+					 const std::vector<ScalarType> &weights,
+					 int &I_res,
+					 vcg::Point2<ScalarType> &alpha_beta_res,
+					 int *num=NULL)
+	{
+		int size;
+		if (num==NULL)
+			size=alpha_beta.size();
+		else
+			size=*num;
+
+		int IndexDomain;
+		int kind=isoParam->InterpolationSpace(I,IndexDomain,num);
+		if (kind==-1)
+			return false;
+
+		std::vector<vcg::Point2<ScalarType> > transformed;
+		transformed.resize(size);
+		
+		///interpolate in a face
+		if (kind==0)
+		{
+			for (int i=0;i<size;i++)
+				isoParam->GE2(IndexDomain,alpha_beta[i],transformed[i]);
+		}
+		else
+		///interpolate in a diamond
+		if (kind==1)
+		{				
+			for (int i=0;i<size;i++)
+				isoParam->GE1(I[i],alpha_beta[i],IndexDomain,transformed[i]);		
+		}
+		else
+		{
+			for (int i=0;i<size;i++)
+				bool b0=isoParam->GE0(I[i],alpha_beta[i],IndexDomain,transformed[i]);
+		}
+
+		/// do the interpolation
+		vcg::Point2<ScalarType> UV_interp=vcg::Point2<ScalarType>(0,0);
+		for (int i=0;i<size;i++)
+			UV_interp+=(transformed[i]*weights[i]);
+		
+		///FINALLY......
+		///transform back to alpha,beta,I
+		if (kind==0)
+		{
+			isoParam->inv_GE2(IndexDomain,UV_interp,alpha_beta_res);
+			I_res=IndexDomain;
+		}
+		else
+		if (kind==1)
+		{
+			isoParam->inv_GE1(IndexDomain,UV_interp,I_res,alpha_beta_res);
+		}
+		else
+			isoParam->inv_GE0(IndexDomain,UV_interp,I_res,alpha_beta_res);
+		return true;
+	}
+
+};
+#endif
diff --git a/src/meshlabplugins/filter_layer/filter_layer.cpp b/src/meshlabplugins/filter_layer/filter_layer.cpp
index 62659408d..483092786 100644
--- a/src/meshlabplugins/filter_layer/filter_layer.cpp
+++ b/src/meshlabplugins/filter_layer/filter_layer.cpp
@@ -29,8 +29,7 @@
 
 #include "filter_layer.h"
 
-#include <vcg/complex/trimesh/clean.h>
-#include<vcg/complex/trimesh/append.h>
+#include<vcg/complex/append.h>
 
 
 
diff --git a/src/meshlabplugins/filter_measure/filter_measure.cpp b/src/meshlabplugins/filter_measure/filter_measure.cpp
index 14443b9ab..ecc53a046 100644
--- a/src/meshlabplugins/filter_measure/filter_measure.cpp
+++ b/src/meshlabplugins/filter_measure/filter_measure.cpp
@@ -26,15 +26,15 @@
 #include <math.h>
 #include <stdlib.h>
 #include <time.h>
-#include <vcg/complex/trimesh/clean.h>
-#include <vcg/complex/trimesh/inertia.h>
-#include <vcg/complex/trimesh/stat.h>
+#include <vcg/complex/algorithms/clean.h>
+#include <vcg/complex/algorithms/inertia.h>
+#include <vcg/complex/algorithms/stat.h>
 
-#include <vcg/complex/trimesh/update/selection.h>
-#include<vcg/complex/trimesh/append.h>
+#include <vcg/complex/algorithms/update/selection.h>
+#include<vcg/complex/append.h>
 #include<vcg/simplex/face/pos.h>
-#include<vcg/complex/trimesh/bitquad_support.h>
-#include<vcg/complex/trimesh/bitquad_optimization.h>
+#include<vcg/complex/algorithms/bitquad_support.h>
+#include<vcg/complex/algorithms/bitquad_optimization.h>
 #include "filter_measure.h"
 
 using namespace std;
diff --git a/src/meshlabplugins/filter_meshing/filter_meshing.pro b/src/meshlabplugins/filter_meshing/filter_meshing.pro
index 9fd260bac..a54393877 100644
--- a/src/meshlabplugins/filter_meshing/filter_meshing.pro
+++ b/src/meshlabplugins/filter_meshing/filter_meshing.pro
@@ -1,6 +1,6 @@
 include (../../shared.pri)
 
-HEADERS       += $$VCGDIR/vcg/complex/trimesh/clean.h\
+HEADERS       += $$VCGDIR/vcg/complex/algorithms/clean.h\
 		quadric_simp.h \ 
 		quadric_tex_simp.h \ 
 		meshfilter.h 
diff --git a/src/meshlabplugins/filter_meshing/meshfilter.cpp b/src/meshlabplugins/filter_meshing/meshfilter.cpp
index 6518c18e4..8d0280533 100644
--- a/src/meshlabplugins/filter_meshing/meshfilter.cpp
+++ b/src/meshlabplugins/filter_meshing/meshfilter.cpp
@@ -21,17 +21,17 @@
  ****************************************************************************/
 
 #include "meshfilter.h"
-#include <vcg/complex/trimesh/clean.h>
-#include <vcg/complex/trimesh/stat.h>
-#include <vcg/complex/trimesh/smooth.h>
-#include <vcg/complex/trimesh/hole.h>
-#include <vcg/complex/trimesh/refine_loop.h>
-#include <vcg/complex/trimesh/bitquad_support.h>
-#include <vcg/complex/trimesh/bitquad_creation.h>
-#include <vcg/complex/trimesh/clustering.h>
-#include <vcg/complex/trimesh/attribute_seam.h>
-#include <vcg/complex/trimesh/update/curvature.h>
-#include <vcg/complex/trimesh/update/curvature_fitting.h>
+#include <vcg/complex/algorithms/clean.h>
+#include <vcg/complex/algorithms/stat.h>
+#include <vcg/complex/algorithms/smooth.h>
+#include <vcg/complex/algorithms/hole.h>
+#include <vcg/complex/algorithms/refine_loop.h>
+#include <vcg/complex/algorithms/bitquad_support.h>
+#include <vcg/complex/algorithms/bitquad_creation.h>
+#include <vcg/complex/algorithms/clustering.h>
+#include <vcg/complex/algorithms/attribute_seam.h>
+#include <vcg/complex/algorithms/update/curvature.h>
+#include <vcg/complex/algorithms/update/curvature_fitting.h>
 #include <vcg/space/normal_extrapolation.h>
 #include <vcg/space/fitting3.h>
 #include "quadric_tex_simp.h"
diff --git a/src/meshlabplugins/filter_meshing/quadric_simp.cpp b/src/meshlabplugins/filter_meshing/quadric_simp.cpp
index 3cedf7bfa..d371652e5 100644
--- a/src/meshlabplugins/filter_meshing/quadric_simp.cpp
+++ b/src/meshlabplugins/filter_meshing/quadric_simp.cpp
@@ -20,9 +20,6 @@
  *                                                                           *
  ****************************************************************************/
 #include "meshfilter.h"
-#include <vcg/complex/local_optimization.h>
-#include <vcg/complex/local_optimization/tri_edge_collapse_quadric.h>
-#include <vcg/container/simple_temporary_data.h>
 #include "quadric_simp.h"
 
 using namespace vcg;
diff --git a/src/meshlabplugins/filter_meshing/quadric_simp.h b/src/meshlabplugins/filter_meshing/quadric_simp.h
index be52898b2..4f3d0e6cd 100644
--- a/src/meshlabplugins/filter_meshing/quadric_simp.h
+++ b/src/meshlabplugins/filter_meshing/quadric_simp.h
@@ -55,11 +55,11 @@ Added remove non manifold and quadric simplification filter.
 #include <limits>
 
 #include "meshfilter.h"
-#include <vcg/complex/trimesh/update/position.h>
-#include <vcg/complex/trimesh/update/bounding.h>
-#include <vcg/complex/trimesh/update/selection.h>
-#include <vcg/complex/local_optimization.h>
-#include <vcg/complex/local_optimization/tri_edge_collapse_quadric.h>
+#include <vcg/complex/algorithms/update/position.h>
+#include <vcg/complex/algorithms/update/bounding.h>
+#include <vcg/complex/algorithms/update/selection.h>
+#include <vcg/complex/algorithms/local_optimization.h>
+#include <vcg/complex/algorithms/local_optimization/tri_edge_collapse_quadric.h>
 #include <vcg/container/simple_temporary_data.h>
 namespace vcg {
 namespace tri {
diff --git a/src/meshlabplugins/filter_meshing/quadric_tex_simp.h b/src/meshlabplugins/filter_meshing/quadric_tex_simp.h
index 73f483ede..3534e207f 100644
--- a/src/meshlabplugins/filter_meshing/quadric_tex_simp.h
+++ b/src/meshlabplugins/filter_meshing/quadric_tex_simp.h
@@ -23,8 +23,8 @@
 #ifndef __QUADRICTEXSIMP_H
 #define __QUADRICTEXSIMP_H
 
-#include <vcg/complex/local_optimization.h>
-#include <vcg/complex/local_optimization/tri_edge_collapse_quadric.h>
+#include <vcg/complex/algorithms/local_optimization.h>
+#include <vcg/complex/algorithms/local_optimization/tri_edge_collapse_quadric.h>
 #include <vcg/container/simple_temporary_data.h>
 #include "algebra5.h"
 #include "quadric5.h"
diff --git a/src/meshlabplugins/filter_mls/mlsplugin.cpp b/src/meshlabplugins/filter_mls/mlsplugin.cpp
index 668659919..04d9a971b 100644
--- a/src/meshlabplugins/filter_mls/mlsplugin.cpp
+++ b/src/meshlabplugins/filter_mls/mlsplugin.cpp
@@ -30,12 +30,12 @@
 
 #include <common/interfaces.h>
 
-#include <vcg/complex/trimesh/clean.h>
-#include <vcg/complex/trimesh/refine.h>
-#include <vcg/complex/trimesh/refine_loop.h>
-#include <vcg/complex/trimesh/append.h>
-#include <vcg/complex/trimesh/create/advancing_front.h>
-#include <vcg/complex/trimesh/create/marching_cubes.h>
+#include <vcg/complex/algorithms/clean.h>
+#include <vcg/complex/algorithms/refine.h>
+#include <vcg/complex/algorithms/refine_loop.h>
+#include <vcg/complex/append.h>
+#include <vcg/complex/algorithms/create/advancing_front.h>
+#include <vcg/complex/algorithms/create/marching_cubes.h>
 #include "mlsmarchingcube.h"
 
 #include "mlsplugin.h"
diff --git a/src/meshlabplugins/filter_mutualinfo/alignset.cpp b/src/meshlabplugins/filter_mutualinfo/alignset.cpp
index a46a957d4..f5a7f1ff6 100644
--- a/src/meshlabplugins/filter_mutualinfo/alignset.cpp
+++ b/src/meshlabplugins/filter_mutualinfo/alignset.cpp
@@ -1,357 +1,357 @@
-#include <iostream>
-
-#include <GL/glew.h>
-
-#include <QGLContext>
-#include <QDomNode>
-#include <QDir>
-#include <QFileInfo>
-#include <QFile>
-#include <QTextStream>
-#include <QGLFramebufferObject>
-
-
-#include "alignset.h"
-
-#include <wrap/gl/shot.h>
-#include <wrap/gl/camera.h>
-//#include <vcg/math/shot.h>
-#include <vcg/complex/trimesh/update/normal.h>
-#include <vcg/complex/trimesh/update/bounding.h>
-#include <wrap/io_trimesh/import_ply.h>
-
-#include "shutils.h"
-
-using namespace std;
-
-AlignSet::AlignSet(): mode(COMBINE),
-target(NULL), render(NULL),
-vbo(0), nbo(0), cbo(0), ibo(0), error(0){
-
-  box.SetNull();
-  correspList = new QList<PointCorrespondence*>();
-  imageRatio=1;
-}
-
-AlignSet::~AlignSet() {
-  if(target) delete []target;
-  if(render) delete []render;
-  delete correspList;
-}
-
-void AlignSet::initializeGL() {
-
-  programs[COLOR] = createShaders("varying vec4 color; void main() { gl_Position = ftransform(); color = gl_Color; }",
-    "varying vec4 color; void main() { gl_FragColor = color; }");
-  programs[NORMALMAP] = createShaders("varying vec3 normal; void main() { normal = gl_NormalMatrix * gl_Normal;	gl_Position = ftransform(); }",
-    "varying vec3 normal; void main() { "
-    "vec3 color = normalize(normal); color = color * 0.5 + 0.5; gl_FragColor = vec4(color, 1.0); }");
-  programs[COMBINE] = createShaders("varying vec3 normal; varying vec4 color; void main() { "
-    "normal = gl_NormalMatrix * gl_Normal; gl_Position = ftransform(); color = gl_Color; }",
-    "varying vec3 normal; varying vec4 color; void main() { "
-    "vec3 ncolor = normalize(normal); ncolor = ncolor * 0.5 + 0.5; "
-    "float t = color.x*color.x; gl_FragColor = (1-t)*color + t*(vec4(ncolor, 1.0)); }");
-  programs[SPECULAR] = createShaders("varying vec3 reflection; void main() { "
-    "vec3 normal = normalize(gl_NormalMatrix * gl_Normal); vec4 position = gl_ModelViewMatrix * gl_Vertex; "
-    "reflection = reflect(position.xyz, normal); gl_Position = ftransform(); }",
-    "varying vec3 reflection; varying vec4 color; void main() { "
-    "vec4 ncolor; ncolor.xyz = normalize(reflection); ncolor.w = 1.0; gl_FragColor = ncolor * 0.5 + 0.5; }");
-  programs[SILHOUETTE] = createShaders("varying vec4 color; void main() { gl_Position = ftransform(); color = gl_Color; }",
-    "varying vec4 color; void main() { gl_FragColor = color; }");
-
-  programs[SPECAMB] = createShaders("varying vec3 reflection; varying vec4 color; void main() { "
-    "vec3 normal = normalize(gl_NormalMatrix * gl_Normal); vec4 position = gl_ModelViewMatrix * gl_Vertex; "
-    "reflection = reflect(position.xyz, normal); gl_Position = ftransform(); color = gl_Color; }",
-    "varying vec3 reflection; varying vec4 color; void main() { "
-    "vec3 ncolor = normalize(reflection); ncolor = ncolor * 0.5 + 0.5; "
-    "float t = color.x*color.x; gl_FragColor = (1-t)*color + t*(vec4(ncolor, 1.0)); }");
-
-
-  // generate a new VBO and get the associated ID
-  glGenBuffersARB(1, &vbo);
-  glGenBuffersARB(1, &nbo);
-  glGenBuffersARB(1, &cbo);
-  glGenBuffersARB(1, &ibo);
-}
-
-//resample image IF too big.
-void AlignSet::resize(int max_side) {
-  int w = image->width();
-  int h = image->height();
-  if(image->isNull()) {
-    w =  1024;
-    h = 768;
-  }
-
-  if(w > max_side) {
-    h = h*max_side/w;
-    w = max_side;
-  }
-  if(h > max_side) {
-    w = w*max_side/h;
-    h = max_side;
-  }
-
-  wt=w;
-  ht=h;
-
-  if(target) delete []target;
-  if(render) delete []render;
-  target = new unsigned char[w*h];
-  render = new unsigned char[w*h];
-
-
-  if(image->isNull()) return;
-  //resize image and store values into render
-  QImage im;
-  if(w != image->width() || h != image->height())
-    im = image->scaled(w, h, Qt::IgnoreAspectRatio); //Qt::KeepAspectRatio);
-  else im = *image;
-  im.save("image.jpg");
-  assert(w == im.width());
-  assert(h == im.height());
-  QColor color;
-  int offset = 0;
-  //equalize image
-  int histo[256];
-  memset(histo, 0, 256*sizeof(int));
-  for (int y = h-1; y >= 0; y--) {
-    for (int x = 0; x < w; x++) {
-      color.setRgb(im.pixel(x, y));
-      unsigned char c = (unsigned char)(color.red() * 0.3f + color.green() * 0.59f + color.blue() * 0.11f);
-      target[offset] = c;
-      histo[c]++;
-      offset++;
-    }
-  }
-#ifdef RESCALE_HISTO
-  int cumulative[256];
-  cumulative[0] = histo[0];
-  for(int i = 1; i < 256; i++)
-    cumulative[i] = cumulative[i-1] + histo[i];
-
-  int min = 0;
-  int max = 255;
-  for(int i = 0; i < 256; i++) {
-    if(cumulative[i] > 20) break;
-    min = i;
-  }
-
-  //invert cumulative..
-  cumulative[255] = histo[255];
-  for(int i = 254; i >= 0; i--)
-    cumulative[i] = cumulative[i+1] + histo[i];
-
-  for(int i = 255; i >= 0; i--) {
-    if(cumulative[i] > 20) break;
-    max = i;
-  }
-  assert(max > min);
-  //rescale between min and max (should use bresenham but I am lazy
-  unsigned char equa[256];
-  for(int i = 0; i < 256; i++) {
-    if(i < min) equa[i] = 0;
-    if(i > max) equa[i] = 255;
-    equa[i] = (255*(i - min))/(max - min);
-  }
-  for(int i = 0; i < w*h; i++)
-    target[i] = equa[target[i]];
-#endif
-}
-
-void AlignSet::renderScene(vcg::Shot<float> &view, int component) {
-  QSize fbosize(wt,ht);
-  QGLFramebufferObjectFormat frmt;
-  frmt.setInternalTextureFormat(GL_RGBA);
-  frmt.setAttachment(QGLFramebufferObject::Depth);
-  QGLFramebufferObject fbo(fbosize,frmt);
-
-  float _near, _far;
-  _near=0.1;
-  _far=10000;
-
-  GlShot< vcg::Shot<float> >::GetNearFarPlanes(view, mesh->bbox, _near, _far);
-  //assert(_near <= _far);
-  if(_near <= 0) _near = 0.1;
-  if(_far < _near) _far = 1000;
-
-
-//GLenum err = glGetError();
-
-  //render to FBO
-  fbo.bind();
-
-  glViewport(0, 0, wt, ht);
-  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-  GlShot< vcg::Shot<float> >::SetView(shot, 0.5*_near, 2*_far);
-
-//	err = glGetError();
-
-  bool use_colors = false;
-  bool use_normals = false;
-  int program = programs[mode]; //standard pipeline
-  switch(mode){
-   case COLOR:
-     use_colors = true;
-     break;
-   case NORMALMAP:
-   case SPECULAR:
-     use_normals = true;
-     break;
-   case COMBINE:
-   case SPECAMB:
-     use_colors = true;
-     use_normals = true;
-     break;
-   case SILHOUETTE:
-     break;
-   default: assert(0);
-  }
-  glDisable(GL_LIGHTING);
-  //bind indices
-  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ibo);
-
-  //bind vertices
-  glEnable(GL_COLOR_MATERIAL);
-  glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
-  glEnableClientState(GL_VERTEX_ARRAY);                 // activate vertex coords array
-  glVertexPointer(3, GL_FLOAT, 0, 0);                   // last param is offset, not ptr
-
-//    err = glGetError();
-
-  glUseProgram(program);
-
-//    err = glGetError();
-
-  if(use_colors) {
-    glBindBufferARB(GL_ARRAY_BUFFER_ARB, cbo);
-    glEnableClientState(GL_COLOR_ARRAY);
-    glColorPointer(4, GL_UNSIGNED_BYTE, 0, 0);
-  }
-  if(use_normals) {
-    glBindBufferARB(GL_ARRAY_BUFFER_ARB, nbo);
-    glEnableClientState(GL_NORMAL_ARRAY);
-    glNormalPointer(GL_FLOAT, 0, 0);
-  }
-
-//	err = glGetError();
-
-
-  int start = 0;
-  int tot = 30000;
-  if (mesh->fn>0)
-  {
-    while(start < mesh->fn) {
-      glDrawElements(GL_TRIANGLES, tot*3, GL_UNSIGNED_INT, (void *)(start*3*sizeof(int)));
-      start += tot;
-      if(start + tot > mesh->fn)
-        tot = mesh->fn - start;
-    }
-  }
-  else glDrawArrays(GL_POINTS, 0, mesh->vn);
-
-
-
-  render = new unsigned char[wt*ht];
-
-  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-  glPixelStorei(GL_PACK_ALIGNMENT, 1);
-
-  switch(component) {
-    case 0: glReadPixels( 0, 0, wt, ht, GL_RED, GL_UNSIGNED_BYTE, render); break;
-    case 1: glReadPixels( 0, 0, wt, ht, GL_GREEN, GL_UNSIGNED_BYTE, render); break;
-    case 2: glReadPixels( 0, 0, wt, ht, GL_BLUE, GL_UNSIGNED_BYTE, render); break;
-    case 3: glReadPixels( 0, 0, wt, ht, GL_ALPHA, GL_UNSIGNED_BYTE, render); break;
-    case 4: break;
-  }
-
-  //err = glGetError();
-
-  glDisableClientState(GL_VERTEX_ARRAY);                // deactivate vertex array
-  if(use_colors) glDisableClientState(GL_COLOR_ARRAY);
-  if(use_normals) glDisableClientState(GL_NORMAL_ARRAY);
-
-  //err = glGetError();
-
-  // bind with 0, so, switch back to normal pointer operation
-  glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
-  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
-
-  switch(mode) {
-    case SILHOUETTE:
-    case COLOR:
-    case COMBINE:
-    case NORMALMAP: glEnable(GL_LIGHTING); break;
-    default: break;
-  }
-
-  // standard opengl pipeline is re-activated
-  glUseProgram(0);
-
-  GlShot< vcg::Shot<float> >::UnsetView();
-
-  glFinish();
-  /*QImage l=fbo.toImage();
-  l.save("rendering.jpg");*/
-  fbo.release();
-
-}
-
-void AlignSet::readRender(int component) {
-  QSize fbosize(wt,ht);
-  QGLFramebufferObjectFormat frmt;
-  frmt.setInternalTextureFormat(GL_RGBA);
-  frmt.setAttachment(QGLFramebufferObject::Depth);
-  QGLFramebufferObject fbo(fbosize,frmt);
-
-  fbo.bind();
-  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-  glPixelStorei(GL_PACK_ALIGNMENT, 1);
-
-  switch(component) {
-  case 0: glReadPixels( 0, 0, width(), height(), GL_RED, GL_UNSIGNED_BYTE, render); break;
-  case 1: glReadPixels( 0, 0, width(), height(), GL_GREEN, GL_UNSIGNED_BYTE, render); break;
-  case 2: glReadPixels( 0, 0, width(), height(), GL_BLUE, GL_UNSIGNED_BYTE, render); break;
-  case 3: glReadPixels( 0, 0, width(), height(), GL_ALPHA, GL_UNSIGNED_BYTE, render); break;
-  }
-  QImage l=fbo.toImage();
-  l.save("puppo.jpg");
-  fbo.release();
-}
-
-GLuint AlignSet::createShaderFromFiles(QString name) {
-  QString vert = "shaders/" + name + ".vert";
-  QString frag = "shaders/" + name + ".frag";
-
-  const char *vs_src = ShaderUtils::importShaders(vert.toAscii().data());
-  if(!vs_src) {
-    cerr << "Could not load shader: " << qPrintable(vert) << endl;
-    return 0;
-  }
-
-  const char *fs_src = ShaderUtils::importShaders(frag.toAscii().data());
-  if(!fs_src) {
-    cerr << "Could not load shader: " << qPrintable(frag) << endl;
-    return 0;
-  }
-
-  return createShaders(vs_src, fs_src);
-}
-
-GLuint AlignSet::createShaders(const char *vert, const char *frag) {
-  GLuint vs = glCreateShader(GL_VERTEX_SHADER);
-  glShaderSource(vs, 1, &vert, NULL);
-  ShaderUtils::compileShader(vs);
-
-  GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
-  glShaderSource(fs, 1, &frag, NULL);
-  ShaderUtils::compileShader(fs);
-
-  GLuint prog = glCreateProgram();
-  glAttachShader(prog, vs);
-  glAttachShader(prog, fs);
-
-  ShaderUtils::linkShaderProgram(prog);
-  return prog;
-}
-
+#include <iostream>
+
+#include <GL/glew.h>
+
+#include <QGLContext>
+#include <QDomNode>
+#include <QDir>
+#include <QFileInfo>
+#include <QFile>
+#include <QTextStream>
+#include <QGLFramebufferObject>
+
+
+#include "alignset.h"
+
+#include <wrap/gl/shot.h>
+#include <wrap/gl/camera.h>
+//#include <vcg/math/shot.h>
+#include <vcg/complex/algorithms/update/normal.h>
+#include <vcg/complex/algorithms/update/bounding.h>
+#include <wrap/io_trimesh/import_ply.h>
+
+#include "shutils.h"
+
+using namespace std;
+
+AlignSet::AlignSet(): mode(COMBINE),
+target(NULL), render(NULL),
+vbo(0), nbo(0), cbo(0), ibo(0), error(0){
+
+  box.SetNull();
+  correspList = new QList<PointCorrespondence*>();
+  imageRatio=1;
+}
+
+AlignSet::~AlignSet() {
+  if(target) delete []target;
+  if(render) delete []render;
+  delete correspList;
+}
+
+void AlignSet::initializeGL() {
+
+  programs[COLOR] = createShaders("varying vec4 color; void main() { gl_Position = ftransform(); color = gl_Color; }",
+    "varying vec4 color; void main() { gl_FragColor = color; }");
+  programs[NORMALMAP] = createShaders("varying vec3 normal; void main() { normal = gl_NormalMatrix * gl_Normal;	gl_Position = ftransform(); }",
+    "varying vec3 normal; void main() { "
+    "vec3 color = normalize(normal); color = color * 0.5 + 0.5; gl_FragColor = vec4(color, 1.0); }");
+  programs[COMBINE] = createShaders("varying vec3 normal; varying vec4 color; void main() { "
+    "normal = gl_NormalMatrix * gl_Normal; gl_Position = ftransform(); color = gl_Color; }",
+    "varying vec3 normal; varying vec4 color; void main() { "
+    "vec3 ncolor = normalize(normal); ncolor = ncolor * 0.5 + 0.5; "
+    "float t = color.x*color.x; gl_FragColor = (1-t)*color + t*(vec4(ncolor, 1.0)); }");
+  programs[SPECULAR] = createShaders("varying vec3 reflection; void main() { "
+    "vec3 normal = normalize(gl_NormalMatrix * gl_Normal); vec4 position = gl_ModelViewMatrix * gl_Vertex; "
+    "reflection = reflect(position.xyz, normal); gl_Position = ftransform(); }",
+    "varying vec3 reflection; varying vec4 color; void main() { "
+    "vec4 ncolor; ncolor.xyz = normalize(reflection); ncolor.w = 1.0; gl_FragColor = ncolor * 0.5 + 0.5; }");
+  programs[SILHOUETTE] = createShaders("varying vec4 color; void main() { gl_Position = ftransform(); color = gl_Color; }",
+    "varying vec4 color; void main() { gl_FragColor = color; }");
+
+  programs[SPECAMB] = createShaders("varying vec3 reflection; varying vec4 color; void main() { "
+    "vec3 normal = normalize(gl_NormalMatrix * gl_Normal); vec4 position = gl_ModelViewMatrix * gl_Vertex; "
+    "reflection = reflect(position.xyz, normal); gl_Position = ftransform(); color = gl_Color; }",
+    "varying vec3 reflection; varying vec4 color; void main() { "
+    "vec3 ncolor = normalize(reflection); ncolor = ncolor * 0.5 + 0.5; "
+    "float t = color.x*color.x; gl_FragColor = (1-t)*color + t*(vec4(ncolor, 1.0)); }");
+
+
+  // generate a new VBO and get the associated ID
+  glGenBuffersARB(1, &vbo);
+  glGenBuffersARB(1, &nbo);
+  glGenBuffersARB(1, &cbo);
+  glGenBuffersARB(1, &ibo);
+}
+
+//resample image IF too big.
+void AlignSet::resize(int max_side) {
+  int w = image->width();
+  int h = image->height();
+  if(image->isNull()) {
+    w =  1024;
+    h = 768;
+  }
+
+  if(w > max_side) {
+    h = h*max_side/w;
+    w = max_side;
+  }
+  if(h > max_side) {
+    w = w*max_side/h;
+    h = max_side;
+  }
+
+  wt=w;
+  ht=h;
+
+  if(target) delete []target;
+  if(render) delete []render;
+  target = new unsigned char[w*h];
+  render = new unsigned char[w*h];
+
+
+  if(image->isNull()) return;
+  //resize image and store values into render
+  QImage im;
+  if(w != image->width() || h != image->height())
+    im = image->scaled(w, h, Qt::IgnoreAspectRatio); //Qt::KeepAspectRatio);
+  else im = *image;
+  im.save("image.jpg");
+  assert(w == im.width());
+  assert(h == im.height());
+  QColor color;
+  int offset = 0;
+  //equalize image
+  int histo[256];
+  memset(histo, 0, 256*sizeof(int));
+  for (int y = h-1; y >= 0; y--) {
+    for (int x = 0; x < w; x++) {
+      color.setRgb(im.pixel(x, y));
+      unsigned char c = (unsigned char)(color.red() * 0.3f + color.green() * 0.59f + color.blue() * 0.11f);
+      target[offset] = c;
+      histo[c]++;
+      offset++;
+    }
+  }
+#ifdef RESCALE_HISTO
+  int cumulative[256];
+  cumulative[0] = histo[0];
+  for(int i = 1; i < 256; i++)
+    cumulative[i] = cumulative[i-1] + histo[i];
+
+  int min = 0;
+  int max = 255;
+  for(int i = 0; i < 256; i++) {
+    if(cumulative[i] > 20) break;
+    min = i;
+  }
+
+  //invert cumulative..
+  cumulative[255] = histo[255];
+  for(int i = 254; i >= 0; i--)
+    cumulative[i] = cumulative[i+1] + histo[i];
+
+  for(int i = 255; i >= 0; i--) {
+    if(cumulative[i] > 20) break;
+    max = i;
+  }
+  assert(max > min);
+  //rescale between min and max (should use bresenham but I am lazy
+  unsigned char equa[256];
+  for(int i = 0; i < 256; i++) {
+    if(i < min) equa[i] = 0;
+    if(i > max) equa[i] = 255;
+    equa[i] = (255*(i - min))/(max - min);
+  }
+  for(int i = 0; i < w*h; i++)
+    target[i] = equa[target[i]];
+#endif
+}
+
+void AlignSet::renderScene(vcg::Shot<float> &view, int component) {
+  QSize fbosize(wt,ht);
+  QGLFramebufferObjectFormat frmt;
+  frmt.setInternalTextureFormat(GL_RGBA);
+  frmt.setAttachment(QGLFramebufferObject::Depth);
+  QGLFramebufferObject fbo(fbosize,frmt);
+
+  float _near, _far;
+  _near=0.1;
+  _far=10000;
+
+  GlShot< vcg::Shot<float> >::GetNearFarPlanes(view, mesh->bbox, _near, _far);
+  //assert(_near <= _far);
+  if(_near <= 0) _near = 0.1;
+  if(_far < _near) _far = 1000;
+
+
+//GLenum err = glGetError();
+
+  //render to FBO
+  fbo.bind();
+
+  glViewport(0, 0, wt, ht);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  GlShot< vcg::Shot<float> >::SetView(shot, 0.5*_near, 2*_far);
+
+//	err = glGetError();
+
+  bool use_colors = false;
+  bool use_normals = false;
+  int program = programs[mode]; //standard pipeline
+  switch(mode){
+   case COLOR:
+     use_colors = true;
+     break;
+   case NORMALMAP:
+   case SPECULAR:
+     use_normals = true;
+     break;
+   case COMBINE:
+   case SPECAMB:
+     use_colors = true;
+     use_normals = true;
+     break;
+   case SILHOUETTE:
+     break;
+   default: assert(0);
+  }
+  glDisable(GL_LIGHTING);
+  //bind indices
+  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ibo);
+
+  //bind vertices
+  glEnable(GL_COLOR_MATERIAL);
+  glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
+  glEnableClientState(GL_VERTEX_ARRAY);                 // activate vertex coords array
+  glVertexPointer(3, GL_FLOAT, 0, 0);                   // last param is offset, not ptr
+
+//    err = glGetError();
+
+  glUseProgram(program);
+
+//    err = glGetError();
+
+  if(use_colors) {
+    glBindBufferARB(GL_ARRAY_BUFFER_ARB, cbo);
+    glEnableClientState(GL_COLOR_ARRAY);
+    glColorPointer(4, GL_UNSIGNED_BYTE, 0, 0);
+  }
+  if(use_normals) {
+    glBindBufferARB(GL_ARRAY_BUFFER_ARB, nbo);
+    glEnableClientState(GL_NORMAL_ARRAY);
+    glNormalPointer(GL_FLOAT, 0, 0);
+  }
+
+//	err = glGetError();
+
+
+  int start = 0;
+  int tot = 30000;
+  if (mesh->fn>0)
+  {
+    while(start < mesh->fn) {
+      glDrawElements(GL_TRIANGLES, tot*3, GL_UNSIGNED_INT, (void *)(start*3*sizeof(int)));
+      start += tot;
+      if(start + tot > mesh->fn)
+        tot = mesh->fn - start;
+    }
+  }
+  else glDrawArrays(GL_POINTS, 0, mesh->vn);
+
+
+
+  render = new unsigned char[wt*ht];
+
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+  switch(component) {
+    case 0: glReadPixels( 0, 0, wt, ht, GL_RED, GL_UNSIGNED_BYTE, render); break;
+    case 1: glReadPixels( 0, 0, wt, ht, GL_GREEN, GL_UNSIGNED_BYTE, render); break;
+    case 2: glReadPixels( 0, 0, wt, ht, GL_BLUE, GL_UNSIGNED_BYTE, render); break;
+    case 3: glReadPixels( 0, 0, wt, ht, GL_ALPHA, GL_UNSIGNED_BYTE, render); break;
+    case 4: break;
+  }
+
+  //err = glGetError();
+
+  glDisableClientState(GL_VERTEX_ARRAY);                // deactivate vertex array
+  if(use_colors) glDisableClientState(GL_COLOR_ARRAY);
+  if(use_normals) glDisableClientState(GL_NORMAL_ARRAY);
+
+  //err = glGetError();
+
+  // bind with 0, so, switch back to normal pointer operation
+  glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
+  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
+
+  switch(mode) {
+    case SILHOUETTE:
+    case COLOR:
+    case COMBINE:
+    case NORMALMAP: glEnable(GL_LIGHTING); break;
+    default: break;
+  }
+
+  // standard opengl pipeline is re-activated
+  glUseProgram(0);
+
+  GlShot< vcg::Shot<float> >::UnsetView();
+
+  glFinish();
+  /*QImage l=fbo.toImage();
+  l.save("rendering.jpg");*/
+  fbo.release();
+
+}
+
+void AlignSet::readRender(int component) {
+  QSize fbosize(wt,ht);
+  QGLFramebufferObjectFormat frmt;
+  frmt.setInternalTextureFormat(GL_RGBA);
+  frmt.setAttachment(QGLFramebufferObject::Depth);
+  QGLFramebufferObject fbo(fbosize,frmt);
+
+  fbo.bind();
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+  switch(component) {
+  case 0: glReadPixels( 0, 0, width(), height(), GL_RED, GL_UNSIGNED_BYTE, render); break;
+  case 1: glReadPixels( 0, 0, width(), height(), GL_GREEN, GL_UNSIGNED_BYTE, render); break;
+  case 2: glReadPixels( 0, 0, width(), height(), GL_BLUE, GL_UNSIGNED_BYTE, render); break;
+  case 3: glReadPixels( 0, 0, width(), height(), GL_ALPHA, GL_UNSIGNED_BYTE, render); break;
+  }
+  QImage l=fbo.toImage();
+  l.save("puppo.jpg");
+  fbo.release();
+}
+
+GLuint AlignSet::createShaderFromFiles(QString name) {
+  QString vert = "shaders/" + name + ".vert";
+  QString frag = "shaders/" + name + ".frag";
+
+  const char *vs_src = ShaderUtils::importShaders(vert.toAscii().data());
+  if(!vs_src) {
+    cerr << "Could not load shader: " << qPrintable(vert) << endl;
+    return 0;
+  }
+
+  const char *fs_src = ShaderUtils::importShaders(frag.toAscii().data());
+  if(!fs_src) {
+    cerr << "Could not load shader: " << qPrintable(frag) << endl;
+    return 0;
+  }
+
+  return createShaders(vs_src, fs_src);
+}
+
+GLuint AlignSet::createShaders(const char *vert, const char *frag) {
+  GLuint vs = glCreateShader(GL_VERTEX_SHADER);
+  glShaderSource(vs, 1, &vert, NULL);
+  ShaderUtils::compileShader(vs);
+
+  GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
+  glShaderSource(fs, 1, &frag, NULL);
+  ShaderUtils::compileShader(fs);
+
+  GLuint prog = glCreateProgram();
+  glAttachShader(prog, vs);
+  glAttachShader(prog, fs);
+
+  ShaderUtils::linkShaderProgram(prog);
+  return prog;
+}
+
diff --git a/src/meshlabplugins/filter_perceptualmetric/filter_perceptualmetric.cpp b/src/meshlabplugins/filter_perceptualmetric/filter_perceptualmetric.cpp
index 90dfc463b..714413087 100644
--- a/src/meshlabplugins/filter_perceptualmetric/filter_perceptualmetric.cpp
+++ b/src/meshlabplugins/filter_perceptualmetric/filter_perceptualmetric.cpp
@@ -1,224 +1,217 @@
-/****************************************************************************
-* MeshLab                                                           o o     *
-* A versatile mesh processing toolbox                             o     o   *
-*                                                                _   O  _   *
-* Copyright(C) 2005                                                \/)\/    *
-* Visual Computing Lab                                            /\/|      *
-* ISTI - Italian National Research Council                           |      *
-*                                                                    \      *
-* All rights reserved.                                                      *
-*                                                                           *
-* This program is free software; you can redistribute it and/or modify      *   
-* it under the terms of the GNU General Public License as published by      *
-* the Free Software Foundation; either version 2 of the License, or         *
-* (at your option) any later version.                                       *
-*                                                                           *
-* This program is distributed in the hope that it will be useful,           *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
-* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
-* for more details.                                                         *
-*                                                                           *
-****************************************************************************/
-/****************************************************************************
-  History
-$Log: filter_perceptualmetric.cpp,v $
-****************************************************************************/
-
-#include <QtGui>
-
-#include <math.h>
-#include <stdlib.h>
-#include <time.h>
-
-#include <meshlab/meshmodel.h>
-#include <meshlab/interfaces.h>
-
-#include <vcg/complex/trimesh/clean.h>
-#include <vcg/complex/trimesh/update/position.h>
-#include <vcg/complex/trimesh/update/normal.h>
-#include <vcg/complex/trimesh/update/flag.h>
-#include <vcg/complex/trimesh/update/bounding.h>
-#include <vcg/complex/trimesh/update/quality.h>
-#include <vcg/complex/trimesh/point_sampling.h>
-#include <vcg/complex/trimesh/create/resampler.h>
-#include <vcg/simplex/face/distance.h>
-#include <vcg/complex/trimesh/update/color.h>
-#include <vcg/complex/trimesh/geodesic.h>
-#include <vcg/space/index/grid_static_ptr.h>
-
-// filter interface
-#include "filter_perceptualmetric.h"
-
-// perceptual metrics core
-#include "perceptualmetrics.h"
-
-using namespace vcg;
-using namespace std;
-
-
-// Constructor usually performs only two simple tasks of filling the two lists 
-//  - typeList: with all the possible id of the filtering actions
-//  - actionList with the corresponding actions. If you want to add icons to your filtering actions you can do here by construction the QActions accordingly
-
-FilterPerceptualMetric::FilterPerceptualMetric() 
-{ 
-	typeList 
-			<< FP_ROUGHNESS_MULTISCALE 
-			<< FP_ROUGHNESS_SMOOTHING
-			<< FP_STRAIN_ENERGY
-	;
-  
-  foreach(FilterIDType tt , types())
-	  actionList << new QAction(filterName(tt), this);
-}
-
-// ST() must return the very short string describing each filtering action 
-// (this string is used also to define the menu entry)
- QString FilterPerceptualMetric::filterName(FilterIDType filterId) 
-{
-	switch(filterId) 
-	{
-		case FP_ROUGHNESS_MULTISCALE :  return QString("Roughness-multiscale perceptual metric"); 
-		case FP_ROUGHNESS_SMOOTHING  :  return QString("Roughness-smoothing perceptual metric"); 
-		case FP_STRAIN_ENERGY        :  return QString("Energy Strain-based perceptual metric");  
-			
-		default : assert(0); return QString("unknown filter!!!!");
-	}
-}
-
-// Info() must return the longer string describing each filtering action 
-// (this string is used in the About plugin dialog)
- QString FilterPerceptualMetric::filterInfo(FilterIDType filterId)
-{
-	switch(filterId) 
-	{
-		case FP_ROUGHNESS_MULTISCALE :  return QString("Evaluate the perceptual difference between two given meshes; this perceptual metric is based on roughness measure, the roughness is evaluated at multiple-scale using dihedral angles."); 
-		case FP_ROUGHNESS_SMOOTHING  :  return QString("Evaluate the perceptual difference between two given meshes; this perceptual metric is based on roughness measure, the roughness is evaluated using a smoothed version of the 3D models."); 
-		case FP_STRAIN_ENERGY        :  return QString("Evaluate the perceptual difference between two given meshes; this perceptual metric is based on strain energy.");
-
-		default : assert(0); return QString("unknown filter!!!!");
-	}
-}
- int FilterPerceptualMetric::getRequirements(QAction *action)
-{
-	switch(ID(action))
-	{
-		case FP_ROUGHNESS_MULTISCALE : return MeshModel::MM_VERTFACETOPO | MeshModel::MM_FACENORMAL;
-		case FP_ROUGHNESS_SMOOTHING  : return MeshModel::MM_VERTFACETOPO;
-		case FP_STRAIN_ENERGY        : return MeshModel::MM_VERTFACETOPO;
-
-		default: assert(0);
-	}
-
-	return 0;
-}
-
-// This function define the needed parameters for each filter. Return true if the filter has some parameters
-// it is called every time, so you can set the default value of parameters according to the mesh
-// For each parameter you need to define, 
-// - the name of the parameter, 
-// - the string shown in the dialog 
-// - the default value
-// - a possibly long string describing the meaning of that parameter (shown as a popup help in the dialog)
-void FilterPerceptualMetric::initParameterSet(QAction *action, MeshDocument & md, FilterParameterSet & parlst) 
-{
-	switch(ID(action))	 
-	{
-		case FP_ROUGHNESS_MULTISCALE :
-		{
-			MeshModel *refmesh = md.mm();
-			foreach (refmesh, md.meshList) 
-				if (refmesh != md.mm())  break;
-
-			parlst.addMesh("ReferenceMesh", refmesh, "Reference Mesh",
-				"The original mesh.");
-			parlst.addMesh("InputMesh", md.mm(), "Mesh",
-				"The mesh where the perceptual impairment of the processing is evaluated.");
-		} break;
-		
-		case FP_ROUGHNESS_SMOOTHING :
-		{
-			MeshModel *refmesh = md.mm();
-			foreach (refmesh, md.meshList) 
-				if (refmesh != md.mm())  break;
-
-			parlst.addMesh("ReferenceMesh", refmesh, "Reference Mesh",
-				"The original mesh.");
-			parlst.addMesh("InputMesh", md.mm(), "Mesh",
-				"The mesh where the perceptual impairment of the processing is evaluated.");
-		} break;
-
-		case FP_STRAIN_ENERGY :  
-		{
-			MeshModel *refmesh = md.mm();
-			foreach (refmesh, md.meshList) 
-				if (refmesh != md.mm())  break;
-		
-			parlst.addMesh("ReferenceMesh", refmesh, "Reference Mesh",
-				"The original mesh.");
-			parlst.addMesh("InputMesh", md.mm(), "Mesh",
-				"The mesh where the perceptual impairment of the processing is evaluated.");
-		} break;
-
-		default : assert(0); 
-	}
-}
-
-bool FilterPerceptualMetric::applyFilter(QAction *action, MeshDocument &md, FilterParameterSet & par, vcg::CallBackPos *cb)
-{
-	switch(ID(action))
-	{
-
-		case FP_ROUGHNESS_MULTISCALE :  
-		{
-			MeshModel* mesh0 = par.getMesh("ReferenceMesh");  // reference mesh 
-			MeshModel* mesh1 = par.getMesh("InputMesh");      // the processed mesh
-			
-			double globalimpact = PerceptualMetrics<CMeshO>::roughnessMultiscale(mesh0->cm, mesh1->cm);
-
-			Log(0,"This metric is not implemented yet!!");
-		}
-		break;
-
-		case FP_ROUGHNESS_SMOOTHING :  
-		{
-			MeshModel* mesh0 = par.getMesh("ReferenceMesh");  // reference mesh 
-			MeshModel* mesh1 = par.getMesh("InputMesh");      // the processed mesh
-
-			double globalimpact = PerceptualMetrics<CMeshO>::roughnessSmoothing(mesh0->cm, mesh1->cm);
-			
-			Log(0,"This metric is not implemented yet!!");
-		}
-		break;
-
-		case FP_STRAIN_ENERGY : 
-		{
-			MeshModel* mesh0 = par.getMesh("ReferenceMesh");  // reference mesh 
-			MeshModel* mesh1 = par.getMesh("InputMesh");      // the processed mesh
-
-			double globalimpact = PerceptualMetrics<CMeshO>::strainEnergy(mesh0->cm, mesh1->cm);
-			
-			Log(0,"Perceptual Distance: %f",globalimpact);
-		}
-		break;
-
-		default : assert(0);
-	}
-	return true;
-}
-
- MeshFilterInterface::FilterClass FilterPerceptualMetric::getClass(QAction *action)
-{
-	switch(ID(action))
-	{
-		case FP_ROUGHNESS_MULTISCALE : return Quality;
-		case FP_ROUGHNESS_SMOOTHING : return Quality;
-		case FP_STRAIN_ENERGY : return Quality;
-		default: assert(0);
-	}
-	return FilterClass(0);
-}
-
-
-Q_EXPORT_PLUGIN(FilterPerceptualMetric)
+/****************************************************************************
+* MeshLab                                                           o o     *
+* A versatile mesh processing toolbox                             o     o   *
+*                                                                _   O  _   *
+* Copyright(C) 2005                                                \/)\/    *
+* Visual Computing Lab                                            /\/|      *
+* ISTI - Italian National Research Council                           |      *
+*                                                                    \      *
+* All rights reserved.                                                      *
+*                                                                           *
+* This program is free software; you can redistribute it and/or modify      *   
+* it under the terms of the GNU General Public License as published by      *
+* the Free Software Foundation; either version 2 of the License, or         *
+* (at your option) any later version.                                       *
+*                                                                           *
+* This program is distributed in the hope that it will be useful,           *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
+* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
+* for more details.                                                         *
+*                                                                           *
+****************************************************************************/
+/****************************************************************************
+  History
+$Log: filter_perceptualmetric.cpp,v $
+****************************************************************************/
+
+#include <QtGui>
+
+#include <math.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include <meshlab/meshmodel.h>
+#include <meshlab/interfaces.h>
+
+#include <vcg/complex/algorithms/point_sampling.h>
+#include <vcg/complex/algorithms/create/resampler.h>
+#include <vcg/simplex/face/distance.h>
+#include <vcg/complex/algorithms/geodesic.h>
+#include <vcg/space/index/grid_static_ptr.h>
+
+// filter interface
+#include "filter_perceptualmetric.h"
+
+// perceptual metrics core
+#include "perceptualmetrics.h"
+
+using namespace vcg;
+using namespace std;
+
+
+// Constructor usually performs only two simple tasks of filling the two lists 
+//  - typeList: with all the possible id of the filtering actions
+//  - actionList with the corresponding actions. If you want to add icons to your filtering actions you can do here by construction the QActions accordingly
+
+FilterPerceptualMetric::FilterPerceptualMetric() 
+{ 
+	typeList 
+			<< FP_ROUGHNESS_MULTISCALE 
+			<< FP_ROUGHNESS_SMOOTHING
+			<< FP_STRAIN_ENERGY
+	;
+  
+  foreach(FilterIDType tt , types())
+	  actionList << new QAction(filterName(tt), this);
+}
+
+// ST() must return the very short string describing each filtering action 
+// (this string is used also to define the menu entry)
+ QString FilterPerceptualMetric::filterName(FilterIDType filterId) 
+{
+	switch(filterId) 
+	{
+		case FP_ROUGHNESS_MULTISCALE :  return QString("Roughness-multiscale perceptual metric"); 
+		case FP_ROUGHNESS_SMOOTHING  :  return QString("Roughness-smoothing perceptual metric"); 
+		case FP_STRAIN_ENERGY        :  return QString("Energy Strain-based perceptual metric");  
+			
+		default : assert(0); return QString("unknown filter!!!!");
+	}
+}
+
+// Info() must return the longer string describing each filtering action 
+// (this string is used in the About plugin dialog)
+ QString FilterPerceptualMetric::filterInfo(FilterIDType filterId)
+{
+	switch(filterId) 
+	{
+		case FP_ROUGHNESS_MULTISCALE :  return QString("Evaluate the perceptual difference between two given meshes; this perceptual metric is based on roughness measure, the roughness is evaluated at multiple-scale using dihedral angles."); 
+		case FP_ROUGHNESS_SMOOTHING  :  return QString("Evaluate the perceptual difference between two given meshes; this perceptual metric is based on roughness measure, the roughness is evaluated using a smoothed version of the 3D models."); 
+		case FP_STRAIN_ENERGY        :  return QString("Evaluate the perceptual difference between two given meshes; this perceptual metric is based on strain energy.");
+
+		default : assert(0); return QString("unknown filter!!!!");
+	}
+}
+ int FilterPerceptualMetric::getRequirements(QAction *action)
+{
+	switch(ID(action))
+	{
+		case FP_ROUGHNESS_MULTISCALE : return MeshModel::MM_VERTFACETOPO | MeshModel::MM_FACENORMAL;
+		case FP_ROUGHNESS_SMOOTHING  : return MeshModel::MM_VERTFACETOPO;
+		case FP_STRAIN_ENERGY        : return MeshModel::MM_VERTFACETOPO;
+
+		default: assert(0);
+	}
+
+	return 0;
+}
+
+// This function define the needed parameters for each filter. Return true if the filter has some parameters
+// it is called every time, so you can set the default value of parameters according to the mesh
+// For each parameter you need to define, 
+// - the name of the parameter, 
+// - the string shown in the dialog 
+// - the default value
+// - a possibly long string describing the meaning of that parameter (shown as a popup help in the dialog)
+void FilterPerceptualMetric::initParameterSet(QAction *action, MeshDocument & md, FilterParameterSet & parlst) 
+{
+	switch(ID(action))	 
+	{
+		case FP_ROUGHNESS_MULTISCALE :
+		{
+			MeshModel *refmesh = md.mm();
+			foreach (refmesh, md.meshList) 
+				if (refmesh != md.mm())  break;
+
+			parlst.addMesh("ReferenceMesh", refmesh, "Reference Mesh",
+				"The original mesh.");
+			parlst.addMesh("InputMesh", md.mm(), "Mesh",
+				"The mesh where the perceptual impairment of the processing is evaluated.");
+		} break;
+		
+		case FP_ROUGHNESS_SMOOTHING :
+		{
+			MeshModel *refmesh = md.mm();
+			foreach (refmesh, md.meshList) 
+				if (refmesh != md.mm())  break;
+
+			parlst.addMesh("ReferenceMesh", refmesh, "Reference Mesh",
+				"The original mesh.");
+			parlst.addMesh("InputMesh", md.mm(), "Mesh",
+				"The mesh where the perceptual impairment of the processing is evaluated.");
+		} break;
+
+		case FP_STRAIN_ENERGY :  
+		{
+			MeshModel *refmesh = md.mm();
+			foreach (refmesh, md.meshList) 
+				if (refmesh != md.mm())  break;
+		
+			parlst.addMesh("ReferenceMesh", refmesh, "Reference Mesh",
+				"The original mesh.");
+			parlst.addMesh("InputMesh", md.mm(), "Mesh",
+				"The mesh where the perceptual impairment of the processing is evaluated.");
+		} break;
+
+		default : assert(0); 
+	}
+}
+
+bool FilterPerceptualMetric::applyFilter(QAction *action, MeshDocument &md, FilterParameterSet & par, vcg::CallBackPos *cb)
+{
+	switch(ID(action))
+	{
+
+		case FP_ROUGHNESS_MULTISCALE :  
+		{
+			MeshModel* mesh0 = par.getMesh("ReferenceMesh");  // reference mesh 
+			MeshModel* mesh1 = par.getMesh("InputMesh");      // the processed mesh
+			
+			double globalimpact = PerceptualMetrics<CMeshO>::roughnessMultiscale(mesh0->cm, mesh1->cm);
+
+			Log(0,"This metric is not implemented yet!!");
+		}
+		break;
+
+		case FP_ROUGHNESS_SMOOTHING :  
+		{
+			MeshModel* mesh0 = par.getMesh("ReferenceMesh");  // reference mesh 
+			MeshModel* mesh1 = par.getMesh("InputMesh");      // the processed mesh
+
+			double globalimpact = PerceptualMetrics<CMeshO>::roughnessSmoothing(mesh0->cm, mesh1->cm);
+			
+			Log(0,"This metric is not implemented yet!!");
+		}
+		break;
+
+		case FP_STRAIN_ENERGY : 
+		{
+			MeshModel* mesh0 = par.getMesh("ReferenceMesh");  // reference mesh 
+			MeshModel* mesh1 = par.getMesh("InputMesh");      // the processed mesh
+
+			double globalimpact = PerceptualMetrics<CMeshO>::strainEnergy(mesh0->cm, mesh1->cm);
+			
+			Log(0,"Perceptual Distance: %f",globalimpact);
+		}
+		break;
+
+		default : assert(0);
+	}
+	return true;
+}
+
+ MeshFilterInterface::FilterClass FilterPerceptualMetric::getClass(QAction *action)
+{
+	switch(ID(action))
+	{
+		case FP_ROUGHNESS_MULTISCALE : return Quality;
+		case FP_ROUGHNESS_SMOOTHING : return Quality;
+		case FP_STRAIN_ENERGY : return Quality;
+		default: assert(0);
+	}
+	return FilterClass(0);
+}
+
+
+Q_EXPORT_PLUGIN(FilterPerceptualMetric)
diff --git a/src/meshlabplugins/filter_perceptualmetric/perceptualmetrics.h b/src/meshlabplugins/filter_perceptualmetric/perceptualmetrics.h
index fd392fefc..7d0e05ce1 100644
--- a/src/meshlabplugins/filter_perceptualmetric/perceptualmetrics.h
+++ b/src/meshlabplugins/filter_perceptualmetric/perceptualmetrics.h
@@ -1,242 +1,242 @@
-/****************************************************************************
-* MeshLab                                                           o o     *
-* A versatile mesh processing toolbox                             o     o   *
-*                                                                _   O  _   *
-* Copyright(C) 2005                                                \/)\/    *
-* Visual Computing Lab                                            /\/|      *
-* ISTI - Italian National Research Council                           |      *
-*                                                                    \      *
-* All rights reserved.                                                      *
-*                                                                           *
-* This program is free software; you can redistribute it and/or modify      *   
-* it under the terms of the GNU General Public License as published by      *
-* the Free Software Foundation; either version 2 of the License, or         *
-* (at your option) any later version.                                       *
-*                                                                           *
-* This program is distributed in the hope that it will be useful,           *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
-* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
-* for more details.                                                         *
-*                                                                           *
-****************************************************************************/
-
-/****************************************************************************
-  History
-$Log: perceptualmetrics.h,v $
-****************************************************************************/
-
-#ifndef PERCEPTUALMETRICS_H
-#define PERCEPTUALMETRICS_H
-
-#include <QObject>
-
-#include <common/interfaces.h>
-#include <vcg/complex/trimesh/stat.h>
-
-template <class MeshType>
-class PerceptualMetrics
-{
-
-// definitions
-public:
-
-	typedef typename MeshType::CoordType         CoordType;
-	typedef typename MeshType::ScalarType        ScalarType;
-	typedef typename MeshType::VertexType        VertexType;
-	typedef typename MeshType::VertexPointer     VertexPointer;
-	typedef typename MeshType::CoordType         CoordType;
-	typedef typename MeshType::VertexIterator    VertexIterator;
-	typedef typename MeshType::FacePointer       FacePointer;
-	typedef typename MeshType::FaceIterator      FaceIterator;
-	typedef typename MeshType::FaceType          FaceType;
-	typedef typename MeshType::FaceContainer     FaceContainer;
-
-
-// private methods
-private:
-
-	static void planeProjection(double a, double b, double c, double d, 
-		const CoordType &axis1, const CoordType &axis2, const CoordType & O, 
-		const CoordType &p, double &xcoor, double &ycoor)
-	{
-		double u = p[0];
-		double v = p[1];
-		double w = p[2];
-
-		CoordType Pproj;
-
-		double num = a*u + b*v + c*w + d;
-
-		// den = a*a + b*b + c*c that is assumed one in this case (!)
-		Pproj[0] = u - a * num; // num/den
-		Pproj[1] = v - b * num; // num/den
-		Pproj[2] = w - c * num; // num/den
-
-		Pproj -= O;
-
-		xcoor = axis1 * Pproj;
-		ycoor = axis2 * Pproj;
-	}
-
-	static void computingDisplacementFunctionCoefficients(FacePointer f0, FacePointer f1, 
-		double & a1u, double & a2u, double & a3u, double & a1v, double & a2v, double & a3v,
-		double & area)
-	{
-		CoordType pD = f0->V(0)->P();
-		CoordType pE = f0->V(1)->P();
-		CoordType pF = f0->V(2)->P();
-
-		CoordType pDp = f1->V(0)->P();
-		CoordType pEp = f1->V(1)->P();
-		CoordType pFp = f1->V(2)->P();
-
-		CoordType axis1 = (pE-pD);
-		CoordType axis2 = (pF-pD);
-		CoordType N = axis1 ^ axis2;
-
-		// axis adjustment
-		axis2 = N ^ axis1;
-
-		axis1.Normalize();
-		axis2.Normalize();
-		N.Normalize();
-
-		double a = N[0];
-		double b = N[1];
-		double c = N[2];
-		double d = -(a * pD[0] + b * pD[1] + c * pD[2]);
-
-		// triangle in the local reference system
-		double xD,yD,xE,yE,xF,yF;
-		planeProjection(a,b,c,d, axis1, axis2, pD, pD, xD, yD);
-		planeProjection(a,b,c,d, axis1, axis2, pD, pE, xE, yE);
-		planeProjection(a,b,c,d, axis1, axis2, pD, pF, xF, yF);
-
-		// triangle in the local reference system after deformations
-		double xDp,yDp,xEp,yEp,xFp,yFp;
-		planeProjection(a,b,c,d, axis1, axis2, pD, pDp, xDp, yDp);
-		planeProjection(a,b,c,d, axis1, axis2, pD, pEp, xEp, yEp);
-		planeProjection(a,b,c,d, axis1, axis2, pD, pFp, xFp, yFp);
-
-		// deformation
-		double uD = xDp - xD;
-		double vD = yDp - yD;
-
-		double uE = xEp - xE;
-		double vE = yEp - yE;
-
-		double uF = xFp - xF;
-		double vF = yFp - yF;
-
-		// parameterization
-		double AA = (yE-yF) * xD + (yF-yD) * xE + (yD-yE) * xF;  // AA = 2A
-		double factor = 1.0 / (AA);
-
-		a1u = factor * ((xE*yF - xF*yE)*uD + (xF*yD - xD*yF)*uE + (xD*yE - xE*yD)*uF);
-		a2u = factor * ((yE-yF)*uD + (yF-yD)*uE + (yD-yE)*uF);
-		a3u = factor * ((xF-xE)*uD + (xD-xF)*uE + (xE-xD)*uF);
-
-		a1v = factor * ((xE*yF - xF*yE)*vD + (xF*yD - xD*yF)*vE + (xD*yE - xE*yD)*vF);
-		a2v = factor * ((yE-yF)*vD + (yF-yD)*vE + (yD-yE)*vF);
-		a3v = factor * ((xF-xE)*vD + (xD-xF)*vE + (xE-xD)*vF);
-
-		area = 0.5 * AA;
-	}
-
-// public methods
-public:
-
-	static double roughnessMultiscale(MeshType & refmesh, MeshType & mesh)
-	{
-		//...TODO...
-		return 0.0;
-	}
-
-	static double roughnessSmoothing(MeshType & refmesh, MeshType & mesh)
-	{
-		//...TODO...
-		return 0.0;
-	}
-
-	static double strainEnergy(MeshType & refmesh, MeshType & mesh)
-	{
-		double epsilonx, epsilony, epsilonz;
-		double gammaxy, gammayz, gammazx;
-		double epsilonx_prime, epsilony_prime, epsilonz_prime;
-		double epsilon_ii_squared;
-		double epsilon_ij_prime_epsilon_ij_prime;
-		double Sdelta;    // Area of each triangle
-		double ni = 0.0;  // Poisson's ratio
-		double E = 1.0;   // Young's modulus
-		double lambda;    // Lame's first parameter
-		double G;
-		double Warea, Wdistortion, W;
-		double u,v;
-		double a1u,a2u,a3u;
-		double a1v,a2v,a3v;
-		double x,y;
-		double D;
-		
-		FacePointer f0;
-		FacePointer f1;
-
-		W = 0.0;
-		for (int i = 0; i < refmesh.fn; i++)
-		{
-			f0 = &refmesh.face[i];
-			f1 = &mesh.face[i];
-			
-			// displacement function are:
-			//    u = a1u + x a2u + y a3u 
-			//    v = a1v + x a2v + y a3v
-			computingDisplacementFunctionCoefficients(f0, f1, a1u, a2u, a3u, a1v, a2v, a3v, Sdelta);
-
-			// epsilonx = du / dx
-			epsilonx = a2u;
-
-			// epsilony = dv / dy
-			epsilony = a3v;
-
-			// epsilonz
-			epsilonz = (ni / (ni - 1.0)) * (epsilonx + epsilony);
-			
-			// gammaxy = dv / dx + du / dy
-			gammaxy = a2v + a3u;
-			gammayz = 0.0;
-			gammazx = 0.0;
-
-			// strain energy for a single triangle
-			///////////////////////////////////////////////////////////////////////////////////////
-			
-			epsilonx_prime = epsilonx - (epsilonx + epsilony + epsilonz) / 3.0;
-			epsilony_prime = epsilony - (epsilonx + epsilony + epsilonz) / 3.0;
-			epsilonz_prime = epsilonz - (epsilonx + epsilony + epsilonz) / 3.0;
-			
-			epsilon_ii_squared = (epsilonx + epsilony + epsilonz) * (epsilonx + epsilony + epsilonz);
-			epsilon_ij_prime_epsilon_ij_prime = epsilonx_prime * epsilonx_prime + epsilony_prime * epsilony_prime + 
-				epsilonz_prime * epsilonz_prime + 0.5 * (gammaxy*gammaxy + gammayz*gammayz + gammazx*gammazx);
-			
-			lambda = (E * ni) / ((1.0 + ni) * (1 - 2.0 * ni));
-			G = E / (2.0 * (1.0 + ni));
-			
-			Warea = 0.5 * (lambda + 0.666666666666 * G) * epsilon_ii_squared * Sdelta;
-			Wdistortion = G * epsilon_ij_prime_epsilon_ij_prime * Sdelta;
-			W += Warea + Wdistortion;
-		}
-
-		// Average Strain Energy (ASE)
-		//////////////////////////////////////////////////////////////////////////
-		
-		double area1 = vcg::tri::Stat<MeshType>::ComputeMeshArea(refmesh);
-		//double area2 = vcg::tri::Stat<MeshType>::ComputeMeshArea(mesh);
-
-		// the area if the deformed mesh is considered the same of the original one,
-		// since the deformation is assumed to be small 
-
-		return W / (area1);
-	}
-
-};
-
-#endif  /* PERCEPTUALMETRICS_H */
+/****************************************************************************
+* MeshLab                                                           o o     *
+* A versatile mesh processing toolbox                             o     o   *
+*                                                                _   O  _   *
+* Copyright(C) 2005                                                \/)\/    *
+* Visual Computing Lab                                            /\/|      *
+* ISTI - Italian National Research Council                           |      *
+*                                                                    \      *
+* All rights reserved.                                                      *
+*                                                                           *
+* This program is free software; you can redistribute it and/or modify      *   
+* it under the terms of the GNU General Public License as published by      *
+* the Free Software Foundation; either version 2 of the License, or         *
+* (at your option) any later version.                                       *
+*                                                                           *
+* This program is distributed in the hope that it will be useful,           *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
+* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
+* for more details.                                                         *
+*                                                                           *
+****************************************************************************/
+
+/****************************************************************************
+  History
+$Log: perceptualmetrics.h,v $
+****************************************************************************/
+
+#ifndef PERCEPTUALMETRICS_H
+#define PERCEPTUALMETRICS_H
+
+#include <QObject>
+
+#include <common/interfaces.h>
+#include <vcg/complex/algorithms/stat.h>
+
+template <class MeshType>
+class PerceptualMetrics
+{
+
+// definitions
+public:
+
+	typedef typename MeshType::CoordType         CoordType;
+	typedef typename MeshType::ScalarType        ScalarType;
+	typedef typename MeshType::VertexType        VertexType;
+	typedef typename MeshType::VertexPointer     VertexPointer;
+	typedef typename MeshType::CoordType         CoordType;
+	typedef typename MeshType::VertexIterator    VertexIterator;
+	typedef typename MeshType::FacePointer       FacePointer;
+	typedef typename MeshType::FaceIterator      FaceIterator;
+	typedef typename MeshType::FaceType          FaceType;
+	typedef typename MeshType::FaceContainer     FaceContainer;
+
+
+// private methods
+private:
+
+	static void planeProjection(double a, double b, double c, double d, 
+		const CoordType &axis1, const CoordType &axis2, const CoordType & O, 
+		const CoordType &p, double &xcoor, double &ycoor)
+	{
+		double u = p[0];
+		double v = p[1];
+		double w = p[2];
+
+		CoordType Pproj;
+
+		double num = a*u + b*v + c*w + d;
+
+		// den = a*a + b*b + c*c that is assumed one in this case (!)
+		Pproj[0] = u - a * num; // num/den
+		Pproj[1] = v - b * num; // num/den
+		Pproj[2] = w - c * num; // num/den
+
+		Pproj -= O;
+
+		xcoor = axis1 * Pproj;
+		ycoor = axis2 * Pproj;
+	}
+
+	static void computingDisplacementFunctionCoefficients(FacePointer f0, FacePointer f1, 
+		double & a1u, double & a2u, double & a3u, double & a1v, double & a2v, double & a3v,
+		double & area)
+	{
+		CoordType pD = f0->V(0)->P();
+		CoordType pE = f0->V(1)->P();
+		CoordType pF = f0->V(2)->P();
+
+		CoordType pDp = f1->V(0)->P();
+		CoordType pEp = f1->V(1)->P();
+		CoordType pFp = f1->V(2)->P();
+
+		CoordType axis1 = (pE-pD);
+		CoordType axis2 = (pF-pD);
+		CoordType N = axis1 ^ axis2;
+
+		// axis adjustment
+		axis2 = N ^ axis1;
+
+		axis1.Normalize();
+		axis2.Normalize();
+		N.Normalize();
+
+		double a = N[0];
+		double b = N[1];
+		double c = N[2];
+		double d = -(a * pD[0] + b * pD[1] + c * pD[2]);
+
+		// triangle in the local reference system
+		double xD,yD,xE,yE,xF,yF;
+		planeProjection(a,b,c,d, axis1, axis2, pD, pD, xD, yD);
+		planeProjection(a,b,c,d, axis1, axis2, pD, pE, xE, yE);
+		planeProjection(a,b,c,d, axis1, axis2, pD, pF, xF, yF);
+
+		// triangle in the local reference system after deformations
+		double xDp,yDp,xEp,yEp,xFp,yFp;
+		planeProjection(a,b,c,d, axis1, axis2, pD, pDp, xDp, yDp);
+		planeProjection(a,b,c,d, axis1, axis2, pD, pEp, xEp, yEp);
+		planeProjection(a,b,c,d, axis1, axis2, pD, pFp, xFp, yFp);
+
+		// deformation
+		double uD = xDp - xD;
+		double vD = yDp - yD;
+
+		double uE = xEp - xE;
+		double vE = yEp - yE;
+
+		double uF = xFp - xF;
+		double vF = yFp - yF;
+
+		// parameterization
+		double AA = (yE-yF) * xD + (yF-yD) * xE + (yD-yE) * xF;  // AA = 2A
+		double factor = 1.0 / (AA);
+
+		a1u = factor * ((xE*yF - xF*yE)*uD + (xF*yD - xD*yF)*uE + (xD*yE - xE*yD)*uF);
+		a2u = factor * ((yE-yF)*uD + (yF-yD)*uE + (yD-yE)*uF);
+		a3u = factor * ((xF-xE)*uD + (xD-xF)*uE + (xE-xD)*uF);
+
+		a1v = factor * ((xE*yF - xF*yE)*vD + (xF*yD - xD*yF)*vE + (xD*yE - xE*yD)*vF);
+		a2v = factor * ((yE-yF)*vD + (yF-yD)*vE + (yD-yE)*vF);
+		a3v = factor * ((xF-xE)*vD + (xD-xF)*vE + (xE-xD)*vF);
+
+		area = 0.5 * AA;
+	}
+
+// public methods
+public:
+
+	static double roughnessMultiscale(MeshType & refmesh, MeshType & mesh)
+	{
+		//...TODO...
+		return 0.0;
+	}
+
+	static double roughnessSmoothing(MeshType & refmesh, MeshType & mesh)
+	{
+		//...TODO...
+		return 0.0;
+	}
+
+	static double strainEnergy(MeshType & refmesh, MeshType & mesh)
+	{
+		double epsilonx, epsilony, epsilonz;
+		double gammaxy, gammayz, gammazx;
+		double epsilonx_prime, epsilony_prime, epsilonz_prime;
+		double epsilon_ii_squared;
+		double epsilon_ij_prime_epsilon_ij_prime;
+		double Sdelta;    // Area of each triangle
+		double ni = 0.0;  // Poisson's ratio
+		double E = 1.0;   // Young's modulus
+		double lambda;    // Lame's first parameter
+		double G;
+		double Warea, Wdistortion, W;
+		double u,v;
+		double a1u,a2u,a3u;
+		double a1v,a2v,a3v;
+		double x,y;
+		double D;
+		
+		FacePointer f0;
+		FacePointer f1;
+
+		W = 0.0;
+		for (int i = 0; i < refmesh.fn; i++)
+		{
+			f0 = &refmesh.face[i];
+			f1 = &mesh.face[i];
+			
+			// displacement function are:
+			//    u = a1u + x a2u + y a3u 
+			//    v = a1v + x a2v + y a3v
+			computingDisplacementFunctionCoefficients(f0, f1, a1u, a2u, a3u, a1v, a2v, a3v, Sdelta);
+
+			// epsilonx = du / dx
+			epsilonx = a2u;
+
+			// epsilony = dv / dy
+			epsilony = a3v;
+
+			// epsilonz
+			epsilonz = (ni / (ni - 1.0)) * (epsilonx + epsilony);
+			
+			// gammaxy = dv / dx + du / dy
+			gammaxy = a2v + a3u;
+			gammayz = 0.0;
+			gammazx = 0.0;
+
+			// strain energy for a single triangle
+			///////////////////////////////////////////////////////////////////////////////////////
+			
+			epsilonx_prime = epsilonx - (epsilonx + epsilony + epsilonz) / 3.0;
+			epsilony_prime = epsilony - (epsilonx + epsilony + epsilonz) / 3.0;
+			epsilonz_prime = epsilonz - (epsilonx + epsilony + epsilonz) / 3.0;
+			
+			epsilon_ii_squared = (epsilonx + epsilony + epsilonz) * (epsilonx + epsilony + epsilonz);
+			epsilon_ij_prime_epsilon_ij_prime = epsilonx_prime * epsilonx_prime + epsilony_prime * epsilony_prime + 
+				epsilonz_prime * epsilonz_prime + 0.5 * (gammaxy*gammaxy + gammayz*gammayz + gammazx*gammazx);
+			
+			lambda = (E * ni) / ((1.0 + ni) * (1 - 2.0 * ni));
+			G = E / (2.0 * (1.0 + ni));
+			
+			Warea = 0.5 * (lambda + 0.666666666666 * G) * epsilon_ii_squared * Sdelta;
+			Wdistortion = G * epsilon_ij_prime_epsilon_ij_prime * Sdelta;
+			W += Warea + Wdistortion;
+		}
+
+		// Average Strain Energy (ASE)
+		//////////////////////////////////////////////////////////////////////////
+		
+		double area1 = vcg::tri::Stat<MeshType>::ComputeMeshArea(refmesh);
+		//double area2 = vcg::tri::Stat<MeshType>::ComputeMeshArea(mesh);
+
+		// the area if the deformed mesh is considered the same of the original one,
+		// since the deformation is assumed to be small 
+
+		return W / (area1);
+	}
+
+};
+
+#endif  /* PERCEPTUALMETRICS_H */