/****************************************************************************
* VCGLib                                                            o o     *
* Visual and Computer Graphics Library                            o     o   *
*                                                                _   O  _   *
* Copyright(C) 2004-2016                                           \/)\/    *
* 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.                                                         *
*                                                                           *
****************************************************************************/
#ifndef __VCGLIB_IOTRIMESH_IO_PLY
#define __VCGLIB_IOTRIMESH_IO_PLY

/**
@name Ply I/O
It contains the definition of the accessory class PlyInfo
It is directly included by the importer and exporter ply classes
*/
//@{

#include "vcg/complex/allocate.h"
#include "vcg/complex/base.h"
#include "vcg/space/point3.h"
#include "wrap/callback.h"
#include "wrap/ply/plylib.h"

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
- retrieving additional per-vertex per-face data
- specifying a callback for long ply parsing
- knowing what data is  contained in a ply file
*/
class PlyInfo
{
public:
	typedef ::vcg::ply::PropDescriptor PropDescriptor ;
    typedef int PlyElemType;
    const static PlyElemType PlyElemVertex = 0;
    const static PlyElemType PlyElemFace = 1;
    
  /// Store the error codes enconutered when parsing a ply
  int status=0;
  /// It returns a bit mask describing the field present in the ply file
  int mask=0;

  /// a Simple callback that can be used for long ply parsing.
  // it returns the current position, and formats a string with a description of what th efunction is doing (loading vertexes, faces...)
  CallBackPos *cb=0;

  /// The additional vertex descriptor that a user can specify to load additional per-vertex non-standard data stored in a ply
  std::vector<PropDescriptor> VertDescriptorVec;
  
  /// VertAttrNameVec is a vector containing the names of the attributes to be saved (loaded).
  /// We assume that VertAttrNameVec, if not empty, is exactly of the same size of VertDescriptorVec
  /// If VertAttrNameVec[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;

  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;

enum Error
{
	// Funzioni superiori
	E_NO_VERTEX       = ply::E_MAXPLYERRORS+1,       // 15
	E_NO_FACE         = ply::E_MAXPLYERRORS+2,       // 16
	E_SHORTFILE       = ply::E_MAXPLYERRORS+3,       // 17
	E_NO_3VERTINFACE  = ply::E_MAXPLYERRORS+4,       // 18
	E_BAD_VERT_INDEX  = ply::E_MAXPLYERRORS+5,       // 19
	E_NO_6TCOORD      = ply::E_MAXPLYERRORS+6,		 // 20
	E_DIFFER_COLORS   = ply::E_MAXPLYERRORS+7,	     // 21
	E_BAD_VERT_INDEX_EDGE  = ply::E_MAXPLYERRORS+8,  // 22
	E_MAXPLYINFOERRORS= ply::E_MAXPLYERRORS+9        // 23
};
  
  /**
	 * @brief addPerElemScalarAttribute
	 * @param elemType  Vertex or Face
	 * @param propertyType the type of the property
	 * @param attrName the name of the attribute (both in the ply file and in the mesh)
	 * @param propName, optional only in case we want to load a certain ply property in an attribute with a different name
	 * 
	 * This function is used to specify additional per-vertex or per-face data 
	 * that is stored in the ply file and that should loaded or saved using attributes
	 * 
	 */ 
  void addPerElemScalarAttribute(PlyElemType elemType, vcg::ply::PlyTypes propertyType, const std::string& attrName, std::string propName="")
  {
      if(propName=="")
          propName=attrName;
      
      PropDescriptor p;
      p.propname=propName;
      p.islist = false;
      p.stotype1 = propertyType;
      p.memtype1 = propertyType;
      
      if (elemType == PlyElemVertex){
          p.elemname="vertex";
          VertDescriptorVec.push_back(p);
          VertAttrNameVec.resize(VertDescriptorVec.size());
          VertAttrNameVec.back() = attrName;          
      }
      else if (elemType == PlyElemFace){
          p.elemname="face";
          FaceDescriptorVec.push_back(p);
          FaceAttrNameVec.resize(FaceDescriptorVec.size());
          FaceAttrNameVec.back() = attrName;
      }
  }
  
