diff --git a/apps/sample/edgemesh_sampling/edgemesh_sampling.cpp b/apps/sample/edgemesh_sampling/edgemesh_sampling.cpp
index 6a8bb037..5765c8a8 100644
--- a/apps/sample/edgemesh_sampling/edgemesh_sampling.cpp
+++ b/apps/sample/edgemesh_sampling/edgemesh_sampling.cpp
@@ -45,13 +45,11 @@ class MyEdge    : public Edge<MyUsedTypes,edge::VertexRef, edge::VEAdj, edge::EE
 class MyMesh    : public tri::TriMesh< vector<MyVertex>, vector<MyFace> , vector<MyEdge>  > {};
 
 
-
-
 int main( int argc, char **argv )
 {
   if(argc<2)
   {
-    printf("Usage trimesh_base <meshfilename.obj> radius\n");
+    printf("Usage edgemesh_sampling <meshfilename.off> radius\n");
     return -1;
   }
 
@@ -90,7 +88,7 @@ int main( int argc, char **argv )
   tri::TrivialSampler<MyMesh> ps(sampleVec);
   tri::SurfaceSampling<MyMesh>::EdgeMeshUniform(e,ps,m.bbox.Diag()/90.0f);
   MyMesh sampleMesh;
-  tri::Build(sampleMesh,sampleVec);
+  tri::BuildMeshFromCoordVector(sampleMesh,sampleVec);
   tri::io::ExporterPLY<MyMesh>::Save(sampleMesh,"sampleMesh.ply");
   return 0;
 }
diff --git a/apps/sample/polygonmesh_base/polygonmesh.cpp b/apps/sample/polygonmesh_base/polygonmesh.cpp
index 99191dc0..920b5280 100644
--- a/apps/sample/polygonmesh_base/polygonmesh.cpp
+++ b/apps/sample/polygonmesh_base/polygonmesh.cpp
@@ -28,17 +28,14 @@
 #include <vcg/complex/algorithms/update/bounding.h>
 #include <vcg/complex/algorithms/update/normal.h>
 
-/*include the algorithms for mesh fixing  */
 #include <vcg/complex/algorithms/clean.h>
+#include <vcg/complex/algorithms/create/platonic.h>
 
 #include <wrap/io_trimesh/import.h>
 #include <wrap/io_trimesh/export_ply.h>
 
 /* include the support for polygon meshes (function to convert from/to trimesh)*/
-#include <vcg/complex/algorithms/polygon_support.h>
-
-/* include the support for polygon meshes (the component for the face )*/
-#include <vcg/simplex/face/component_polygon.h>
+//#include <vcg/complex/algorithms/polygon_support.h>
 
 /* include the support for half edges */
 #include <vcg/complex/algorithms/update/halfedge_indexed.h>
@@ -48,179 +45,173 @@ using namespace vcg;
 using namespace std;
 
 // forward declarations
-class CFace;
-class CVertex;
-class CHEdge;
-class CEdge;
-class MyPolyVertex;
+class TFace;
+class TVertex;
 
-struct CUsedTypes: public vcg::UsedTypes< vcg::Use<CVertex>::AsVertexType, vcg::Use<CFace>::AsFaceType >{};
+struct TUsedTypes: public vcg::UsedTypes< vcg::Use<TVertex>::AsVertexType, vcg::Use<TFace>::AsFaceType >{};
 
 
 
 /* Definition of a mesh of triangles
 */
-class CVertex : public Vertex< CUsedTypes,
-	vertex::BitFlags,
-	vertex::Coord3f, 
-	vertex::Normal3f,
-	vertex::Mark >{};
+class TVertex : public Vertex< TUsedTypes,
+    vertex::BitFlags,
+    vertex::Coord3f,
+    vertex::Normal3f,
+    vertex::Mark >{};
 
-class CFace   : public Face<   CUsedTypes,
-	face::VertexRef,	// three pointers to vertices
-	face::Normal3f,		// normal	
-	face::BitFlags,		// flags
-	face::FFAdj			// three pointers to adjacent faces
+class TFace   : public Face<   TUsedTypes,
+    face::VertexRef,	// three pointers to vertices
+    face::Normal3f,		// normal
+    face::BitFlags,		// flags
+    face::FFAdj			// three pointers to adjacent faces
 > {};
 
-/* the mesh is a container of vertices and a container of faces */ 
-class CMesh   : public vcg::tri::TriMesh< vector<CVertex>, vector<CFace> > {};
+/* the mesh is a container of vertices and a container of faces */
+class TMesh   : public vcg::tri::TriMesh< vector<TVertex>, vector<TFace> > {};
 
 
 /* Definition of a mesh of polygons that also supports half-edges
 */
-class MyPolyFace;
-class MyPolyVertex;
-struct PolyUsedTypes: public vcg::UsedTypes<vcg::Use<MyPolyVertex>	::AsVertexType,
-	 										vcg::Use<CEdge>			::AsEdgeType,
-											vcg::Use<CHEdge>		::AsHEdgeType,
-											vcg::Use<MyPolyFace>	::AsFaceType
-											>{};
+class PFace;
+class PVertex;
+class PHEdge;
+class PEdge;
+
+struct PUsedTypes: public vcg::UsedTypes<vcg::Use<PVertex>  ::AsVertexType,
+                                            vcg::Use<PEdge>	::AsEdgeType,
+                                            vcg::Use<PHEdge>::AsHEdgeType,
+                                            vcg::Use<PFace>	::AsFaceType
+                                            >{};
 
 //class DummyEdge: public vcg::Edge<PolyUsedTypes>{};
-class MyPolyVertex:public vcg::Vertex<	PolyUsedTypes,
-										vcg::vertex::Coord3f,
-										vcg::vertex::Normal3f,
-										vcg::vertex::Mark,
-										vcg::vertex::BitFlags, 
-										vcg::vertex::VHAdj>{} ;
+class PVertex:public vcg::Vertex<	PUsedTypes,
+                                        vcg::vertex::Coord3f,
+                                        vcg::vertex::Normal3f,
+                                        vcg::vertex::Mark,
+                                        vcg::vertex::BitFlags,
+                                        vcg::vertex::VHAdj>{} ;
 
-class CEdge : public Edge<PolyUsedTypes>{};
-class CHEdge : public HEdge< PolyUsedTypes, hedge::BitFlags,
-	//hedge::HFAdj,		// pointer to the face
-	//hedge::HOppAdj,	// pointer to the opposite edge
-	//hedge::HVAdj,		// pointer to the vertex
-	//hedge::HNextAdj,	// pointer to the next halfedge
-	hedge::HEdgeData		// the previous 4 components (just more handy, you can comment this and uncomment the previous four lines)
-	//,hedge::HPrevAdj	// pointer to the previous halfedge
+class PEdge : public Edge<PUsedTypes>{};
+class PHEdge : public HEdge< PUsedTypes, hedge::BitFlags,
+    //hedge::HFAdj,		// pointer to the face
+    //hedge::HOppAdj,	// pointer to the opposite edge
+    //hedge::HVAdj,		// pointer to the vertex
+    //hedge::HNextAdj,	// pointer to the next halfedge
+    hedge::HEdgeData		// the previous 4 components (just more handy, you can comment this and uncomment the previous four lines)
+    //,hedge::HPrevAdj	// pointer to the previous halfedge
 >{};
 
