diff --git a/wrap/io_trimesh/export_ply.h b/wrap/io_trimesh/export_ply.h
index 73ed0622..bf8f7669 100644
--- a/wrap/io_trimesh/export_ply.h
+++ b/wrap/io_trimesh/export_ply.h
@@ -96,7 +96,6 @@ namespace vcg {
                 static int Save(SaveMeshType &m,  const char * filename, bool binary, PlyInfo &pi, CallBackPos *cb=0)	// V1.0
                 {
                     FILE * fpout;
-                    int i;
                     const char * hbin = "binary_little_endian";
                     const char * hasc = "ascii";
                     const char * h;
@@ -127,7 +126,7 @@ namespace vcg {
                     {
                         const char * TFILE = "TextureFile";
 
-                        for(i=0; i < static_cast<int>(m.textures.size()); ++i)
+                        for(size_t i=0; i < m.textures.size(); ++i)
                             fprintf(fpout,"comment %s %s\n", TFILE, (const char *)(m.textures[i].c_str()) );
 
                         if(m.textures.size()>1 && (HasPerWedgeTexCoord(m) || HasPerVertexTexCoord(m))) multit = true;
@@ -211,8 +210,8 @@ namespace vcg {
                             "property float texture_v\n"
                             );
                     }
-                    for(i=0;i<pi.vdn;i++)
-                        fprintf(fpout,"property %s %s\n",pi.VertexData[i].stotypename(),pi.VertexData[i].propname);
+                    for(size_t i=0;i<pi.VertDescriptorVec.size();i++)
+                        fprintf(fpout,"property %s %s\n",pi.VertDescriptorVec[i].stotypename(),pi.VertDescriptorVec[i].propname);
 
                     fprintf(fpout,
                         "element face %d\n"
@@ -226,13 +225,17 @@ namespace vcg {
                             "property int flags\n"
                             );
                     }
-
-                    if( (HasPerWedgeTexCoord(m) || HasPerVertexTexCoord(m) ) && pi.mask & Mask::IOM_WEDGTEXCOORD ) // Note that you can save VT as WT if you really want it...
+                    // Note that you can save VT as WT if you really want it...
+                    if( (HasPerWedgeTexCoord(m) || HasPerVertexTexCoord(m) ) && pi.mask & Mask::IOM_WEDGTEXCOORD ) 
                     {
                         fprintf(fpout,
                             "property list uchar float texcoord\n"
                             );
-
+                    }
+                    // The per-face texture index information has to be saved (if necessary) both for PerVert and PerWedg 
+                    if( (     HasPerWedgeTexCoord(m)          || HasPerVertexTexCoord(m) ) && 
+                        (  (pi.mask & Mask::IOM_WEDGTEXCOORD) || (pi.mask & Mask::IOM_VERTTEXCOORD ) ) ) 
+                    {
                         if(multit)
                             fprintf(fpout,
                             "property int texnumber\n"
@@ -262,8 +265,8 @@ namespace vcg {
                         fprintf(fpout,"property %s quality\n",fqtp);
                     }
 
-                    for(i=0;i<pi.fdn;i++)
-                        fprintf(fpout,"property %s %s\n",pi.FaceData[i].stotypename(),pi.FaceData[i].propname);
+                    for(size_t i=0;i<pi.FaceDescriptorVec.size();i++)
+                        fprintf(fpout,"property %s %s\n",pi.FaceDescriptorVec[i].stotypename(),pi.FaceDescriptorVec[i].propname);
                     // Saving of edges is enabled if requested
                     if( m.en>0 && (pi.mask & Mask::IOM_EDGEINDEX) )
                         fprintf(fpout,
@@ -344,7 +347,59 @@ namespace vcg {
                     VertexPointer  vp;
                     VertexIterator vi;
                     SimpleTempData<typename SaveMeshType::VertContainer,int> indices(m.vert);
-
+                   
+                    std::vector<typename SaveMeshType:: template PerVertexAttributeHandle<float > > thfv(pi.VertDescriptorVec.size());
+                    std::vector<typename SaveMeshType:: template PerVertexAttributeHandle<double> > thdv(pi.VertDescriptorVec.size());
+                    std::vector<typename SaveMeshType:: template PerVertexAttributeHandle<int   > > thiv(pi.VertDescriptorVec.size());
+                    std::vector<typename SaveMeshType:: template PerVertexAttributeHandle<short > > thsv(pi.VertDescriptorVec.size());
+                    std::vector<typename SaveMeshType:: template PerVertexAttributeHandle<char  > > thcv(pi.VertDescriptorVec.size());
+                    std::vector<typename SaveMeshType:: template PerVertexAttributeHandle<unsigned char> >  thuv(pi.VertDescriptorVec.size());
+                    
+                    for(size_t i=0;i<pi.VertDescriptorVec.size();i++)
+                    {
+                      if(!pi.VertAttrNameVec.empty() && !pi.VertAttrNameVec[i].empty())
+                      { // trying to use named attribute to retrieve the value to store
+                        assert(vcg::tri::HasPerVertexAttribute(m,pi.VertAttrNameVec[i]));
+                        switch (pi.VertDescriptorVec[i].stotype1)
+                        {
+                        case ply::T_FLOAT  : thfv[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerVertexAttribute<float>(m,pi.VertAttrNameVec[i]); break;
+                        case ply::T_DOUBLE : thdv[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerVertexAttribute<double>(m,pi.VertAttrNameVec[i]); break; 
+                        case ply::T_INT    : thiv[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerVertexAttribute<int   >(m,pi.VertAttrNameVec[i]); break;
+                        case ply::T_SHORT  : thsv[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerVertexAttribute<short >(m,pi.VertAttrNameVec[i]); break;
+                        case ply::T_CHAR   : thcv[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerVertexAttribute<char>(m,pi.VertAttrNameVec[i]); break;
+                        case ply::T_UCHAR  : thuv[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerVertexAttribute<unsigned char>(m,pi.VertAttrNameVec[i]); break;
+                        default : assert(0);
+                        }
+                      }                      
+                    }                    
+                    std::vector<typename SaveMeshType:: template PerFaceAttributeHandle<float > > thff(pi.FaceDescriptorVec.size());
+                    std::vector<typename SaveMeshType:: template PerFaceAttributeHandle<double> > thdf(pi.FaceDescriptorVec.size());
+                    std::vector<typename SaveMeshType:: template PerFaceAttributeHandle<int   > > thif(pi.FaceDescriptorVec.size());
+                    std::vector<typename SaveMeshType:: template PerFaceAttributeHandle<short > > thsf(pi.FaceDescriptorVec.size());
+                    std::vector<typename SaveMeshType:: template PerFaceAttributeHandle<char  > > thcf(pi.FaceDescriptorVec.size());
+                    std::vector<typename SaveMeshType:: template PerFaceAttributeHandle<unsigned char> >  thuf(pi.FaceDescriptorVec.size());
+                    
+                    for(size_t i=0;i<pi.FaceDescriptorVec.size();i++)
+                    {
+                      if(!pi.FaceAttrNameVec.empty() && !pi.FaceAttrNameVec[i].empty())
+                      { // trying to use named attribute to retrieve the value to store
+                        assert(vcg::tri::HasPerFaceAttribute(m,pi.FaceAttrNameVec[i]));
+                        switch (pi.FaceDescriptorVec[i].stotype1)
+                        {
+                        case ply::T_FLOAT  : thff[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerFaceAttribute<float>(m,pi.FaceAttrNameVec[i]); break;
+                        case ply::T_DOUBLE : thdf[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerFaceAttribute<double>(m,pi.FaceAttrNameVec[i]); break; 
+                        case ply::T_INT    : thif[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerFaceAttribute<int   >(m,pi.FaceAttrNameVec[i]); break;
+                        case ply::T_SHORT  : thsf[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerFaceAttribute<short >(m,pi.FaceAttrNameVec[i]); break;
+                        case ply::T_CHAR   : thcf[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerFaceAttribute<char>(m,pi.FaceAttrNameVec[i]); break;
+                        case ply::T_UCHAR  : thuf[i] = vcg::tri::Allocator<SaveMeshType>::template FindPerFaceAttribute<unsigned char>(m,pi.FaceAttrNameVec[i]); break;
+                        default : assert(0);
+                        }
+                      }                      
+                    }
+                    
+                    
+                    
+                    
                     for(j=0,vi=m.vert.begin();vi!=m.vert.end();++vi){
                         vp=&(*vi);
                         indices[vi] = j;
@@ -381,22 +436,39 @@ namespace vcg {
 
                                 if( HasPerVertexTexCoord(m) && (pi.mask & Mask::IOM_VERTTEXCOORD) )
                                 {
-                                    t = float(vp->T().u()); fwrite(&t,sizeof(float),1,fpout);
-                                    t = float(vp->T().v()); fwrite(&t,sizeof(float),1,fpout);
+                                    t = ScalarType(vp->T().u()); fwrite(&t,sizeof(ScalarType),1,fpout);
+                                    t = ScalarType(vp->T().v()); fwrite(&t,sizeof(ScalarType),1,fpout);
                                 }
 
-                                for(i=0;i<pi.vdn;i++)
+                                for(size_t i=0;i<pi.VertDescriptorVec.size();i++)
                                 {
-                                    double td(0); float tf(0);int ti;short ts; char tc; unsigned char tuc;
-                                    switch (pi.VertexData[i].stotype1)
+                                    double td(0); float tf(0);int ti;short ts; char tc; unsigned char tu;
+                                    if(!pi.VertAttrNameVec.empty() && !pi.VertAttrNameVec[i].empty())
+                                    { // trying to use named attribute to retrieve the value to store
+                                      assert(vcg::tri::HasPerVertexAttribute(m,pi.VertAttrNameVec[i]));
+                                      switch (pi.VertDescriptorVec[i].stotype1)
+                                      {
+                                      case ply::T_FLOAT  : tf=thfv[i][vp]; fwrite(&tf, sizeof(float),1,fpout); break;
+                                      case ply::T_DOUBLE : td=thdv[i][vp]; fwrite(&td, sizeof(double),1,fpout); break;
+                                      case ply::T_INT    : ti=thiv[i][vp]; fwrite(&ti, sizeof(int),1,fpout); break;
+                                      case ply::T_SHORT  : ts=thsv[i][vp]; fwrite(&ts, sizeof(short),1,fpout); break;
+                                      case ply::T_CHAR   : tc=thcv[i][vp]; fwrite(&tc, sizeof(char),1,fpout); break;
+                                      case ply::T_UCHAR  : tu=thuv[i][vp]; fwrite(&tu,sizeof(unsigned char),1,fpout); break;
+                                      default : assert(0);
+                                      }
+                                    }
+                                    else
                                     {
-                                    case ply::T_FLOAT	 :		PlyConv(pi.VertexData[i].memtype1,  ((char *)vp)+pi.VertexData[i].offset1, tf );	fwrite(&tf, sizeof(float),1,fpout); break;
-                                    case ply::T_DOUBLE :		PlyConv(pi.VertexData[i].memtype1,  ((char *)vp)+pi.VertexData[i].offset1, td );	fwrite(&td, sizeof(double),1,fpout); break;
-                                    case ply::T_INT		 :		PlyConv(pi.VertexData[i].memtype1,  ((char *)vp)+pi.VertexData[i].offset1, ti );	fwrite(&ti, sizeof(int),1,fpout); break;
-                                    case ply::T_SHORT	 :		PlyConv(pi.VertexData[i].memtype1,  ((char *)vp)+pi.VertexData[i].offset1, ts );	fwrite(&ts, sizeof(short),1,fpout); break;
-                                    case ply::T_CHAR	 :		PlyConv(pi.VertexData[i].memtype1,  ((char *)vp)+pi.VertexData[i].offset1, tc );	fwrite(&tc, sizeof(char),1,fpout); break;
-                                    case ply::T_UCHAR	 :		PlyConv(pi.VertexData[i].memtype1,  ((char *)vp)+pi.VertexData[i].offset1, tuc);	fwrite(&tuc,sizeof(unsigned char),1,fpout); break;
-                                    default : assert(0);
+                                      switch (pi.VertDescriptorVec[i].stotype1)
+                                      {
+                                      case ply::T_FLOAT	 :		PlyConv(pi.VertDescriptorVec[i].memtype1,  ((char *)vp)+pi.VertDescriptorVec[i].offset1, tf );	fwrite(&tf, sizeof(float),1,fpout); break;
+                                      case ply::T_DOUBLE :		PlyConv(pi.VertDescriptorVec[i].memtype1,  ((char *)vp)+pi.VertDescriptorVec[i].offset1, td );	fwrite(&td, sizeof(double),1,fpout); break;
+                                      case ply::T_INT		 :		PlyConv(pi.VertDescriptorVec[i].memtype1,  ((char *)vp)+pi.VertDescriptorVec[i].offset1, ti );	fwrite(&ti, sizeof(int),1,fpout); break;
+                                      case ply::T_SHORT	 :		PlyConv(pi.VertDescriptorVec[i].memtype1,  ((char *)vp)+pi.VertDescriptorVec[i].offset1, ts );	fwrite(&ts, sizeof(short),1,fpout); break;
+                                      case ply::T_CHAR	 :		PlyConv(pi.VertDescriptorVec[i].memtype1,  ((char *)vp)+pi.VertDescriptorVec[i].offset1, tc );	fwrite(&tc, sizeof(char),1,fpout); break;
+                                      case ply::T_UCHAR	 :		PlyConv(pi.VertDescriptorVec[i].memtype1,  ((char *)vp)+pi.VertDescriptorVec[i].offset1, tu );	fwrite(&tu,sizeof(unsigned char),1,fpout); break;
+                                      default : assert(0);
+                                      }
                                     }
                                 }
                             }
@@ -422,19 +494,35 @@ namespace vcg {
                                 if( HasPerVertexTexCoord(m) && (pi.mask & Mask::IOM_VERTTEXCOORD) )
                                     fprintf(fpout,"%f %f",vp->T().u(),vp->T().v());
 
-                                for(i=0;i<pi.vdn;i++)
+                                for(size_t i=0;i<pi.VertDescriptorVec.size();i++)
                                 {
-                                    float tf(0); double td(0);
-                                    int ti;
-                                    switch (pi.VertexData[i].memtype1)
+                                    float tf(0); double td(0); int ti;
+                                    if(!pi.VertAttrNameVec.empty() && !pi.VertAttrNameVec[i].empty())
+                                    { // trying to use named attribute to retrieve the value to store
+                                      assert(vcg::tri::HasPerVertexAttribute(m,pi.VertAttrNameVec[i]));
+                                      switch (pi.VertDescriptorVec[i].stotype1)
+                                      {
+                                      case ply::T_FLOAT  : tf=thfv[i][vp]; fprintf(fpout,"%f ",tf); break;
+                                      case ply::T_DOUBLE : td=thdv[i][vp]; fprintf(fpout,"%lf ",td); break;
+                                      case ply::T_INT    : ti=thiv[i][vp]; fprintf(fpout,"%i ",ti); break;
+                                      case ply::T_SHORT  : ti=thsv[i][vp]; fprintf(fpout,"%i ",ti); break;
+                                      case ply::T_CHAR   : ti=thcv[i][vp]; fprintf(fpout,"%i ",ti); break;
+                                      case ply::T_UCHAR  : ti=thuv[i][vp]; fprintf(fpout,"%i ",ti); break;
+                                      default : assert(0);
+                                      }
+                                    }
+                                    else
                                     {
-                                    case ply::T_FLOAT	 :		tf=*( (float  *)        (((char *)vp)+pi.VertexData[i].offset1));	fprintf(fpout,"%f ",tf); break;
-                                    case ply::T_DOUBLE :    td=*( (double *)        (((char *)vp)+pi.VertexData[i].offset1));	fprintf(fpout,"%f ",tf); break;
-                                    case ply::T_INT		 :		ti=*( (int    *)        (((char *)vp)+pi.VertexData[i].offset1));	fprintf(fpout,"%i ",ti); break;
-                                    case ply::T_SHORT	 :		ti=*( (short  *)        (((char *)vp)+pi.VertexData[i].offset1)); fprintf(fpout,"%i ",ti); break;
-                                    case ply::T_CHAR	 :		ti=*( (char   *)        (((char *)vp)+pi.VertexData[i].offset1));	fprintf(fpout,"%i ",ti); break;
-                                    case ply::T_UCHAR	 :		ti=*( (unsigned char *) (((char *)vp)+pi.VertexData[i].offset1));	fprintf(fpout,"%i ",ti); break;
-                                    default : assert(0);
+                                      switch (pi.VertDescriptorVec[i].memtype1)
+                                      {
+                                      case ply::T_FLOAT	 :		tf=*( (float  *)        (((char *)vp)+pi.VertDescriptorVec[i].offset1)); fprintf(fpout,"%f ",tf); break;
+                                      case ply::T_DOUBLE :    td=*( (double *)        (((char *)vp)+pi.VertDescriptorVec[i].offset1)); fprintf(fpout,"%f ",tf); break;
+                                      case ply::T_INT		 :		ti=*( (int    *)        (((char *)vp)+pi.VertDescriptorVec[i].offset1)); fprintf(fpout,"%i ",ti); break;
+                                      case ply::T_SHORT	 :		ti=*( (short  *)        (((char *)vp)+pi.VertDescriptorVec[i].offset1)); fprintf(fpout,"%i ",ti); break;
+                                      case ply::T_CHAR	 :		ti=*( (char   *)        (((char *)vp)+pi.VertDescriptorVec[i].offset1)); fprintf(fpout,"%i ",ti); break;
+                                      case ply::T_UCHAR	 :		ti=*( (unsigned char *) (((char *)vp)+pi.VertDescriptorVec[i].offset1)); fprintf(fpout,"%i ",ti); break;
+                                      default : assert(0);
+                                      }
                                     }
                                 }
 
@@ -524,17 +612,34 @@ namespace vcg {
                                 fwrite( &(fp->Q()),sizeof(typename FaceType::ScalarType),1,fpout);
 
 
-                            for(i=0;i<pi.fdn;i++)
+                            for(size_t i=0;i<pi.FaceDescriptorVec.size();i++)
                             {
-                                double td(0); float tf(0);int ti;short ts; char tc; unsigned char tuc;
-                                switch (pi.FaceData[i].stotype1){
-                                case ply::T_FLOAT	 :		PlyConv(pi.FaceData[i].memtype1,  ((char *)fp)+pi.FaceData[i].offset1, tf );	fwrite(&tf, sizeof(float),1,fpout); break;
-                                case ply::T_DOUBLE :		PlyConv(pi.FaceData[i].memtype1,  ((char *)fp)+pi.FaceData[i].offset1, td );	fwrite(&td, sizeof(double),1,fpout); break;
-                                case ply::T_INT		 :		PlyConv(pi.FaceData[i].memtype1,  ((char *)fp)+pi.FaceData[i].offset1, ti );	fwrite(&ti, sizeof(int),1,fpout); break;
-                                case ply::T_SHORT	 :		PlyConv(pi.FaceData[i].memtype1,  ((char *)fp)+pi.FaceData[i].offset1, ts );	fwrite(&ts, sizeof(short),1,fpout); break;
-                                case ply::T_CHAR	 :		PlyConv(pi.FaceData[i].memtype1,  ((char *)fp)+pi.FaceData[i].offset1, tc );	fwrite(&tc, sizeof(char),1,fpout); break;
-                                case ply::T_UCHAR	 :		PlyConv(pi.FaceData[i].memtype1,  ((char *)fp)+pi.FaceData[i].offset1, tuc);	fwrite(&tuc,sizeof(unsigned char),1,fpout); break;
-                                default : assert(0);
+                                double td(0); float tf(0);int ti;short ts; char tc; unsigned char tu;
+                                if(!pi.FaceAttrNameVec.empty() && !pi.FaceAttrNameVec[i].empty())
+                                { // trying to use named attribute to retrieve the value to store
+                                  assert(vcg::tri::HasPerFaceAttribute(m,pi.FaceAttrNameVec[i]));
+                                  switch (pi.FaceDescriptorVec[i].stotype1)
+                                  {
+                                  case ply::T_FLOAT  : tf=thff[i][fp]; fwrite(&tf, sizeof(float),1,fpout); break;
+                                  case ply::T_DOUBLE : td=thdf[i][fp]; fwrite(&td, sizeof(double),1,fpout); break;
+                                  case ply::T_INT    : ti=thif[i][fp]; fwrite(&ti, sizeof(int),1,fpout); break;
+                                  case ply::T_SHORT  : ts=thsf[i][fp]; fwrite(&ts, sizeof(short),1,fpout); break;
+                                  case ply::T_CHAR   : tc=thcf[i][fp]; fwrite(&tc, sizeof(char),1,fpout); break;
+                                  case ply::T_UCHAR  : tu=thuf[i][fp]; fwrite(&tu,sizeof(unsigned char),1,fpout); break;
+                                  default : assert(0);
+                                  }
+                                }
+                                else
+                                {
+                                  switch (pi.FaceDescriptorVec[i].stotype1){
+                                  case ply::T_FLOAT	 :		PlyConv(pi.FaceDescriptorVec[i].memtype1,  ((char *)fp)+pi.FaceDescriptorVec[i].offset1, tf );	fwrite(&tf, sizeof(float),1,fpout); break;
+                                  case ply::T_DOUBLE :		PlyConv(pi.FaceDescriptorVec[i].memtype1,  ((char *)fp)+pi.FaceDescriptorVec[i].offset1, td );	fwrite(&td, sizeof(double),1,fpout); break;
+                                  case ply::T_INT		 :		PlyConv(pi.FaceDescriptorVec[i].memtype1,  ((char *)fp)+pi.FaceDescriptorVec[i].offset1, ti );	fwrite(&ti, sizeof(int),1,fpout); break;
+                                  case ply::T_SHORT	 :		PlyConv(pi.FaceDescriptorVec[i].memtype1,  ((char *)fp)+pi.FaceDescriptorVec[i].offset1, ts );	fwrite(&ts, sizeof(short),1,fpout); break;
+                                  case ply::T_CHAR	 :		PlyConv(pi.FaceDescriptorVec[i].memtype1,  ((char *)fp)+pi.FaceDescriptorVec[i].offset1, tc );	fwrite(&tc, sizeof(char),1,fpout); break;
+                                  case ply::T_UCHAR	 :		PlyConv(pi.FaceDescriptorVec[i].memtype1,  ((char *)fp)+pi.FaceDescriptorVec[i].offset1, tu );	fwrite(&tu, sizeof(unsigned char),1,fpout); break;
+                                  default : assert(0);
+                                  }
                                 }
                             }
                         }
@@ -589,20 +694,36 @@ namespace vcg {
                             if( HasPerFaceQuality(m) && (pi.mask & Mask::IOM_FACEQUALITY) )
                                 fprintf(fpout,"%.*g ",DGTFQ,fp->Q());
 
-                            for(i=0;i<pi.fdn;i++)
+                            for(size_t i=0;i<pi.FaceDescriptorVec.size();i++)
                             {
-                                float tf(0); double td(0);
-                                int ti;
-                                switch (pi.FaceData[i].memtype1)
+                              float tf(0); double td(0); int ti;
+                              if(!pi.FaceAttrNameVec.empty() && !pi.FaceAttrNameVec[i].empty())
+                              { // trying to use named attribute to retrieve the value to store
+                                assert(vcg::tri::HasPerFaceAttribute(m,pi.FaceAttrNameVec[i]));
+                                switch (pi.FaceDescriptorVec[i].stotype1)
                                 {
-                                case  ply::T_FLOAT	:		tf=*( (float  *)        (((char *)fp)+pi.FaceData[i].offset1));	fprintf(fpout,"%g ",tf); break;
-                                case  ply::T_DOUBLE :		td=*( (double *)        (((char *)fp)+pi.FaceData[i].offset1));	fprintf(fpout,"%g ",tf); break;
-                                case  ply::T_INT		:		ti=*( (int    *)        (((char *)fp)+pi.FaceData[i].offset1));	fprintf(fpout,"%i ",ti); break;
-                                case  ply::T_SHORT	:		ti=*( (short  *)        (((char *)fp)+pi.FaceData[i].offset1));	fprintf(fpout,"%i ",ti); break;
-                                case  ply::T_CHAR		:		ti=*( (char   *)        (((char *)fp)+pi.FaceData[i].offset1));	fprintf(fpout,"%i ",ti); break;
-                                case  ply::T_UCHAR	:		ti=*( (unsigned char *) (((char *)fp)+pi.FaceData[i].offset1));	fprintf(fpout,"%i ",ti); break;
+                                case ply::T_FLOAT  : tf=thff[i][fp]; fprintf(fpout,"%f ",tf); break;
+                                case ply::T_DOUBLE : td=thdf[i][fp]; fprintf(fpout,"%g ",td); break;
+                                case ply::T_INT    : ti=thif[i][fp]; fprintf(fpout,"%i ",ti); break;
+                                case ply::T_SHORT  : ti=thsf[i][fp]; fprintf(fpout,"%i ",ti); break;
+                                case ply::T_CHAR   : ti=thcf[i][fp]; fprintf(fpout,"%i ",ti); break;
+                                case ply::T_UCHAR  : ti=thuf[i][fp]; fprintf(fpout,"%i ",ti); break;
                                 default : assert(0);
                                 }
+                              }
+                              else
+                              {
+                                switch (pi.FaceDescriptorVec[i].memtype1)
+                                {
+                                case  ply::T_FLOAT	:		tf=*( (float  *)        (((char *)fp)+pi.FaceDescriptorVec[i].offset1));	fprintf(fpout,"%g ",tf); break;
+                                case  ply::T_DOUBLE :		td=*( (double *)        (((char *)fp)+pi.FaceDescriptorVec[i].offset1));	fprintf(fpout,"%g ",tf); break;
+                                case  ply::T_INT		:		ti=*( (int    *)        (((char *)fp)+pi.FaceDescriptorVec[i].offset1));	fprintf(fpout,"%i ",ti); break;
+                                case  ply::T_SHORT	:		ti=*( (short  *)        (((char *)fp)+pi.FaceDescriptorVec[i].offset1));	fprintf(fpout,"%i ",ti); break;
+                                case  ply::T_CHAR		:		ti=*( (char   *)        (((char *)fp)+pi.FaceDescriptorVec[i].offset1));	fprintf(fpout,"%i ",ti); break;
+                                case  ply::T_UCHAR	:		ti=*( (unsigned char *) (((char *)fp)+pi.FaceDescriptorVec[i].offset1));	fprintf(fpout,"%i ",ti); break;
+                                default : assert(0);
+                                }
+                              }
                             }
 
                             fprintf(fpout,"\n");
diff --git a/wrap/io_trimesh/import_ply.h b/wrap/io_trimesh/import_ply.h
index a37e9240..bd38024f 100644
--- a/wrap/io_trimesh/import_ply.h
+++ b/wrap/io_trimesh/import_ply.h
@@ -547,15 +547,15 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
     }
 
     // User defined descriptors
-    std::vector<PropDescriptor> VPV(pi.vdn); // property descriptor relative al tipo LoadPly_VertexAux
-    std::vector<PropDescriptor> FPV(pi.fdn); // property descriptor relative al tipo LoadPly_FaceAux
-    if(pi.vdn>0){
+    std::vector<PropDescriptor> VPV(pi.VertDescriptorVec.size()); // property descriptor relative al tipo LoadPly_VertexAux
+    std::vector<PropDescriptor> FPV(pi.FaceDescriptorVec.size()); // property descriptor relative al tipo LoadPly_FaceAux
+    if(pi.VertDescriptorVec.size()>0){
         // Compute the total size needed to load additional per vertex data.
         size_t totsz=0;
-        for(int i=0;i<pi.vdn;i++){
-            VPV[i] = pi.VertexData[i];
+        for(size_t i=0;i<pi.VertDescriptorVec.size();i++){
+            VPV[i] = pi.VertDescriptorVec[i];
             VPV[i].offset1=offsetof(LoadPly_VertAux<ScalarType>,data)+totsz;
-            totsz+=pi.VertexData[i].memtypesize();
+            totsz+=pi.VertDescriptorVec[i].memtypesize();
             if( pf.AddToRead(VPV[i])==-1 ) { pi.status = pf.GetError(); return pi.status; }
         }
         if(totsz > MAX_USER_DATA)
@@ -564,12 +564,12 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
             return pi.status;
         }
     }
-    if(pi.fdn>0){
+    if(pi.FaceDescriptorVec.size()>0){
         size_t totsz=0;
-        for(int i=0;i<pi.fdn;i++){
-            FPV[i] = pi.FaceData[i];
+        for(size_t i=0;i<pi.FaceDescriptorVec.size();i++){
+            FPV[i] = pi.FaceDescriptorVec[i];
             FPV[i].offset1=offsetof(LoadPly_FaceAux,data)+totsz;
-            totsz+=pi.FaceData[i].memtypesize();
+            totsz+=pi.FaceDescriptorVec[i].memtypesize();
             if( pf.AddToRead(FPV[i])==-1 ) { pi.status = pf.GetError(); return pi.status; }
         }
         if(totsz > MAX_USER_DATA)
@@ -583,7 +583,7 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
     /* Main Reading Loop */
     /**************************************************************/
     m.Clear();
-    for(int i=0;i<int(pf.elements.size());i++)
+    for(size_t i=0;i<pf.elements.size();i++)
     {
         int n = pf.ElemNumber(i);
 
@@ -695,8 +695,8 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
                     (*vi).R() = va.radius;
 
 
-                for(int k=0;k<pi.vdn;k++)
-                    memcpy((char *)(&*vi) + pi.VertexData[k].offset1,
+                for(size_t k=0;k<pi.VertDescriptorVec.size();k++)
+                    memcpy((char *)(&*vi) + pi.VertDescriptorVec[k].offset1,
                            (char *)(&va) + VPV[k].offset1,
                            VPV[k].memtypesize());
                 ++vi;
@@ -820,8 +820,8 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
                 // tag faux vertices of first face
                 if (fa.size>3) fi->SetF(2);
 
-                for(k=0;k<pi.fdn;k++)
-                    memcpy((char *)(&(*fi)) + pi.FaceData[k].offset1,
+                for(size_t k=0;k<pi.FaceDescriptorVec.size();k++)
+                    memcpy((char *)(&(*fi)) + pi.FaceDescriptorVec[k].offset1,
                            (char *)(&fa) + FPV[k].offset1,
                            FPV[k].memtypesize());
 
@@ -861,8 +861,8 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
                     fi->SetF(0);
                     if(qq<(fa.size-4)) fi->SetF(2);
 
-                    for(k=0;k<pi.fdn;k++)
-                        memcpy((char *)(&(*fi)) + pi.FaceData[k].offset1,
+                    for(size_t k=0;k<pi.FaceDescriptorVec.size();k++)
+                        memcpy((char *)(&(*fi)) + pi.FaceDescriptorVec[k].offset1,
                                (char *)(&fa) + FPV[k].offset1, FPV[k].memtypesize());
                     ++fi;
                 }
@@ -911,7 +911,7 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
             //qDebug("Starting Reading of Range Grid");
             if(RangeGridCols==0) // not initialized.
             {
-                for(int co=0;co<int(pf.comments.size());++co)
+                for(size_t co=0;co< pf.comments.size();++co)
                 {
                     std::string num_cols = "num_cols";
                     std::string num_rows = "num_rows";
@@ -974,20 +974,20 @@ static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi )
     m.textures.clear();
     m.normalmaps.clear();
 
-    for(int co=0;co<int(pf.comments.size());++co)
+    for(size_t co=0;co<pf.comments.size();++co)
     {
         std::string TFILE = "TextureFile";
         std::string NFILE = "TextureNormalFile";
         std::string &c = pf.comments[co];
         //		char buf[256];
         std::string bufstr,bufclean;
-        int i,n;
+        int n;
 
         if( TFILE == c.substr(0,TFILE.length()) )
         {
             bufstr = c.substr(TFILE.length()+1);
             n = static_cast<int>(bufstr.length());
-            for(i=0;i<n;i++)
+            for(int i=0;i<n;i++)
                 if( bufstr[i]!=' ' && bufstr[i]!='\t' && bufstr[i]>32 && bufstr[i]<125 )	bufclean.push_back(bufstr[i]);
 
             char buf2[255];
@@ -1036,8 +1036,7 @@ int LoadCamera(const char * filename)
 
 
     bool found = true;
-    int i;
-    for(i=0;i<23;++i)
+    for(int i=0;i<23;++i)
     {
         if( pf.AddToRead(CameraDesc(i))==-1 )
         {
@@ -1049,7 +1048,7 @@ int LoadCamera(const char * filename)
     if(!found)
         return this->pi.status;
 
-    for(i=0;i<int(pf.elements.size());i++)
+    for(size_t i=0;i<pf.elements.size();i++)
     {
         int n = pf.ElemNumber(i);
 
diff --git a/wrap/io_trimesh/io_ply.h b/wrap/io_trimesh/io_ply.h
index 33db9d4c..08b75aad 100644
--- a/wrap/io_trimesh/io_ply.h
+++ b/wrap/io_trimesh/io_ply.h
@@ -52,6 +52,8 @@ namespace vcg {
 namespace tri {
 namespace io {
 
+
+
   
 /** Additional data needed or useful for parsing a ply mesh.
 This class can be passed to the ImporterPLY::Open() function for 
@@ -63,14 +65,35 @@ class PlyInfo
 {
 public:
   typedef ::vcg::ply::PropDescriptor PropDescriptor ;
-
+  
+  void AddPerVertexFloatAttribute(const std::string &attrName, std::string propName="")
+  {
+    static const char *vertStr="vertex";
+    if(propName.empty()) propName=attrName;
+    VertDescriptorVec.push_back(PropDescriptor());
+    VertAttrNameVec.push_back(attrName);
+    VertDescriptorVec.back().elemname=vertStr;
+    VertDescriptorVec.back().propname=propName.c_str();
+    VertDescriptorVec.back().stotype1 = vcg::ply::T_FLOAT;
+    VertDescriptorVec.back().memtype1 = vcg::ply::T_FLOAT;
+  }
+  void AddPerFaceFloatAttribute(const std::string &attrName, std::string propName="")
+  {
+    static const char *faceStr="face";
+    if(propName.empty()) propName=attrName;
+    FaceDescriptorVec.push_back(PropDescriptor());
+    FaceAttrNameVec.push_back(attrName);
+    FaceDescriptorVec.back().elemname=faceStr;
+    FaceDescriptorVec.back().propname=propName.c_str();
+    FaceDescriptorVec.back().stotype1 = vcg::ply::T_FLOAT;
+    FaceDescriptorVec.back().memtype1 = vcg::ply::T_FLOAT;
+  }
+  
   PlyInfo()
   {
     status=0;
     mask=0;
-    cb=0;
-    vdn=fdn=0;
-    VertexData=FaceData=0;
+    cb=0;    
   }
   /// Store the error codes enconutered when parsing a ply
   int status;
@@ -81,15 +104,16 @@ public:
   // it returns the current position, and formats a string with a description of what th efunction is doing (loading vertexes, faces...)
   CallBackPos *cb;
 
-  /// the number of per-vertex descriptor (usually 0)
-  int vdn;
   /// The additional vertex descriptor that a user can specify to load additional per-vertex non-standard data stored in a ply
-  PropDescriptor *VertexData;
-  /// the number of per-face descriptor (usually 0)
-  int fdn;
+  std::vector<PropDescriptor> VertDescriptorVec;
+  /// AttributeName is an array, externally allocated, containing the names of the attributes to be saved (loaded). 
+  /// We assume that AttributeName[], if not empty, is exactly of the same size of VertexdData[]
+  /// If AttributeName[i] is not empty we use it to retrieve/store the info instead of the offsetted space in the current vertex
+  std::vector<std::string> VertAttrNameVec; 
   
   /// The additional vertex descriptor that a user can specify to load additional per-face non-standard data stored in a ply
-  PropDescriptor *FaceData;
+  std::vector<PropDescriptor> FaceDescriptorVec;
+  std::vector<std::string> FaceAttrNameVec; 
 
   /// a string containing the current ply header. Useful for showing it to the user.
   std::string header;