  void AddPerElemFloatAttribute(PlyElemType elemType, const std::string& attrName, std::string propName="")
  {
      addPerElemScalarAttribute(elemType, vcg::ply::T_FLOAT, attrName, propName);
  }
  
  void AddPerElemDoubleAttribute(PlyElemType elemType, const std::string& attrName, std::string propName="")
  {
      addPerElemScalarAttribute(elemType, vcg::ply::T_DOUBLE, attrName, propName);
  }
  
  void addPerVertexScalarAttribute(const std::string& attrName, vcg::ply::PlyTypes attrType, std::string propName="")
  {
      addPerElemScalarAttribute(PlyInfo::PlyElemVertex, attrType, attrName,propName);
  }
  
  void AddPerVertexFloatAttribute(const std::string& attrName, std::string propName="")
  {
      AddPerElemFloatAttribute(PlyInfo::PlyElemVertex,attrName,propName);
  }
  
  void addPerFaceScalarAttribute(const std::string& attrName,  vcg::ply::PlyTypes attrType, std::string propName="")
  {
      addPerElemScalarAttribute(PlyInfo::PlyElemFace,attrType, attrName,propName);
  }
  
  void AddPerFaceFloatAttribute(const std::string& attrName, std::string propName="")
  {
      AddPerElemFloatAttribute(PlyInfo::PlyElemFace,attrName,propName);
  }
  
  void addPerElemPointAttribute(int elemType, vcg::ply::PlyTypes propertyType, const std::string& attrName, std::string propName="")
  {
      if(propName=="")
          propName=attrName;
      
      PropDescriptor p;
      p.propname=propName;
      p.stotype1 = propertyType;
      p.memtype1 = propertyType;
      p.islist = true;
      p.memtype2 = vcg::ply::PlyTypes::T_UCHAR;
      p.stotype2 = vcg::ply::PlyTypes::T_UCHAR;
      
      if (elemType == 0){ //vertex
          VertAttrNameVec.push_back(attrName);
          p.elemname="vertex";
          VertDescriptorVec.push_back(p);
      }
      else if (elemType == 1){ //face
          FaceAttrNameVec.push_back(attrName);
          p.elemname="face";
          FaceDescriptorVec.push_back(p);
      }
  }
  
  void addPerVertexPoint3mAttribute(const std::string& attrName, vcg::ply::PlyTypes attrType, std::string propName="")
  {
      addPerElemPointAttribute(PlyInfo::PlyElemVertex,attrType, attrName,propName);
  }
  
  void addPerVertexPoint3fAttribute(const std::string& attrName, std::string propName="")
  {
      addPerElemPointAttribute(PlyInfo::PlyElemVertex,vcg::ply::PlyTypes::T_FLOAT, attrName,propName);
  }
  
  void addPerVertexPoint3dAttribute(const std::string& attrName, std::string propName="")
  {
      addPerElemPointAttribute(PlyInfo::PlyElemVertex,vcg::ply::PlyTypes::T_DOUBLE, attrName,propName);
  }
  
  void addPerFacePoint3mAttribute(const std::string& attrName, vcg::ply::PlyTypes attrType, std::string propName="")
  {
      addPerElemPointAttribute(PlyInfo::PlyElemFace,attrType, attrName,propName);
  }
  
  void addPerFacePoint3fAttribute(const std::string& attrName, std::string propName="")
  {
      addPerElemPointAttribute(PlyInfo::PlyElemFace,vcg::ply::PlyTypes::T_FLOAT, attrName,propName);
  }
  
  void addPerFacePoint3dAttribute(const std::string& attrName, std::string propName="")
  {
      addPerElemPointAttribute(PlyInfo::PlyElemFace,vcg::ply::PlyTypes::T_DOUBLE, attrName,propName);
  }
  