-class MyPolyFace:public vcg::Face<
-	 PolyUsedTypes
-	,vcg::face::PolyInfo // this is necessary  if you use component in vcg/simplex/face/component_polygon.h
-						 // It says "this class is a polygon and the memory for its components (e.g. pointer to its vertices
-						 // will be allocated dynamically")	
-	,vcg::face::PFVAdj	 // Pointer to the vertices (just like FVAdj )
-	,vcg::face::PFVAdj
-	,vcg::face::PFFAdj	 // Pointer to edge-adjacent face (just like FFAdj )
-	,vcg::face::PFHAdj	 // Pointer its half -edges  ( you may need this if you use half edges)
-	,vcg::face::BitFlags // bit flags
-	,vcg::face::Normal3f // normal
+class PFace:public vcg::Face<
+     PUsedTypes
+    ,vcg::face::PolyInfo // this is necessary  if you use component in vcg/simplex/face/component_polygon.h
+                         // It says "this class is a polygon and the memory for its components (e.g. pointer to its vertices
+                         // will be allocated dynamically")
+    ,vcg::face::PFVAdj	 // Pointer to the vertices (just like FVAdj )
+    ,vcg::face::PFVAdj
+    ,vcg::face::PFFAdj	 // Pointer to edge-adjacent face (just like FFAdj )
+    ,vcg::face::PFHAdj	 // Pointer its half -edges  ( you may need this if you use half edges)
+    ,vcg::face::BitFlags // bit flags
+    ,vcg::face::Normal3f // normal
 > {};
 
-class MyPolyMesh: public 
-	vcg::tri::TriMesh< 
-	std::vector<MyPolyVertex>,	// the vector of vertices
-	std::vector<MyPolyFace >, 						// the vector of faces
-	std::vector<CHEdge>		,						// the vector of edges
- 	std::vector<CEdge> 								// the vector of edges
-	>{};
+class PMesh: public
+    vcg::tri::TriMesh<
+    std::vector<PVertex>,	// the vector of vertices
+    std::vector<PFace >, 						// the vector of faces
+    std::vector<PHEdge>		,						// the vector of edges
+    std::vector<PEdge> 								// the vector of edges
+    >{};
 
-MyPolyMesh pm;
+PMesh pm;
+TMesh tm0;
 
+int	main(int argc, char *argv[]) {
 
-////////////////////////////////////////////////////////////////////////////
-// Globals: the mesh, the OpenGL wrapper to draw the mesh and the trackball.
-CMesh mesh,mesh1;
+    int loadmask;
 
-int			main(int argc, char *argv[]) {
-
-	int loadmask;
-	
-	vcg::tri::io::PlyInfo pi;
-
-//	pm.hedge.reserve(100000);
 if(true){
-	/*
-	first way: 
-	1) read a polygon mesh that will be automatically converted in a triangle mesh tagging
-	  the internal edges (i.e. the edges that have been added for triangulating the polygons)
+    /*
+    first way:
+    1) read a polygon mesh that will be automatically converted in a triangle mesh tagging
+      the internal edges (i.e. the edges that have been added for triangulating the polygons)
     2) make some cleaning
-	3) import the tagged triangle mesh in a polygon mesh
-	*/
+    3) import the tagged triangle mesh in a polygon mesh
+    */
 //	vcg::tri::io::ImporterOBJ<CMesh>::Open(mesh,argv[1],loadmask);
-	vcg::tri::io::ImporterOFF<CMesh>::Open(mesh,argv[1],loadmask);
+//    vcg::tri::io::ImporterOFF<TMesh>::Open(tm0,argv[1],loadmask);
+    vcg::tri::Hexahedron(tm0);
+    vcg::tri::Clean<TMesh>::RemoveUnreferencedVertex(tm0);
+    vcg::tri::Clean<TMesh>::RemoveZeroAreaFace(tm0);
+    vcg::tri::UpdateTopology<TMesh>::FaceFace(tm0);
+    vcg::tri::Clean<TMesh>::RemoveNonManifoldFace(tm0);
+    vcg::tri::UpdateTopology<TMesh>::FaceFace(tm0);
+    assert(vcg::tri::Clean<TMesh>::CountNonManifoldEdgeFF(tm0)==0);
+    assert(vcg::tri::Clean<TMesh>::CountNonManifoldVertexFF(tm0)==0);
 
-	vcg::tri::Clean<CMesh>::RemoveUnreferencedVertex(mesh);
-	vcg::tri::Clean<CMesh>::RemoveZeroAreaFace(mesh);
-	vcg::tri::UpdateTopology<CMesh>::FaceFace(mesh);
-	vcg::tri::Clean<CMesh>::RemoveNonManifoldFace(mesh);
-	vcg::tri::UpdateTopology<CMesh>::FaceFace(mesh);
-	assert(vcg::tri::Clean<CMesh>::CountNonManifoldEdgeFF(mesh)==0);
-	assert(vcg::tri::Clean<CMesh>::CountNonManifoldVertexFF(mesh)==0);
-
-	// create a polygon meshe from a trimesh with tagged faces
-	vcg::tri::PolygonSupport<CMesh,MyPolyMesh>::ImportFromTriMesh(pm,mesh);
+    // create a polygon meshe from a trimesh with tagged faces
+    vcg::tri::PolygonSupport<TMesh,PMesh>::ImportFromTriMesh(pm,tm0);
 }
 else
 {
-	/* second way: 
-	Load into a polygon mesh straight away.
-	*/
-	vcg::tri::io::ImporterOBJ<MyPolyMesh>::Open(pm,argv[1],loadmask);
-	vcg::tri::UpdateTopology<MyPolyMesh>::FaceFace(pm);
-	vcg::tri::Clean<MyPolyMesh>::RemoveNonManifoldFace(pm);
-	vcg::tri::UpdateTopology<MyPolyMesh>::FaceFace(pm);
-	assert(vcg::tri::Clean<MyPolyMesh>::CountNonManifoldEdgeFF(pm));
-
+    /* second way:
+    Load into a polygon mesh straight away.
+    */
+    vcg::tri::io::ImporterOBJ<PMesh>::Open(pm,argv[1],loadmask);
+    vcg::tri::UpdateTopology<PMesh>::FaceFace(pm);
+    vcg::tri::Clean<PMesh>::RemoveNonManifoldFace(pm);
+    vcg::tri::UpdateTopology<PMesh>::FaceFace(pm);
+    assert(vcg::tri::Clean<PMesh>::CountNonManifoldEdgeFF(pm));
 }
 
 
-	// compute the half edges because I'm a half-edge programmer
-	vcg::tri::UpdateHalfEdges<MyPolyMesh>::FromIndexed(pm);
+    // compute the half edges because I'm a half-edge programmer
+    vcg::tri::UpdateHalfEdges<PMesh>::FromIndexed(pm);
 
-	// .... my half edge based code ......
+    // .... my half edge based code ......
 
-	// check for consistency
-	assert(vcg::tri::UpdateHalfEdges<MyPolyMesh>::CheckConsistency(pm));
+    // check for consistency
+    assert(vcg::tri::UpdateHalfEdges<PMesh>::CheckConsistency(pm));
 
-	int size =  pm.face.size();
+    int size =  pm.face.size();
 
-	// add a face to each face with more than 3 vertices ( just one pass)
-	 
-	for(int i = 0; i < size; ++i)
-		if(!(pm.face[i].IsD()))
-		if(pm.face[i].VN()>3){
-			MyPolyMesh::HEdgePointer ef =  pm.face[i].FHp();
-			MyPolyMesh::HEdgePointer ef1 = ef -> HNp();
-			ef1 = ef1->HNp();
-			vcg::tri::UpdateHalfEdges<MyPolyMesh>::AddHEdge(pm, ef, ef1 );
- 		}
-	assert(vcg::tri::UpdateHalfEdges<MyPolyMesh>::CheckConsistency(pm));
-	size =  pm.face.size();
+    // add a face to each face with more than 3 vertices ( just one pass)
 
-	// remove an edge for each face
-	 
-	for(int i = 0; i < size; ++i)
-		if(!(pm.face[i].IsD() ))
-		{
-			MyPolyMesh::HEdgePointer ef =  pm.face[i].FHp();
-			if( ef->HOp()->HFp() !=NULL){
-				vcg::tri::UpdateHalfEdges<MyPolyMesh>::RemoveHEdge(pm,ef);
-			}
- 		}
+    for(int i = 0; i < size; ++i)
+        if(!(pm.face[i].IsD()))
+        if(pm.face[i].VN()>3){
+            PMesh::HEdgePointer ef =  pm.face[i].FHp();
+            PMesh::HEdgePointer ef1 = ef -> HNp();
+            ef1 = ef1->HNp();
+            vcg::tri::UpdateHalfEdges<PMesh>::AddHEdge(pm, ef, ef1 );
+        }
+    assert(vcg::tri::UpdateHalfEdges<PMesh>::CheckConsistency(pm));
+    size =  pm.face.size();
 
-	// check for consistency
-	assert(vcg::tri::UpdateHalfEdges<MyPolyMesh>::CheckConsistency(pm));
+    // remove an edge for each face
 
-	// recompute indexed data structure from the half edge data structure
-	vcg::tri::UpdateIndexed<MyPolyMesh>::FromHalfEdges(pm );
- 
-	// create a triangle mesh from a polygon mesh
-	vcg::tri::PolygonSupport<CMesh,MyPolyMesh>::ImportFromPolyMesh(mesh1,pm);
+    for(int i = 0; i < size; ++i)
+        if(!(pm.face[i].IsD() ))
+        {
+            PMesh::HEdgePointer ef =  pm.face[i].FHp();
+            if( ef->HOp()->HFp() !=NULL){
+                vcg::tri::UpdateHalfEdges<PMesh>::RemoveHEdge(pm,ef);
+            }
+        }
 
-	// write out the triangle mesh
-	vcg::tri::io::ExporterPLY<CMesh>::Save(mesh1,"converted_out.ply",true,pi);
+    // check for consistency
+    assert(vcg::tri::UpdateHalfEdges<PMesh>::CheckConsistency(pm));
+
+    // recompute indexed data structure from the half edge data structure
+//    vcg::tri::UpdateIndexed<PMesh>::FromHalfEdges(pm );
+
+    // create a triangle mesh from a polygon mesh
+    TMesh tm1;
+    vcg::tri::PolygonSupport<TMesh,PMesh>::ImportFromPolyMesh(tm1,pm);
+
+    vcg::tri::io::PlyInfo pi;
+    vcg::tri::io::ExporterPLY<TMesh>::Save(tm1,"converted_tri.ply",false,pi);
+    vcg::tri::io::ExporterPLY<PMesh>::Save(pm,"converted_poly.ply",false,pi);
 }
 
 