  /* Note that saving a per vertex point3 attribute is a mess.
   * Actually it requires to allocate 3 float attribute and save them. And they are never deallocated... */
  template<class MeshType>
  void AddPerVertexPoint3fAttribute(MeshType &m, const std::string& attrName, std::string propName="")
  {
      if(propName=="")
          propName=attrName;
      
      const char *attrxyz[3] = {
          strdup((std::string(attrName)+std::string("_x")).c_str()),
          strdup((std::string(attrName)+std::string("_y")).c_str()),
          strdup((std::string(attrName)+std::string("_z")).c_str()),
      };
      typename MeshType::template PerVertexAttributeHandle <vcg::Point3f>
          ht = vcg::tri::Allocator<MeshType>:: template GetPerVertexAttribute <vcg::Point3f> (m,attrName);
      
      typename MeshType::template PerVertexAttributeHandle <float> htt[3];
      
      for(int i=0;i<3;++i)
      {
          htt[i] = vcg::tri::Allocator<MeshType>:: template GetPerVertexAttribute<float> (m,std::string(attrxyz[i]));
          //      ForEachVertex (m, [&](typename MeshType::VertexType &v) {
          //        htt[i][v] = ht[v][i];
          //      });
          for(auto vi=m.vert.begin();vi!=m.vert.end();++vi)
              if(!vi->IsD())
                  htt[i][vi] = ht[vi][i];
          AddPerVertexFloatAttribute(attrxyz[i]);
      }
  }
  
}; // end PlyInfo class

// This class holds the vectors of handles to the attributes of a given mesh type
// it is intialized with a PlyInfo object and a mesh and try to retrieve and initialize
// a set of handles for all the attributes that we want to load/save into ply elements
// It is used internally by the importer and exporter ply classes
// Note: we have two sets of handles, const and not const ones to handle the fact
// that for loading we need non const handles while for saving we need const handles
// (saved meshes are const) 

template <class MeshType> class PlyAttributeHelper
{    
   public:
    std::vector<typename MeshType:: template ConstPerVertexAttributeHandle<float > >        tchfv;
    std::vector<typename MeshType:: template ConstPerVertexAttributeHandle<double> >        tchdv;
    std::vector<typename MeshType:: template ConstPerVertexAttributeHandle<int   > >        tchiv;
    std::vector<typename MeshType:: template ConstPerVertexAttributeHandle<short > >        tchsv;
    std::vector<typename MeshType:: template ConstPerVertexAttributeHandle<char  > >        tchcv;
    std::vector<typename MeshType:: template ConstPerVertexAttributeHandle<unsigned char> > tchuv;
    std::vector<typename MeshType:: template ConstPerVertexAttributeHandle<vcg::Point3f> >  tchp3fv;
    std::vector<typename MeshType:: template ConstPerVertexAttributeHandle<vcg::Point3d> >  tchp3dv;
    
    std::vector<typename MeshType:: template ConstPerFaceAttributeHandle<float > >          tchff;
    std::vector<typename MeshType:: template ConstPerFaceAttributeHandle<double> >          tchdf;
    std::vector<typename MeshType:: template ConstPerFaceAttributeHandle<int   > >          tchif;
    std::vector<typename MeshType:: template ConstPerFaceAttributeHandle<short > >          tchsf;
    std::vector<typename MeshType:: template ConstPerFaceAttributeHandle<char  > >          tchcf;
    std::vector<typename MeshType:: template ConstPerFaceAttributeHandle<unsigned char> >   tchuf;
    std::vector<typename MeshType:: template ConstPerFaceAttributeHandle<vcg::Point3f> >    tchp3ff;
    std::vector<typename MeshType:: template ConstPerFaceAttributeHandle<vcg::Point3d> >    tchp3df;
    
    std::vector<typename MeshType:: template      PerVertexAttributeHandle<float > >        thfv;
    std::vector<typename MeshType:: template      PerVertexAttributeHandle<double> >        thdv;
    std::vector<typename MeshType:: template      PerVertexAttributeHandle<int   > >        thiv;
    std::vector<typename MeshType:: template      PerVertexAttributeHandle<short > >        thsv;
    std::vector<typename MeshType:: template      PerVertexAttributeHandle<char  > >        thcv;
    std::vector<typename MeshType:: template      PerVertexAttributeHandle<unsigned char> > thuv;
    std::vector<typename MeshType:: template      PerVertexAttributeHandle<vcg::Point3f> >  thp3fv;
    std::vector<typename MeshType:: template      PerVertexAttributeHandle<vcg::Point3d> >  thp3dv;
    
    std::vector<typename MeshType:: template      PerFaceAttributeHandle<float > >          thff;
    std::vector<typename MeshType:: template      PerFaceAttributeHandle<double> >          thdf;
    std::vector<typename MeshType:: template      PerFaceAttributeHandle<int   > >          thif;
    std::vector<typename MeshType:: template      PerFaceAttributeHandle<short > >          thsf;
    std::vector<typename MeshType:: template      PerFaceAttributeHandle<char  > >          thcf;
    std::vector<typename MeshType:: template      PerFaceAttributeHandle<unsigned char> >   thuf;
    std::vector<typename MeshType:: template      PerFaceAttributeHandle<vcg::Point3f> >    thp3ff;
    std::vector<typename MeshType:: template      PerFaceAttributeHandle<vcg::Point3d> >    thp3df;
   
    /* The constructor take care of initializing the handles to the attributes of a mesh
     * given a PlyInfo object and a mesh
     * Note that there are two version of the constructor one for const handler (used by save) and one for non-const handlers (used by load)
     */
    
    PlyAttributeHelper(const PlyInfo &pi, const MeshType &m)
    {
        tchfv.resize(pi.VertDescriptorVec.size());
        tchdv.resize(pi.VertDescriptorVec.size());
        tchiv.resize(pi.VertDescriptorVec.size());
        tchsv.resize(pi.VertDescriptorVec.size());
        tchcv.resize(pi.VertDescriptorVec.size());
        tchuv.resize(pi.VertDescriptorVec.size());
        tchp3fv.resize(pi.VertDescriptorVec.size());
        tchp3dv.resize(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]));
                if (!pi.VertDescriptorVec[i].islist){
                    switch (pi.VertDescriptorVec[i].stotype1)
                    {
                    case ply::T_FLOAT  : tchfv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<float>(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_DOUBLE : tchdv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<double>(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_INT    : tchiv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<int   >(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_SHORT  : tchsv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<short >(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_CHAR   : tchcv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<char>(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_UCHAR  : tchuv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<unsigned char>(m,pi.VertAttrNameVec[i]); break;
                    default : assert(0);
                    }
                }
                else {
                    switch (pi.VertDescriptorVec[i].stotype1)
                    {
                    case ply::T_FLOAT  : tchp3fv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<vcg::Point3f>(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_DOUBLE : tchp3dv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<vcg::Point3d>(m,pi.VertAttrNameVec[i]); break;
                    default : assert(0);
                    }
                }
            }
        }
        
        
        tchff.resize(pi.FaceDescriptorVec.size());
        tchdf.resize(pi.FaceDescriptorVec.size());
        tchif.resize(pi.FaceDescriptorVec.size());
        tchsf.resize(pi.FaceDescriptorVec.size());
        tchcf.resize(pi.FaceDescriptorVec.size());
        tchuf.resize(pi.FaceDescriptorVec.size());
        tchp3ff.resize(pi.FaceDescriptorVec.size());
        tchp3df.resize(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]));
                if (!pi.FaceDescriptorVec[i].islist) {
                    switch (pi.FaceDescriptorVec[i].stotype1)
                    {
                    case ply::T_FLOAT  : tchff[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<float>(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_DOUBLE : tchdf[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<double>(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_INT    : tchif[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<int   >(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_SHORT  : tchsf[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<short >(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_CHAR   : tchcf[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<char>(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_UCHAR  : tchuf[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<unsigned char>(m,pi.FaceAttrNameVec[i]); break;
                    default : assert(0);
                    }
                }
                else {
                    switch (pi.FaceDescriptorVec[i].stotype1)
                    {
                    case ply::T_FLOAT  : tchp3ff[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<vcg::Point3f>(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_DOUBLE : tchp3df[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<vcg::Point3d>(m,pi.FaceAttrNameVec[i]); break;
                    default : assert(0);
                    }
                }
            }
        }
    }
        
    // Second version of the constructor
    // This one is used when we want to load attributes from a ply file and we need non const handles to the attributes
    PlyAttributeHelper(const PlyInfo &pi, MeshType &m)
    {
        thfv.resize(pi.VertDescriptorVec.size());
        thdv.resize(pi.VertDescriptorVec.size());
        thiv.resize(pi.VertDescriptorVec.size());
        thsv.resize(pi.VertDescriptorVec.size());
        thcv.resize(pi.VertDescriptorVec.size());
        thuv.resize(pi.VertDescriptorVec.size());
        thp3fv.resize(pi.VertDescriptorVec.size());
        thp3dv.resize(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]));
                if (!pi.VertDescriptorVec[i].islist){
                    switch (pi.VertDescriptorVec[i].stotype1)
                    {
                    case ply::T_FLOAT  : thfv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<float>(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_DOUBLE : thdv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<double>(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_INT    : thiv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<int   >(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_SHORT  : thsv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<short >(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_CHAR   : thcv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<char>(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_UCHAR  : thuv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<unsigned char>(m,pi.VertAttrNameVec[i]); break;
                    default : assert(0);
                    }
                }
                else {
                    switch (pi.VertDescriptorVec[i].stotype1)
                    {
                    case ply::T_FLOAT  : thp3fv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<vcg::Point3f>(m,pi.VertAttrNameVec[i]); break;
                    case ply::T_DOUBLE : thp3dv[i] = vcg::tri::Allocator<MeshType>::template FindPerVertexAttribute<vcg::Point3d>(m,pi.VertAttrNameVec[i]); break;
                    default : assert(0);
                    }
                }
            }
        }
        
        
        thff.resize(pi.FaceDescriptorVec.size());
        thdf.resize(pi.FaceDescriptorVec.size());
        thif.resize(pi.FaceDescriptorVec.size());
        thsf.resize(pi.FaceDescriptorVec.size());
        thcf.resize(pi.FaceDescriptorVec.size());
        thuf.resize(pi.FaceDescriptorVec.size());
        thp3ff.resize(pi.FaceDescriptorVec.size());
        thp3df.resize(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]));
                if (!pi.FaceDescriptorVec[i].islist) {
                    switch (pi.FaceDescriptorVec[i].stotype1)
                    {
                    case ply::T_FLOAT  : thff[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<float>(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_DOUBLE : thdf[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<double>(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_INT    : thif[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<int   >(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_SHORT  : thsf[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<short >(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_CHAR   : thcf[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<char>(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_UCHAR  : thuf[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<unsigned char>(m,pi.FaceAttrNameVec[i]); break;
                    default : assert(0);
                    }
                }
                else {
                    switch (pi.FaceDescriptorVec[i].stotype1)
                    {
                    case ply::T_FLOAT  : thp3ff[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<vcg::Point3f>(m,pi.FaceAttrNameVec[i]); break;
                    case ply::T_DOUBLE : thp3df[i] = vcg::tri::Allocator<MeshType>::template FindPerFaceAttribute<vcg::Point3d>(m,pi.FaceAttrNameVec[i]); break;
                    default : assert(0);
                    }
                }
            }
        }
    }

}; // end PlyAttributeHelper class


} // end namespace tri
} // end namespace io
} // end namespace vcg
#endif