diff --git a/apps/sample/trimesh_ball_pivoting/trimesh_ball_pivoting.cpp b/apps/sample/trimesh_ball_pivoting/trimesh_ball_pivoting.cpp
index 4cc9d4e6..8505d431 100644
--- a/apps/sample/trimesh_ball_pivoting/trimesh_ball_pivoting.cpp
+++ b/apps/sample/trimesh_ball_pivoting/trimesh_ball_pivoting.cpp
@@ -39,7 +39,7 @@ class MyFace;
 class MyVertex;
 
 struct MyUsedTypes : public UsedTypes<	Use<MyVertex>		::AsVertexType,
-																				Use<MyFace>			::AsFaceType>{};
+                                                                                Use<MyFace>			::AsFaceType>{};
 
 class MyVertex  : public Vertex< MyUsedTypes, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags, vertex::Mark>{};
 class MyFace    : public Face  < MyUsedTypes, face::VertexRef, face::Normal3f, face::BitFlags > {};
@@ -53,51 +53,49 @@ bool callback(int percent, const char *str) {
 int  main(int argc, char **argv)
 {
  if(argc<3)
-	{
-		printf(
-		"\n                  trimesh_ball_pivoting ("__DATE__")\n"
-			"						Visual Computing Group I.S.T.I. C.N.R.\n"
+    {
+        printf(
       "Usage: trimesh_ball_pivoting filein.ply fileout.ply [opt]\n"
       "options: \n"
       "-r <val> radius of the rolling ball\n"
       "-c <val> clustering radius (as fraction of radius) default: 0.05\n"
-			);
-		exit(0);
-	}
+            );
+        exit(0);
+    }
 
    float radius = 0.0f;
    float clustering = 0.05;
    int i = 3;
-	while(i<argc)
-		{
-			if(argv[i][0]!='-')
-				{printf("Error unable to parse option '%s'\n",argv[i]); exit(0);}
-			switch(argv[i][1])
-			{				
-				case 'r' :	radius = atof(argv[++i]); printf("Using %f sphere radius\n",radius);  break;
-				case 'c' :	clustering = atof(argv[++i]); printf("Using %f clustering radius\n",clustering); break;
-      
-				default : {printf("Error unable to parse option '%s'\n",argv[i]); exit(0);}
-			}
-			++i;
-		}
-    if(radius == 0) 
-      printf("Autodetecting ball radius...\n");
-                
-	MyMesh m;
+    while(i<argc)
+        {
+            if(argv[i][0]!='-')
+                {printf("Error unable to parse option '%s'\n",argv[i]); exit(0);}
+            switch(argv[i][1])
+            {
+                case 'r' :	radius = atof(argv[++i]); printf("Using %f sphere radius\n",radius);  break;
+                case 'c' :	clustering = atof(argv[++i]); printf("Using %f clustering radius\n",clustering); break;
 
-	if(vcg::tri::io::ImporterPLY<MyMesh>::Open(m,argv[1])!=0)
-		{
+                default : {printf("Error unable to parse option '%s'\n",argv[i]); exit(0);}
+            }
+            ++i;
+        }
+    if(radius == 0)
+      printf("Autodetecting ball radius...\n");
+
+    MyMesh m;
+
+    if(vcg::tri::io::ImporterPLY<MyMesh>::Open(m,argv[1])!=0)
+        {
       printf("Error reading file  %s\n",argv[1]);
-			exit(0);
-		}
+            exit(0);
+        }
   vcg::tri::UpdateBounding<MyMesh>::Box(m);
   vcg::tri::UpdateNormal<MyMesh>::PerFace(m);
   printf("Input mesh  vn:%i fn:%i\n",m.VN(),m.FN());
 
   int t0=clock();
   // Initialization
-  tri::BallPivoting<MyMesh> pivot(m, radius, clustering); 
+  tri::BallPivoting<MyMesh> pivot(m, radius, clustering);
   printf("Ball radius: %f\nClustering points withing %f radii\n", pivot.radius, clustering);
 
   int t1=clock();
@@ -108,7 +106,7 @@ int  main(int argc, char **argv)
 
   printf("Output mesh vn:%i fn:%i\n",m.VN(),m.FN());
   printf("Created in :%i msec (%i+%i)\n",t2-t0,t1-t0,t2-t1);
-	
+
   vcg::tri::io::PlyInfo pi;
   vcg::tri::io::ExporterPLY<MyMesh>::Save(m,argv[2],pi.mask);
   return 0;
diff --git a/apps/sample/trimesh_copy/trimesh_copy.cpp b/apps/sample/trimesh_copy/trimesh_copy.cpp
index e31572df..302f7861 100644
--- a/apps/sample/trimesh_copy/trimesh_copy.cpp
+++ b/apps/sample/trimesh_copy/trimesh_copy.cpp
@@ -26,9 +26,9 @@ class MyVertex  : public vcg::Vertex< MyUsedTypes,vcg::vertex::VFAdj,vcg::vertex
 class MyEdge : public vcg::Edge< MyUsedTypes> {};
 
 class MyFace    : public vcg::Face< MyUsedTypes,
-	vcg::face::VFAdj,
-	vcg::face::VertexRef,
-	vcg::face::BitFlags > {};
+    vcg::face::VFAdj,
+    vcg::face::VertexRef,
+    vcg::face::BitFlags > {};
 
 // the main mesh class
 class MyMesh    : public vcg::tri::TriMesh<std::vector<MyVertex>, std::vector<MyFace> > {};
@@ -39,8 +39,8 @@ class OcfFace;
 
 // Declaration of the semantic of the used types
 class OcfUsedTypes: public vcg::UsedTypes < vcg::Use<OcfVertex>::AsVertexType,
-	vcg::Use<OcfEdge   >::AsEdgeType,
-	vcg::Use<OcfFace  >::AsFaceType >{};
+    vcg::Use<OcfEdge   >::AsEdgeType,
+    vcg::Use<OcfFace  >::AsFaceType >{};
 
 
 // The Main Vertex Class
@@ -61,26 +61,18 @@ class OcfEdge : public vcg::Edge<OcfUsedTypes>
 // Each face needs 32 byte, on 32bit arch. and 48 byte on 64bit arch.
 class OcfFace    : public vcg::Face<  OcfUsedTypes,vcg::face::InfoOcf,vcg::face::VertexRef,vcg::face::BitFlags,vcg::face::VFAdjOcf> {};
 
-class OcfMesh    : public vcg::tri::TriMesh< vcg::vertex::vector_ocf<OcfVertex>, vcg::face::vector_ocf<OcfFace> > 
+class OcfMesh    : public vcg::tri::TriMesh< vcg::vertex::vector_ocf<OcfVertex>, vcg::face::vector_ocf<OcfFace> >
 {
 };
 
 void Usage()
 {
-	printf(
-		"---------------------------------\n"
-		"         TriMeshCopy V.1.0 \n"
-		"     http://vcg.isti.cnr.it\n"
-		"    http://vcg.sourceforge.net\n"
-		"   release date: "__DATE__"\n"
-		"---------------------------------\n\n"
-		"TriMeshCopy 1.0 \n"__DATE__"\n"
-		"Copyright 2003-2012 Visual Computing Lab I.S.T.I. C.N.R.\n"
-		"\nUsage:  "\
-		"trimeshcopy fileIn -(n|o) [fileOut]\n"\
-		"trimeshcopy test vcg::MeshCopy efficiency.\nIt imports a fileIn file into a user defined mesh and test how long vcg::MeshCopy needs to copy the imported mesh in a second one.The copy time is expressed in milliseconds.\nIf the -n flag is used a non-optional attributes mesh will be tested, defining -o, instead, the target mesh will be an ocf one.\nA fileOut file can be passed to the tool in order to check if the mesh was successfully copied.\nThe file will be exported in PLY file format.\n"
-		);
-	exit(-1);
+    printf(
+        "\nUsage:  "\
+        "trimeshcopy fileIn -(n|o) [fileOut]\n"\
+        "trimeshcopy test vcg::MeshCopy efficiency.\nIt imports a fileIn file into a user defined mesh and test how long vcg::MeshCopy needs to copy the imported mesh in a second one.The copy time is expressed in milliseconds.\nIf the -n flag is used a non-optional attributes mesh will be tested, defining -o, instead, the target mesh will be an ocf one.\nA fileOut file can be passed to the tool in order to check if the mesh was successfully copied.\nThe file will be exported in PLY file format.\n"
+        );
+    exit(-1);
 }
 
 template <class MeshType>
@@ -117,7 +109,7 @@ bool UnitTest_Append(const char *filename1, const char *filename2)
 
 int main(int /*argc*/ ,char**argv)
 {
-	UnitTest_Append<MyMesh>(argv[1],"out.ply");
-	UnitTest_Append<OcfMesh>(argv[1],"out.ply");
-	return 0;
+    UnitTest_Append<MyMesh>(argv[1],"out.ply");
+    UnitTest_Append<OcfMesh>(argv[1],"out.ply");
+    return 0;
 }
diff --git a/apps/sample/trimesh_geodesic/trimesh_geodesic.cpp b/apps/sample/trimesh_geodesic/trimesh_geodesic.cpp
index f62394f5..1b035780 100644
--- a/apps/sample/trimesh_geodesic/trimesh_geodesic.cpp
+++ b/apps/sample/trimesh_geodesic/trimesh_geodesic.cpp
@@ -22,9 +22,12 @@
 ****************************************************************************/
 #include<vcg/complex/complex.h>
 
-#include<wrap/io_trimesh/import_off.h>
+#include<wrap/io_trimesh/import_ply.h>
+#include<wrap/io_trimesh/export_ply.h>
 
+#include<vcg/complex/algorithms/point_sampling.h>
 #include<vcg/complex/algorithms/geodesic.h>
+#include<vcg/complex/algorithms/update/color.h>
 
 using namespace vcg;
 using namespace std;
@@ -36,8 +39,8 @@ struct MyUsedTypes : public UsedTypes<	Use<MyVertex>   ::AsVertexType,
                                         Use<MyEdge>     ::AsEdgeType,
                                         Use<MyFace>     ::AsFaceType>{};
 
-class MyVertex  : public Vertex<MyUsedTypes, vertex::Coord3f, vertex::Normal3f, vertex::BitFlags  >{};
-class MyFace    : public Face< MyUsedTypes, face::FFAdj,  face::VertexRef, face::BitFlags > {};
+class MyVertex  : public Vertex<MyUsedTypes, vertex::Coord3f, vertex::Normal3f, vertex::Mark, vertex::VFAdj, vertex::Color4b, vertex::Qualityf, vertex::BitFlags  >{};
+class MyFace    : public Face< MyUsedTypes, face::VFAdj,  face::VertexRef, face::Normal3f, face::BitFlags > {};
 class MyEdge    : public Edge<MyUsedTypes>{};
 class MyMesh    : public tri::TriMesh< vector<MyVertex>, vector<MyFace> , vector<MyEdge>  > {};
 
@@ -45,20 +48,47 @@ int main( int argc, char **argv )
 {
   if(argc<2)
   {
-    printf("Usage trimesh_base <meshfilename.obj>\n");
-    return -1;
+    printf("Usage trimesh_geodesic <meshfilename.obj>\n");
+//    return -1;
   }
 
   MyMesh m;
 
-  if(tri::io::ImporterOFF<MyMesh>::Open(m,argv[1])!=0)
+//  if(tri::io::ImporterPLY<MyMesh>::Open(m,"../../meshes/disk_irregular_1k.ply")!=0)
+    if(tri::io::ImporterPLY<MyMesh>::Open(m,"../../meshes/disk_irregular_650k.ply")!=0)
   {
     printf("Error reading file  %s\n",argv[1]);
     exit(0);
   }
-  vector<Point3f> pointVec;
-  float radius;
-  tri::PoissonSampling<MyMesh>(m,pointVec,1000,radius);
+
+  Point3f c=m.bbox.Center();
+  MyVertex*closest=&*m.vert.begin();
+  float minDist = Distance(closest->P(),c);
+  for(MyMesh::VertexIterator vi=m.vert.begin();vi!=m.vert.end(); ++vi)
+  {
+    if(Distance(vi->P(),c)<minDist)
+    {
+      minDist = Distance(vi->P(),c);
+      closest = &*vi;
+    }
+  }
+  vector<MyVertex*> seedVec;
+  seedVec.push_back(closest);
+  tri::EuclideanDistance<MyMesh> ed;
+  tri::Clean<MyMesh>::RemoveUnreferencedVertex(m);
+  tri::Allocator<MyMesh>::CompactEveryVector(m);
+  tri::UpdateTopology<MyMesh>::VertexFace(m);
+  tri::Geodesic<MyMesh>::Compute(m,seedVec,ed);
+  pair<float,float> minmax = tri::Stat<MyMesh>::ComputePerVertexQualityMinMax(m);
+  tri::UpdateColor<MyMesh>::PerVertexQualityRamp(m);
+  printf("min %f max %f\n",minmax.first,minmax.second);
+  tri::io::ExporterPLY<MyMesh>::Save(m,"base.ply",tri::io::Mask::IOM_VERTCOLOR | tri::io::Mask::IOM_VERTQUALITY);
+  int t0=clock();
+  tri::Geodesic<MyMesh>::PerVertexDijsktraCompute(m,seedVec,ed);
+  int t1=clock();
+  printf("Geodesic dijkstra %6.3f\n",float(t1-t0)/CLOCKS_PER_SEC);
+  tri::UpdateColor<MyMesh>::PerVertexQualityRamp(m);
+  tri::io::ExporterPLY<MyMesh>::Save(m,"base_d.ply",tri::io::Mask::IOM_VERTCOLOR | tri::io::Mask::IOM_VERTQUALITY);
 
   return 0;
 }
diff --git a/apps/sample/trimesh_geodesic/trimesh_geodesic.pro b/apps/sample/trimesh_geodesic/trimesh_geodesic.pro
index 31d41730..2bce06e6 100644
--- a/apps/sample/trimesh_geodesic/trimesh_geodesic.pro
+++ b/apps/sample/trimesh_geodesic/trimesh_geodesic.pro
@@ -1,3 +1,3 @@
 include(../common.pri)
 TARGET = trimesh_geodesic
-SOURCES += trimesh_geodesic.cpp
+SOURCES += trimesh_geodesic.cpp ../../../wrap/ply/plylib.cpp
diff --git a/apps/sample/trimesh_hole/trimesh_hole.cpp b/apps/sample/trimesh_hole/trimesh_hole.cpp
index 0a84f08a..93886b44 100644
--- a/apps/sample/trimesh_hole/trimesh_hole.cpp
+++ b/apps/sample/trimesh_hole/trimesh_hole.cpp
@@ -73,13 +73,13 @@ bool NormalTest(typename face::Pos<typename MESH::FaceType> pos)
 {
     //giro intorno al vertice e controllo le normali
     typename MESH::ScalarType thr = 0.0f;
-        typename MESH::CoordType NdP = vcg::Normal<typename MESH::FaceType>(*pos.f);
+        typename MESH::CoordType NdP = vcg::TriangleNormal<typename MESH::FaceType>(*pos.f);
     typename MESH::CoordType tmp, oop, soglia = typename MESH::CoordType(thr,thr,thr);
     face::Pos<typename MESH::FaceType> aux=pos;
     do{
         aux.FlipF();
         aux.FlipE();
-                oop = Abs(tmp - ::vcg::Normal<typename MESH::FaceType>(*pos.f));
+                oop = Abs(tmp - ::vcg::TriangleNormal<typename MESH::FaceType>(*pos.f));
         if(oop < soglia )return false;
     }while(aux != pos && !aux.IsBorder());
 
@@ -91,7 +91,7 @@ int main(int argc,char ** argv){
     if(argc<5)
     {
         printf(
-            "\n     HoleFilling ("__DATE__")\n"
+            "\n     HoleFilling (" __DATE__ ")\n"
             "Visual Computing Group I.S.T.I. C.N.R.\n"
       "Usage: trimesh_hole #algorithm #size filein.ply fileout.ply \n"
             "#algorithm: \n"
diff --git a/apps/sample/trimesh_join/trimesh_join.cpp b/apps/sample/trimesh_join/trimesh_join.cpp
index 8ebe3fbe..99509559 100644
--- a/apps/sample/trimesh_join/trimesh_join.cpp
+++ b/apps/sample/trimesh_join/trimesh_join.cpp
@@ -40,7 +40,7 @@ class MyFace;
 class MyVertex;
 
 struct MyUsedTypes : public UsedTypes<	Use<MyVertex>		::AsVertexType,
-																				Use<MyFace>			::AsFaceType>{};
+                                                                                Use<MyFace>			::AsFaceType>{};
 
 class MyVertex  : public Vertex <MyUsedTypes, vertex::Coord3f, vertex::BitFlags  >{};
 class MyFace    : public Face   < MyUsedTypes, face::VertexRef, face::BitFlags > {};
@@ -51,31 +51,29 @@ class MyMesh    : public vcg::tri::TriMesh< vector<MyVertex>, vector<MyFace> > {
 int main(int argc,char **argv )
 {
  if(argc<2)
-	{
-		printf(		"\n trimesh_join ("__DATE__")\n"
-		        	  "Visual Computing Group I.S.T.I. C.N.R.\n"
-                "Usage: trimesh_join [opt] filename.ply [filename.ply | *] \n"
+    {
+        printf(	"Usage: trimesh_join [opt] filename.ply [filename.ply | *] \n"
                 "where opt can be:\n"
                 "   -b xmin ymin zmin xmax ymax zmax  : \n"
                 "      Returns only mesh composed by faces inside specified bbox\n"
                 "   -t Just scan all the input files computing the total bbox\n"
-			);
-		exit(0);
-	}
+            );
+        exit(0);
+    }
 
   MyMesh ml,mr;
   Box3f ClipBB,TotBB;
   bool ClipFlag=false,MergeFlag=true;
-	int i=1; 
+    int i=1;
   // Parsing option loop
   while(argv[i][0]=='-')
   {
     switch(argv[i][1])
     {
-      case 'b': { 
+      case 'b': {
               if(argc<i+7) {
                 printf("Error in parsing bbox option");
-  		          exit(0);
+                  exit(0);
               }
               ClipBB.min=Point3f::Construct(atof(argv[i+1]),atof(argv[i+2]),atof(argv[i+3]));
               ClipBB.max=Point3f::Construct(atof(argv[i+4]),atof(argv[i+5]),atof(argv[i+6]));
@@ -90,36 +88,36 @@ int main(int argc,char **argv )
     }
   ++i;
   }
-	while(i<argc)
-		{
-		  if(vcg::tri::io::ImporterPLY<MyMesh>::Open(mr,argv[i])!=0)
-		  {
+    while(i<argc)
+        {
+          if(vcg::tri::io::ImporterPLY<MyMesh>::Open(mr,argv[i])!=0)
+          {
         printf("Error reading file  %s\n",argv[1]);
-			  exit(0);
-		  }
+              exit(0);
+          }
       printf("Input mesh %3i           vn:%9i fn:%9i\n",i, mr.VN(), mr.FN());
-      if(ClipFlag) 
-      { 
+      if(ClipFlag)
+      {
         tri::GenericVertexInterpolator<MyMesh> interp(mr);
         tri::TriMeshClipper<MyMesh>::Box(ClipBB,interp,mr);
         printf("              clipped to vn:%9i fn:%9i\n", mr.VN(), mr.FN());
       }
       tri::UpdateBounding<MyMesh>::Box(mr);
       TotBB.Add(mr.bbox);
-      
+
       if(MergeFlag) tri::Append<MyMesh,MyMesh>::Mesh(ml,mr); // append mesh mr to ml
-  		++i;
-		}
-  
+        ++i;
+        }
+
   printf("Output mesh vn:%i fn:%i\n",ml.VN(),ml.FN());
-	
+
   tri::io::ExporterPLY<MyMesh>::Save(ml,"joined.ply");
-  int dv=tri::Clean<MyMesh>::RemoveDuplicateVertex(ml); 
+  int dv=tri::Clean<MyMesh>::RemoveDuplicateVertex(ml);
   printf("Removed %i duplicated vertices\n",dv);
   tri::io::ExporterPLY<MyMesh>::Save(ml,"joined_unif.ply");
   printf("Final BBox of mesh :\n (%7.4f %7.4f %7.4f) - (%7.4f %7.4f %7.4f)\n",
                     TotBB.min[0],TotBB.min[1],TotBB.min[2],
                     TotBB.max[0],TotBB.max[1],TotBB.max[2]);
-       
+
 }
 
diff --git a/apps/sample/trimesh_kdtree/trimesh_kdtree.cpp b/apps/sample/trimesh_kdtree/trimesh_kdtree.cpp
index 1be2ed23..f034260d 100644
--- a/apps/sample/trimesh_kdtree/trimesh_kdtree.cpp
+++ b/apps/sample/trimesh_kdtree/trimesh_kdtree.cpp
@@ -23,9 +23,9 @@
 /*! \file trimesh_kdtree.cpp
 \ingroup code_sample
 
-\brief An example about using the kdtree and meshes
+\brief An example about using a kdtree to spatially index the vertexes of a mesh
 
-KdTree are one of the Spatial indexing data structure available.
+KdTree are one of the Spatial indexing data structures available.
 They are tailored for storing point-based structures and performing k-neighbours queries.
 In this simple example we simply compute the average distance of a vertex from its neighbours.
 \ref spatial_indexing for more Details
@@ -69,13 +69,13 @@ int main( int argc, char **argv )
 
   KdTree<float> tree(ww);
   KdTree<float>::PriorityQueue queue;
- 
+
   for (int j = 0; j < m.VN(); j++) {
       tree.doQueryK(m.vert[j].cP(), 3, queue);
-	  int neighbours = queue.getNofElements();
+      int neighbours = queue.getNofElements();
       float avgDist=0;
       for (int i = 0; i < neighbours; i++) {
-		  int neightId = queue.getIndex(i);
+          int neightId = queue.getIndex(i);
           avgDist += Distance(m.vert[j].cP(),m.vert[neightId].cP());
       }
       m.vert[j].Q() = avgDist/=neighbours;
diff --git a/apps/sample/trimesh_refine/trimesh_refine.cpp b/apps/sample/trimesh_refine/trimesh_refine.cpp
index 0bd80836..348b180d 100644
--- a/apps/sample/trimesh_refine/trimesh_refine.cpp
+++ b/apps/sample/trimesh_refine/trimesh_refine.cpp
@@ -40,7 +40,7 @@ int  main(int argc, char **argv)
  if(argc<4)
 	{
 		printf(
-		"\n                  PlyRefine ("__DATE__")\n"
+		"\n                  PlyRefine (" __DATE__ ")\n"
 			"						Visual Computing Group I.S.T.I. C.N.R.\n"
       "Usage: PlyRefine filein.ply fileout.[ply|off|obj|...] ref_step [opt] \n"
 			"Commands: \n"
diff --git a/apps/sample/trimesh_sampling/trimesh_sampling.cpp b/apps/sample/trimesh_sampling/trimesh_sampling.cpp
index 679762b2..0bd4c820 100644
--- a/apps/sample/trimesh_sampling/trimesh_sampling.cpp
+++ b/apps/sample/trimesh_sampling/trimesh_sampling.cpp
@@ -61,17 +61,18 @@ int main( int argc, char **argv )
   tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::SamplingRandomGenerator().initialize(time(0));
 
   //----------------------------------------------------------------------
-  // Basic Sample,
+  // Basic Sample of a mesh surface
   // Build a point cloud with points with a plain poisson disk distribution
+
   int t0=clock();
   vector<Point3f> pointVec;
-  float rad;
+  float rad=0;
   if(argc>2) rad=atof(argv[2]);
   int sampleNum=rad?0:1000;
   tri::PoissonSampling<MyMesh>(m,pointVec,sampleNum,rad);
   int t1=clock();
   MyMesh BasicPoissonMesh;
-  tri::Build(BasicPoissonMesh,pointVec);
+  tri::BuildMeshFromCoordVector(BasicPoissonMesh,pointVec);
 
   tri::io::ExporterOFF<MyMesh>::Save(BasicPoissonMesh,"BasicPoissonMesh.off");
   printf("Computed a basic poisson disk distribution of %i vertices radius is %6.3f in %5.2f sec\n",BasicPoissonMesh.VN(),rad,float(t1-t0)/CLOCKS_PER_SEC);
@@ -90,32 +91,32 @@ int main( int argc, char **argv )
   tri::UpdateNormal<MyMesh>::PerFace(m);
   tri::UpdateFlags<MyMesh>::FaceFauxCrease(m,math::ToRad(40.0f));
   tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::EdgeMontecarlo(m,mps,10000,false);
-  tri::Build(MontecarloEdgeMesh,sampleVec);
+  tri::BuildMeshFromCoordVector(MontecarloEdgeMesh,sampleVec);
   tri::io::ExporterOFF<MyMesh>::Save(MontecarloEdgeMesh,"MontecarloEdgeMesh.off");
 
   sampleVec.clear();
   tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::VertexCrease(m, mps);
-  tri::Build(PoissonEdgeMesh,sampleVec);
-  tri::io::ExporterOFF<MyMesh>::Save(PoissonEdgeMesh,"CreaseMesh.off");
+  tri::BuildMeshFromCoordVector(PoissonEdgeMesh,sampleVec);
+  tri::io::ExporterOFF<MyMesh>::Save(PoissonEdgeMesh,"VertexCreaseMesh.off");
 
   tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::PoissonDiskParam pp;
   pp.preGenMesh = &PoissonEdgeMesh;
   pp.preGenFlag=true;
   sampleVec.clear();
   tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::PoissonDiskPruning(mps, MontecarloEdgeMesh, rad, pp);
-  tri::Build(PoissonEdgeMesh,sampleVec);
+  tri::BuildMeshFromCoordVector(PoissonEdgeMesh,sampleVec);
   tri::io::ExporterOFF<MyMesh>::Save(PoissonEdgeMesh,"PoissonEdgeMesh.off");
 
   sampleVec.clear();
   tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::Montecarlo(m,mps,50000);
-  tri::Build(MontecarloSurfaceMesh,sampleVec);
+  tri::BuildMeshFromCoordVector(MontecarloSurfaceMesh,sampleVec);
   tri::io::ExporterOFF<MyMesh>::Save(MontecarloSurfaceMesh,"MontecarloSurfaceMesh.off");
 
   pp.preGenMesh = &PoissonEdgeMesh;
   pp.preGenFlag=true;
   sampleVec.clear();
   tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::PoissonDiskPruning(mps, MontecarloSurfaceMesh, rad, pp);
-  tri::Build(PoissonMesh,sampleVec);
+  tri::BuildMeshFromCoordVector(PoissonMesh,sampleVec);
   tri::io::ExporterOFF<MyMesh>::Save(PoissonMesh,"PoissonMesh.off");
   printf("Computed a feature aware poisson disk distribution of %i vertices radius is %6.3f\n",PoissonMesh.VN(),rad);
 
diff --git a/apps/sample/trimesh_texture/trimesh_texture.cpp b/apps/sample/trimesh_texture/trimesh_texture.cpp
index 3a6b2df6..64971049 100644
--- a/apps/sample/trimesh_texture/trimesh_texture.cpp
+++ b/apps/sample/trimesh_texture/trimesh_texture.cpp
@@ -73,7 +73,7 @@ int main(int ,char ** )
   std::vector<std::pair<int,MyMesh::FacePointer> > fpVec;
   tri::UpdateTopology<MyMesh>::FaceFace(tm);
   tri::Clean<MyMesh>::ConnectedComponents(tm,fpVec);
-  printf("Mesh has %i texture components\n",fpVec.size());
+  printf("Mesh has %lu texture components\n",fpVec.size());
   tri::io::ExporterPLY<MyMesh>::Save(tm,"out.ply");
   std::vector< std::vector<Point2f> > outline2Vec;
 
@@ -99,13 +99,13 @@ int main(int ,char ** )
     outline2Vec.push_back(compOutline2Vec[largestInd]);
   }
 
-  printf("Mesh has %i texture components\n",outline2Vec.size());
+  printf("Mesh has %lu texture components\n",outline2Vec.size());
 
   Outline2Dumper::Param pp;
   Similarity2f sim;
   sim.sca=1024.0f;
   std::vector<Similarity2f> trVec(outline2Vec.size(),sim);
-  printf("Mesh has %i texture components\n",outline2Vec.size());
+  printf("Mesh has %lu texture components\n",outline2Vec.size());
   Outline2Dumper::dumpOutline2VecPNG("PrePack.png",outline2Vec,trVec,pp);
 
   const Point2i containerSize(1024,1024);
diff --git a/apps/sample/trimesh_voronoiatlas/trimesh_voronoiatlas.cpp b/apps/sample/trimesh_voronoiatlas/trimesh_voronoiatlas.cpp
index d9387167..442d4818 100644
--- a/apps/sample/trimesh_voronoiatlas/trimesh_voronoiatlas.cpp
+++ b/apps/sample/trimesh_voronoiatlas/trimesh_voronoiatlas.cpp
@@ -39,7 +39,7 @@ struct MyUsedTypes : public UsedTypes<	Use<MyVertex>   ::AsVertexType,
                                         Use<MyFace>     ::AsFaceType>{};
 
 class MyVertex  : public Vertex<MyUsedTypes, vertex::InfoOcf, vertex::Coord3f, vertex::Normal3f, vertex::TexCoord2f, vertex::VFAdj , vertex::Qualityf, vertex::Color4b, vertex::BitFlags  >{};
-class MyFace    : public Face< MyUsedTypes, face::InfoOcf, face::VertexRef, face::BitFlags, face::FFAdjOcf ,face::VFAdj , face::WedgeTexCoord2f> {};
+class MyFace    : public Face< MyUsedTypes, face::InfoOcf, face::VertexRef, face::CurvatureDirf, face::BitFlags, face::FFAdjOcf ,face::VFAdj , face::WedgeTexCoord2f> {};
 class MyEdge    : public Edge< MyUsedTypes>{};
 class MyMesh    : public tri::TriMesh< vertex::vector_ocf<MyVertex>, face::vector_ocf<MyFace> , vector<MyEdge>  > {};
 
diff --git a/apps/sample/trimesh_voronoiclustering/trimesh_voronoiclustering.cpp b/apps/sample/trimesh_voronoiclustering/trimesh_voronoiclustering.cpp
index fc967c9a..5da04638 100644
--- a/apps/sample/trimesh_voronoiclustering/trimesh_voronoiclustering.cpp
+++ b/apps/sample/trimesh_voronoiclustering/trimesh_voronoiclustering.cpp
@@ -54,9 +54,9 @@ int main( int argc, char **argv )
     printf("Usage trimesh_voronoiclustering mesh region_num iterNum\n");
      return -1;
   }
-  int seed = atoi(argv[2]);
+  int seedNum = atoi(argv[2]);
   int iterNum   = atoi(argv[3]);
-  printf("Reading %s and sampling %i \n",argv[1],seed);
+  printf("Reading %s and sampling %i \n",argv[1],seedNum);
   int ret= tri::io::ImporterPLY<MyMesh>::Open(baseMesh,argv[1]);
   if(ret!=0)
   {
@@ -66,15 +66,14 @@ int main( int argc, char **argv )
 
   int randSeed=time(0);
   tri::UpdateTopology<MyMesh>::VertexFace(baseMesh);
-  std::vector<MyVertex *> seedVec;
-  tri::ClusteringSampler<MyMesh> cs(seedVec);
-  tri::SurfaceSampling<MyMesh, vcg::tri::ClusteringSampler<MyMesh> >::SamplingRandomGenerator().initialize(randSeed);
-  tri::SurfaceSampling<MyMesh, vcg::tri::ClusteringSampler<MyMesh> >::VertexUniform(baseMesh,cs,seed);
+  tri::TrivialPointerSampler<MyMesh> cs;
+  tri::SurfaceSampling<MyMesh, tri::TrivialPointerSampler<MyMesh> >::SamplingRandomGenerator().initialize(randSeed);
+  tri::SurfaceSampling<MyMesh, tri::TrivialPointerSampler<MyMesh> >::VertexUniform(baseMesh,cs,seedNum);
   tri::VoronoiProcessingParameter vpp;
   tri::EuclideanDistance<MyMesh> df;
-  tri::VoronoiProcessing<MyMesh>::VoronoiRelaxing(baseMesh, seedVec, iterNum, df, vpp);
-  tri::VoronoiProcessing<MyMesh>::TopologicalVertexColoring(baseMesh, seedVec);
-  tri::VoronoiProcessing<MyMesh>::ConvertDelaunayTriangulationToMesh(baseMesh,clusteredMesh,seedVec);
+  tri::VoronoiProcessing<MyMesh>::VoronoiRelaxing(baseMesh, cs.sampleVec, iterNum, df, vpp);
+  tri::VoronoiProcessing<MyMesh>::TopologicalVertexColoring(baseMesh, cs.sampleVec);
+  tri::VoronoiProcessing<MyMesh>::ConvertDelaunayTriangulationToMesh(baseMesh,clusteredMesh,cs.sampleVec);
 
   tri::io::ExporterPLY<MyMesh>::Save(baseMesh,"base.ply",tri::io::Mask::IOM_VERTCOLOR );
   tri::io::ExporterPLY<MyMesh>::Save(clusteredMesh,"clustered.ply");
diff --git a/apps/sample/trimesh_voronoisampling/trimesh_voronoisampling.cpp b/apps/sample/trimesh_voronoisampling/trimesh_voronoisampling.cpp
index 99334734..42a819a5 100644
--- a/apps/sample/trimesh_voronoisampling/trimesh_voronoisampling.cpp
+++ b/apps/sample/trimesh_voronoisampling/trimesh_voronoisampling.cpp
@@ -70,7 +70,8 @@ int main( int argc, char **argv )
   int sampleNum = atoi(argv[2]);
   int iterNum   = atoi(argv[3]);
 
-  bool fixCornerFlag=false;
+  bool fixCornerFlag=true;
+  bool uniformEdgeSamplingFlag = true;
 
   printf("Reading %s and sampling %i points with %i iteration\n",argv[1],sampleNum,iterNum);
   int ret= tri::io::ImporterPLY<MyMesh>::Open(baseMesh,argv[1]);
@@ -91,34 +92,42 @@ int main( int argc, char **argv )
   tri::VoronoiProcessing<MyMesh>::PreprocessForVoronoi(baseMesh,radius,vpp);
 
   tri::UpdateFlags<MyMesh>::FaceBorderFromVF(baseMesh);
-  tri::UpdateFlags<MyMesh>::VertexBorderFromFace(baseMesh);
+  tri::UpdateFlags<MyMesh>::VertexBorderFromFaceBorder(baseMesh);
 
 
   // -- Build a sampling with just corners (Poisson filtered)
   MyMesh poissonCornerMesh;
   std::vector<Point3f> sampleVec;
   tri::TrivialSampler<MyMesh> mps(sampleVec);
-  if(fixCornerFlag)
+  tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::VertexBorderCorner(baseMesh,mps,math::ToRad(150.f));
+  tri::BuildMeshFromCoordVector(poissonCornerMesh,sampleVec);
+  tri::io::ExporterPLY<MyMesh>::Save(poissonCornerMesh,"cornerMesh.ply");
+  sampleVec.clear();
+  MyMesh borderMesh,poissonBorderMesh;
+
+
+  if(uniformEdgeSamplingFlag)
   {
-    tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::VertexBorderCorner(baseMesh,mps,math::ToRad(150.f));
-    tri::Build(poissonCornerMesh,sampleVec);
-    tri::io::ExporterPLY<MyMesh>::Save(poissonCornerMesh,"cornerMesh.ply");
-    sampleVec.clear();
-    tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::PoissonDiskPruning(mps, poissonCornerMesh, radius, pp);
-    tri::Build(poissonCornerMesh,sampleVec);
-    tri::io::ExporterPLY<MyMesh>::Save(poissonCornerMesh,"poissonCornerMesh.ply");
-    // Now save the corner as Fixed Seeds for later...
-    std::vector<MyVertex *> fixedSeedVec;
-    tri::VoronoiProcessing<MyMesh>::SeedToVertexConversion(baseMesh,sampleVec,fixedSeedVec);
-    tri::VoronoiProcessing<MyMesh, tri::EuclideanDistance<MyMesh> >::FixVertexVector(baseMesh,fixedSeedVec);
-    vpp.preserveFixedSeed=true;
+
   }
+  else
+  {
+    if(fixCornerFlag)
+    {
+      tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::PoissonDiskPruning(mps, poissonCornerMesh, radius, pp);
+      tri::BuildMeshFromCoordVector(poissonCornerMesh,sampleVec);
+      tri::io::ExporterPLY<MyMesh>::Save(poissonCornerMesh,"poissonCornerMesh.ply");
+      // Now save the corner as Fixed Seeds for later...
+      std::vector<MyVertex *> fixedSeedVec;
+      tri::VoronoiProcessing<MyMesh>::SeedToVertexConversion(baseMesh,sampleVec,fixedSeedVec);
+      tri::VoronoiProcessing<MyMesh, tri::EuclideanDistance<MyMesh> >::FixVertexVector(baseMesh,fixedSeedVec);
+      vpp.preserveFixedSeed=true;
+    }
 
   // -- Build a sampling with points on the border
-  MyMesh borderMesh,poissonBorderMesh;
   sampleVec.clear();
   tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::VertexBorder(baseMesh,mps);
-  tri::Build(borderMesh,sampleVec);
+  tri::BuildMeshFromCoordVector(borderMesh,sampleVec);
   tri::io::ExporterPLY<MyMesh>::Save(borderMesh,"borderMesh.ply");
 
   // -- and then prune the border sampling with poisson strategy using the precomputed corner vertexes.
@@ -126,14 +135,16 @@ int main( int argc, char **argv )
   pp.preGenFlag=true;
   sampleVec.clear();
   tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::PoissonDiskPruning(mps, borderMesh, radius*0.8f, pp);
-  tri::Build(poissonBorderMesh,sampleVec);
+  tri::BuildMeshFromCoordVector(poissonBorderMesh,sampleVec);
+  }
+
   tri::io::ExporterPLY<MyMesh>::Save(poissonBorderMesh,"PoissonEdgeMesh.ply");
 
   // -- Build the montercarlo sampling of the surface
   MyMesh MontecarloSurfaceMesh;
   sampleVec.clear();
   tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::Montecarlo(baseMesh,mps,50000);
-  tri::Build(MontecarloSurfaceMesh,sampleVec);
+  tri::BuildMeshFromCoordVector(MontecarloSurfaceMesh,sampleVec);
   tri::io::ExporterPLY<MyMesh>::Save(MontecarloSurfaceMesh,"MontecarloSurfaceMesh.ply");
 
   // -- Prune the montecarlo sampling with poisson strategy using the precomputed vertexes on the border.
@@ -141,7 +152,7 @@ int main( int argc, char **argv )
   sampleVec.clear();
   tri::SurfaceSampling<MyMesh,tri::TrivialSampler<MyMesh> >::PoissonDiskPruning(mps, MontecarloSurfaceMesh, radius, pp);
   MyMesh PoissonMesh;
-  tri::Build(PoissonMesh,sampleVec);
+  tri::BuildMeshFromCoordVector(PoissonMesh,sampleVec);
   tri::io::ExporterPLY<MyMesh>::Save(PoissonMesh,"PoissonMesh.ply");
 
   std::vector<MyVertex *> seedVec;