diff --git a/wrap/io_tetramesh/export_ply.h b/wrap/io_tetramesh/export_ply.h new file mode 100644 index 00000000..8ee81de3 --- /dev/null +++ b/wrap/io_tetramesh/export_ply.h @@ -0,0 +1,582 @@ +/**************************************************************************** +* VCGLib o o * +* Visual and Computer Graphics Library o o * +* _ O _ * +* Copyright(C) 2004 \/)\/ * +* Visual Computing Lab /\/| * +* ISTI - Italian National Research Council | * +* \ * +* All rights reserved. * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * +* for more details. * +* * +****************************************************************************/ +/**************************************************************************** + History + +$Log: not supported by cvs2svn $ + +****************************************************************************/ + +/** +@name Load and Save in Ply format +*/ +//@{ + +#ifndef __VCGLIB_TETRAEXPORT_PLY +#define __VCGLIB_TETRAEXPORT_PLY + +#include +#include + +#include + +namespace vcg { +namespace tetra { +namespace io { + + +template +class ExporterPLY +{ + // Si occupa di convertire da un tipo all'altro. +// usata nella saveply per matchare i tipi tra stotype e memtype. +// Ad es se in memoria c'e' un int e voglio salvare un float +// src sara in effetti un puntatore a int il cui valore deve +// essere convertito al tipo di ritorno desiderato (stotype) + +template +static void PlyConv(int mem_type, void *src, StoType &dest) +{ + switch (mem_type){ + case ply::T_FLOAT : dest = (StoType) (* ((float *) src)); break; + case ply::T_DOUBLE: dest = (StoType) (* ((double *) src)); break; + case ply::T_INT : dest = (StoType) (* ((int *) src)); break; + case ply::T_SHORT : dest = (StoType) (* ((short *) src)); break; + case ply::T_CHAR : dest = (StoType) (* ((char *) src)); break; + case ply::T_UCHAR : dest = (StoType) (* ((unsigned char *)src)); break; + default : assert(0); + } +} + +public: +typedef ::vcg::ply::PropDescriptor PropDescriptor ; +typedef typename SaveMeshType::VertexPointer VertexPointer; +typedef typename SaveMeshType::ScalarType ScalarType; +typedef typename SaveMeshType::VertexType VertexType; +typedef typename SaveMeshType::TetraType TetraType; +typedef typename SaveMeshType::TetraPointer TetraPointer; +typedef typename SaveMeshType::VertexIterator VertexIterator; +typedef typename SaveMeshType::TetraIterator TetraIterator; + +static bool Save(SaveMeshType &m, const char * filename, bool binary=true) +{ + PlyInfo pi; + return Save(m,filename,binary,pi); +} + +static bool Save(SaveMeshType &m, const char * filename, int savemask ) +{ + PlyInfo pi; + pi.mask=savemask; + return Save(m,filename,true,pi); +} + +static bool Save(SaveMeshType &m, const char * filename, bool binary, PlyInfo &pi ) // V1.0 +{ + FILE * fpout; + int i; + + const char * hbin = "binary_little_endian"; + const char * hasc = "ascii"; + const char * h; + + bool multit = false; + + if(binary) h=hbin; + else h=hasc; + + fpout = fopen(filename,"wb"); + if(fpout==NULL) { + pi.status=::vcg::ply::E_CANTOPEN; + return false; + } + fprintf(fpout, + "ply\n" + "format %s 1.0\n" + "comment VCGLIB generated\n" + ,h + ); + + //if( pi.mask & ply::PLYMask::PM_WEDGTEXCOORD ) + //{ + // //const char * TFILE = "TextureFile"; + + // //for(i=0;i1 && (HasPerWedgeTexture() || HasPerVertexTexture())) multit = true; + //} + + //if( (pi.mask & PLYMask::PM_CAMERA) && camera.IsValid() ) + /*{ + fprintf(fpout, + "element camera 1\n" + "property float view_px\n" + "property float view_py\n" + "property float view_pz\n" + "property float x_axisx\n" + "property float x_axisy\n" + "property float x_axisz\n" + "property float y_axisx\n" + "property float y_axisy\n" + "property float y_axisz\n" + "property float z_axisx\n" + "property float z_axisy\n" + "property float z_axisz\n" + "property float focal\n" + "property float scalex\n" + "property float scaley\n" + "property float centerx\n" + "property float centery\n" + "property int viewportx\n" + "property int viewporty\n" + "property float k1\n" + "property float k2\n" + "property float k3\n" + "property float k4\n" + ); + }*/ + + fprintf(fpout, + "element vertex %d\n" + "property float x\n" + "property float y\n" + "property float z\n" + ,m.vn + ); + + + if( pi.mask & ply::PLYMask::PM_VERTFLAGS ) + { + fprintf(fpout, + "property int flags\n" + ); + } + + if( m.HasPerVertexColor() && (pi.mask & ply::PLYMask::PM_VERTCOLOR) ) + { + fprintf(fpout, + "property uchar red\n" + "property uchar green\n" + "property uchar blue\n" + "property uchar alpha\n" + ); + } + + if( m.HasPerVertexQuality() && (pi.mask & ply::PLYMask::PM_VERTQUALITY) ) + { + fprintf(fpout, + "property float quality\n" + ); + } + + for(i=0;i FlagV; + VertexPointer vp; + VertexIterator vi; + for(j=0,vi=m.vert.begin();vi!=m.vert.end();++vi) + { + vp=&(*vi); + FlagV.push_back(vp->UberFlags()); // Salva in ogni caso flag del vertice + if( ! vp->IsD() ) + { + if(binary) + { + float t; + + t = float(vp->UberP()[0]); fwrite(&t,sizeof(float),1,fpout); + t = float(vp->UberP()[1]); fwrite(&t,sizeof(float),1,fpout); + t = float(vp->UberP()[2]); fwrite(&t,sizeof(float),1,fpout); + + if( pi.mask & ply::PLYMask::PM_VERTFLAGS ) + fwrite(&(vp->UberFlags()),sizeof(int),1,fpout); + + if( m.HasPerVertexColor() && (pi.mask & ply::PLYMask::PM_VERTCOLOR) ) + fwrite(&( vp->C() ),sizeof(char),4,fpout); + + if( m.HasPerVertexQuality() && (pi.mask & ply::PLYMask::PM_VERTQUALITY) ) + fwrite(&( vp->Q() ),sizeof(float),1,fpout); + + + for(i=0;iP()[0],vp->P()[1],vp->P()[2]); + + if( pi.mask & ply::PLYMask::PM_VERTFLAGS ) + fprintf(fpout,"%d ",vp->UberFlags()); + + if( m.HasPerVertexColor() && (pi.mask & ply::PLYMask::PM_VERTCOLOR) ) + fprintf(fpout,"%d %d %d %d ",vp->C()[0],vp->C()[1],vp->C()[2],vp->C()[3] ); + + if( m.HasPerVertexQuality() && (pi.mask & ply::PLYMask::PM_VERTQUALITY) ) + fprintf(fpout,"%g ",vp->Q()); + + for(i=0;iUberFlags()=j; // Trucco! Nascondi nei flags l'indice del vertice non deletato! + j++; + } + } + assert(j==m.vn); + + char c = 4; + unsigned char b9 = 9; + unsigned char b6 = 6; + TetraPointer fp; + int vv[4]; + TetraIterator fi; + int fcnt=0; + for(j=0,fi=m.tetra.begin();fi!=m.tetra.end();++fi) + { + fp=&(*fi); + if( ! fp->IsD() ) + { fcnt++; + if(binary) + { + vv[0]=fp->cV(0)->UberFlags(); + vv[1]=fp->cV(1)->UberFlags(); + vv[2]=fp->cV(2)->UberFlags(); + vv[3]=fp->cV(2)->UberFlags(); + fwrite(&c,1,1,fpout); + fwrite(vv,sizeof(int),4,fpout); + + if( pi.mask & ply::PLYMask::PM_TETRAFLAGS ) + fwrite(&(fp->Flags()),sizeof(int),1,fpout); + + if( m.HasPerVertexTexture() && (pi.mask & ply::PLYMask::PM_VERTTEXCOORD) ) + { + fwrite(&b6,sizeof(char),1,fpout); + float t[6]; + for(int k=0;k<4;++k) + { + t[k*2+0] = fp->V(k)->T().u(); + t[k*2+1] = fp->V(k)->T().v(); + } + fwrite(t,sizeof(float),6,fpout); + } + //else if( m.HasPerWedgeTexture() && (pi.mask & ply::PLYMask::PM_WEDGTEXCOORD) ) + //{ + // fwrite(&b6,sizeof(char),1,fpout); + // float t[6]; + // for(int k=0;k<3;++k) + // { + // t[k*2+0] = fp->WT(k).u(); + // t[k*2+1] = fp->WT(k).v(); + // } + // fwrite(t,sizeof(float),6,fpout); + //} + + /* if(multit) + { + int t = fp->WT(0).n(); + fwrite(&t,sizeof(int),1,fpout); + } + + if( m.HasPerTetraColor() && (pi.mask & ply::PLYMask::PM_TETRACOLOR) ) + fwrite(&( fp->C() ),sizeof(char),4,fpout);*/ + + + //if( m.HasPerWedgeColor() && (pi.mask & ply::PLYMask::PM_WEDGCOLOR) ) + //{ + // fwrite(&b9,sizeof(char),1,fpout); + // float t[3]; + // for(int z=0;z<3;++z) + // { + // t[0] = float(fp->WC(z)[0])/255; + // t[1] = float(fp->WC(z)[1])/255; + // t[2] = float(fp->WC(z)[2])/255; + // fwrite( t,sizeof(float),3,fpout); + // } + //} + + if( TetraType::HasTetraQuality() && (pi.mask & ply::PLYMask::PM_TETRAQUALITY) ) + fwrite( &(fp->Q()),sizeof(float),1,fpout); + + + for(i=0;icV(0)->UberFlags(), fp->cV(1)->UberFlags(), fp->cV(2)->UberFlags() ); + + if( pi.mask & ply::PLYMask::PM_TETRAFLAGS ) + fprintf(fpout,"%d ",fp->Flags()); + + if( m.HasPerVertexTexture() && (pi.mask & ply::PLYMask::PM_VERTTEXCOORD) ) + { + fprintf(fpout,"6 "); + for(int k=0;k<4;++k) + fprintf(fpout,"%g %g " + ,fp->V(k)->T().u() + ,fp->V(k)->T().v() + ); + } + //else if( m.HasPerWedgeTexture() && (pi.mask & ply::PLYMask::PM_WEDGTEXCOORD) ) + //{ + // fprintf(fpout,"6 "); + // for(int k=0;k<3;++k) + // fprintf(fpout,"%g %g " + // ,fp->WT(k).u() + // ,fp->WT(k).v() + // ); + //} + + /* if(multit) + { + fprintf(fpout,"%d ",fp->WT(0).n()); + }*/ + + if( TetraType::HasTetraColor() && (pi.mask & ply::PLYMask::PM_TETRACOLOR) ) + { + float t[3]; + t[0] = float(fp->C()[0])/255; + t[1] = float(fp->C()[1])/255; + t[2] = float(fp->C()[2])/255; + fprintf(fpout,"9 "); + fprintf(fpout,"%g %g %g ",t[0],t[1],t[2]); + fprintf(fpout,"%g %g %g ",t[0],t[1],t[2]); + fprintf(fpout,"%g %g %g ",t[0],t[1],t[2]); + } + //else if( m.HasPerWedgeColor() && (pi.mask & ply::PLYMask::PM_WEDGCOLOR) ) + //{ + // fprintf(fpout,"9 "); + // for(int z=0;z<3;++z) + // fprintf(fpout,"%g %g %g " + // ,double(fp->WC(z)[0])/255 + // ,double(fp->WC(z)[1])/255 + // ,double(fp->WC(z)[2])/255 + // ); + //} + + if( m.HasPerTetraQuality() && (pi.mask & ply::PLYMask::PM_TETRAQUALITY) ) + fprintf(fpout,"%g ",fp->Q()); + + for(i=0;i + +namespace vcg { +namespace tetra { +namespace io { + +template +class ExporterTS{ + + typedef typename MESHTYPE::VertexPointer VertexPointer; + typedef typename MESHTYPE::VertexType VertexType; + typedef typename MESHTYPE::TetraType FaceType; + typedef typename MESHTYPE::VertexIterator VertexIterator; + typedef typename MESHTYPE::FaceIterator FaceIterator; + typedef MESHTYPE::ScalarType ScalarType; + typedef Point3 Point3x; + + +int Save( MESHTYPE & m, const char * filename ) { + FILE *f; + f = fopen(filename,"w"); + if(f == NULL ) + { + printf( "The file could not be opened\n" ); + return -1; + } + else + { + fprintf(f, "%i", m.vn ); + fprintf(f, "%i", m.tn ); + VertexIterator vi; + for (vi = m.vert.begin(); vi != m.vert.end();++vi) + fprintf(f, "%f %f %f \n", (*vi).P()[0],(*vi).P()[1],(*vi).P()[2] ); + + TetraIterator ti; + fr( ti = m.tetra.begin(); ti != m.tetra.end(); ++ti) + fprintf(f, "%d %d %d %d \n", + (*ti)->V(0)-&*m.tetra.begin(), + (*ti)->V(1)-&*m.tetra.begin(), + (*ti)->V(2)-&*m.tetra.begin(), + (*ti)->V(3)-&*m.tetra.begin()); + } return 0; } };// end class };// end of io };// end of tri };// end of vcg #endif \ No newline at end of file diff --git a/wrap/io_tetramesh/import_ply.h b/wrap/io_tetramesh/import_ply.h new file mode 100644 index 00000000..f5640810 --- /dev/null +++ b/wrap/io_tetramesh/import_ply.h @@ -0,0 +1,776 @@ +/**************************************************************************** +* VCGLib o o * +* Visual and Computer Graphics Library o o * +* _ O _ * +* Copyright(C) 2004 \/)\/ * +* Visual Computing Lab /\/| * +* ISTI - Italian National Research Council | * +* \ * +* All rights reserved. * +* * +* This program is free software; you can redistribute it and/or modify * +* it under the terms of the GNU General Public License as published by * +* the Free Software Foundation; either version 2 of the License, or * +* (at your option) any later version. * +* * +* This program is distributed in the hope that it will be useful, * +* but WITHOUT ANY WARRANTY; without even the implied warranty of * +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * +* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * +* for more details. * +* * +****************************************************************************/ +/**************************************************************************** + History + +$Log: not supported by cvs2svn $ +****************************************************************************/ +#ifndef __VCGLIB_TETRAIMPORTERPLY +#define __VCGLIB_TETRAIMPORTERPLY + +#include +#include +#include +#include +#include + + + +namespace vcg { +namespace tetra { +namespace io { + +template +int PlyType () { return 0;} + +template <> int PlyType () { return ply::T_FLOAT; } +template <> int PlyType () { return ply::T_DOUBLE; } +template <> int PlyType () { return ply::T_INT; } +template <> int PlyType () { return ply::T_SHORT; } +template <> int PlyType () { return ply::T_UCHAR; } + +/** +This class encapsulate a filter for opening ply meshes. +The ply file format is quite extensible... +*/ +template +class ImporterPLY +{ +public: + +typedef ::vcg::ply::PropDescriptor PropDescriptor ; +typedef typename OpenMeshType::VertexPointer VertexPointer; +typedef typename OpenMeshType::ScalarType ScalarType; +typedef typename OpenMeshType::VertexType VertexType; +typedef typename OpenMeshType::TetraType TetraType; +typedef typename OpenMeshType::VertexIterator VertexIterator; +typedef typename OpenMeshType::TetraIterator TetraIterator; + +//template int PlyType () { assert(0); return 0;} + +#define MAX_USER_DATA 256 +// Struttura ausiliaria per la lettura del file ply +struct LoadPly_TetraAux +{ + unsigned char size; + int v[512]; + int flags; + float q; + float tcoord[32]; + unsigned char ntcoord; + int tcoordind; + float colors[32]; + unsigned char ncolors; + + unsigned char r; + unsigned char g; + unsigned char b; + + unsigned char data[MAX_USER_DATA]; +}; + +//struct LoadPly_TristripAux +//{ +// int size; +// int *v; +// unsigned char data[MAX_USER_DATA]; +//}; + +// Struttura ausiliaria per la lettura del file ply +template +struct LoadPly_VertAux +{ + S p[3]; + int flags; + float q; + unsigned char r; + unsigned char g; + unsigned char b; + unsigned char data[MAX_USER_DATA]; +}; + +// Struttura ausiliaria caricamento camera +//struct LoadPly_Camera +//{ +// float view_px; +// float view_py; +// float view_pz; +// float x_axisx; +// float x_axisy; +// float x_axisz; +// float y_axisx; +// float y_axisy; +// float y_axisz; +// float z_axisx; +// float z_axisy; +// float z_axisz; +// float focal; +// float scalex; +// float scaley; +// float centerx; +// float centery; +// int viewportx; +// int viewporty; +// float k1; +// float k2; +// float k3; +// float k4; +//}; + +static const PropDescriptor &VertDesc(int i) +{ + const static PropDescriptor pv[9]={ + {"vertex", "x", ply::T_FLOAT, PlyType(),offsetof(LoadPly_VertAux,p[0]),0,0,0,0,0}, + {"vertex", "y", ply::T_FLOAT, PlyType(),offsetof(LoadPly_VertAux,p[1]),0,0,0,0,0}, + {"vertex", "z", ply::T_FLOAT, PlyType(),offsetof(LoadPly_VertAux,p[2]),0,0,0,0,0}, + {"vertex", "flags", ply::T_INT, ply::T_INT, offsetof(LoadPly_VertAux,flags),0,0,0,0,0}, + {"vertex", "quality", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux,q),0,0,0,0,0}, + {"vertex", "red" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux,r),0,0,0,0,0}, + {"vertex", "green", ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux,g),0,0,0,0,0}, + {"vertex", "blue" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_VertAux,b),0,0,0,0,0}, + {"vertex", "confidence",ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_VertAux,q),0,0,0,0,0}, + }; + return pv[i]; +} + + +static const PropDescriptor &TetraDesc(int i) +{ + const static PropDescriptor qf[10]= + { + {"tetra", "vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_TetraAux,v), 1,0,ply::T_UCHAR,ply::T_UCHAR,offsetof(LoadPly_TetraAux,size) }, + {"tetra", "flags", ply::T_INT, ply::T_INT, offsetof(LoadPly_TetraAux,flags), 0,0,0,0,0}, + {"tetra", "quality", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_TetraAux,q), 0,0,0,0,0}, + {"tetra", "texcoord", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_TetraAux,tcoord), 1,0,ply::T_UCHAR,ply::T_UCHAR,offsetof(LoadPly_TetraAux,ntcoord) }, + {"tetra", "color", ply::T_FLOAT, ply::T_FLOAT, offsetof(LoadPly_TetraAux,colors), 1,0,ply::T_UCHAR,ply::T_UCHAR,offsetof(LoadPly_TetraAux,ncolors) }, + {"tetra", "texnumber", ply::T_INT, ply::T_INT, offsetof(LoadPly_TetraAux,tcoordind), 0,0,0,0,0}, + {"tetra", "red" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_TetraAux,r), 0,0,0,0,0}, + {"tetra", "green", ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_TetraAux,g), 0,0,0,0,0}, + {"tetra", "blue" , ply::T_UCHAR, ply::T_UCHAR, offsetof(LoadPly_TetraAux,b), 0,0,0,0,0}, + {"tetra", "vertex_index", ply::T_INT, ply::T_INT, offsetof(LoadPly_TetraAux,v), 1,0,ply::T_UCHAR,ply::T_CHAR,offsetof(LoadPly_TetraAux,size) }, + }; + return qf[i]; +} +//static const PropDescriptor &TristripDesc(int i) +//{ +// const static PropDescriptor qf[1]= +// { +// {"tristrips","vertex_indices", ply::T_INT, ply::T_INT, offsetof(LoadPly_TristripAux,v), 1,1,ply::T_INT,ply::T_INT,offsetof(LoadPly_TristripAux,size) }, +// }; +// return qf[i]; +//} + + +//static const PropDescriptor &CameraDesc(int i) +//{ +// const static PropDescriptor cad[23] = +// { +// {"camera","view_px",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,view_px),0,0,0,0,0}, +// {"camera","view_py",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,view_py),0,0,0,0,0}, +// {"camera","view_pz",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,view_pz),0,0,0,0,0}, +// {"camera","x_axisx",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,x_axisx),0,0,0,0,0}, +// {"camera","x_axisy",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,x_axisy),0,0,0,0,0}, +// {"camera","x_axisz",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,x_axisz),0,0,0,0,0}, +// {"camera","y_axisx",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,y_axisx),0,0,0,0,0}, +// {"camera","y_axisy",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,y_axisy),0,0,0,0,0}, +// {"camera","y_axisz",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,y_axisz),0,0,0,0,0}, +// {"camera","z_axisx",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,z_axisx),0,0,0,0,0}, +// {"camera","z_axisy",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,z_axisy),0,0,0,0,0}, +// {"camera","z_axisz",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,z_axisz),0,0,0,0,0}, +// {"camera","focal" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,focal ),0,0,0,0,0}, +// {"camera","scalex" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,scalex ),0,0,0,0,0}, +// {"camera","scaley" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,scaley ),0,0,0,0,0}, +// {"camera","centerx",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,centerx),0,0,0,0,0}, +// {"camera","centery",ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,centery),0,0,0,0,0}, +// {"camera","viewportx",ply::T_INT,ply::T_INT ,offsetof(LoadPly_Camera,viewportx),0,0,0,0,0}, +// {"camera","viewporty",ply::T_INT,ply::T_INT ,offsetof(LoadPly_Camera,viewporty),0,0,0,0,0}, +// {"camera","k1" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,k1 ),0,0,0,0,0}, +// {"camera","k2" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,k2 ),0,0,0,0,0}, +// {"camera","k3" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,k3 ),0,0,0,0,0}, +// {"camera","k4" ,ply::T_FLOAT,ply::T_FLOAT,offsetof(LoadPly_Camera,k4 ),0,0,0,0,0} +// }; +// return cad[i]; +//} + + +/// Standard call for reading a mesh +static int Open( OpenMeshType &m, const char * filename, CallBackPos *cb=0) +{ + PlyInfo pi; + pi.cb=cb; + return Open(m, filename, pi); +} + +/// Read a mesh and store in loadmask the loaded field +static int Open( OpenMeshType &m, const char * filename, int & loadmask, CallBackPos *cb =0) +{ + PlyInfo pi; + pi.mask=loadmask; + return Open(m, filename,pi); + loadmask=pi.mask; +} + + +/// read a mesh with all the possible option specified in the PlyInfo obj. +static int Open( OpenMeshType &m, const char * filename, PlyInfo &pi ) +{ + assert(filename!=0); + vector index; + LoadPly_TetraAux fa; +// LoadPly_TristripAux tsa; + LoadPly_VertAux va; + + pi.mask = 0; + bool multit = false; // true if texture has a per face int spec the texture index + + va.flags = 42; + + pi.status = ::vcg::ply::E_NOERROR; + + // init defaults + VertexType tv; + tv.UberFlags() = 0; + if( VertexType::HasQuality() ) tv.Q()=1.0; + if( VertexType::HasColor() ) tv.C()=Color4b(Color4b::White); + + TetraType tf; + tf.UberFlags() = 0; + //if( FaceType::HasFaceQuality() ) tf.Q()=1.0; + //if( FaceType::HasWedgeColor() ) tf.WC(0)=tf.WC(1)=tf.WC(2)=Color4b(Color4b::White); + //if( FaceType::HasFaceColor() ) tf.C()=Color4b(Color4b::White); + // Descrittori delle strutture + + //bool isvflags = false; // Il file contiene i flags + + + // The main descriptor of the ply file + vcg::ply::PlyFile pf; + + // Open the file and parse the header + if( pf.Open(filename,vcg::ply::PlyFile::MODE_READ)==-1 ) + { + pi.status = pf.GetError(); + return -1; + } + pi.header = pf.GetHeader(); + + // Descrittori della camera + { // Check that all the camera properties are present. + /* bool found = true; + for(int i=0;i<23;++i) + { + if( pf.AddToRead(CameraDesc(i))==-1 ) { + found = false; + break; + } + } + if(found) pi.mask |= ply::PLYMask::PM_CAMERA;*/ + } + + // Descrittori dati standard (vertex coord e faces) + if( pf.AddToRead(VertDesc(0))==-1 ) { pi.status = PlyInfo::E_NO_VERTEX; return -1; } + if( pf.AddToRead(VertDesc(1))==-1 ) { pi.status = PlyInfo::E_NO_VERTEX; return -1; } + if( pf.AddToRead(VertDesc(2))==-1 ) { pi.status = PlyInfo::E_NO_VERTEX; return -1; } + if( pf.AddToRead(TetraDesc(0))==-1 ){ pi.status = PlyInfo::E_NO_VERTEX; return -1; } + + +// Se fallisce si prova anche la sintassi di rapidform con index al posto di indices +// if( pf.AddToRead(TetraDesc(9))==-1 ) +// if(pf.AddToRead(TristripDesc(0))==-1) // Se fallisce tutto si prova a vedere se ci sono tristrip alla levoy. +// { pi.status = PlyInfo::E_NO_FACE; return -1; } + + // Descrittori facoltativi dei flags + if( pf.AddToRead(VertDesc(3))!=-1 ) + pi.mask |= ply::PLYMask::PM_VERTFLAGS; + + if( VertexType::HasQuality() ) + { + if( pf.AddToRead(VertDesc(4))!=-1 || + pf.AddToRead(VertDesc(8))!=-1 ) + pi.mask |= ply::PLYMask::PM_VERTQUALITY; + } + + if( VertexType::HasColor() ) + { + if( pf.AddToRead(VertDesc(5))!=-1 ) + { + pf.AddToRead(VertDesc(6)); + pf.AddToRead(VertDesc(7)); + pi.mask |= ply::PLYMask::PM_VERTCOLOR; + } + } + + // se ci sono i flag per vertice ci devono essere anche i flag per faccia + if( pf.AddToRead(TetraDesc(1))!=-1 ) + pi.mask |= ply::PLYMask::PM_TETRAFLAGS; + + if( TetraType::HasTetraQuality()) + { + if( pf.AddToRead(TetraDesc(2))!=-1 ) + pi.mask |= ply::PLYMask::PM_TETRAQUALITY; + } + + if( TetraType::HasTetraColor() ) + { + if( pf.AddToRead(TetraDesc(6))!=-1 ) + { + pf.AddToRead(TetraDesc(7)); + pf.AddToRead(TetraDesc(8)); + pi.mask |= ply::PLYMask::PM_TETRACOLOR; + } + } + + + // if( FaceType::HasWedgeColor() || FaceType::HasFaceColor() || VertexType::HasColor()) + //{ + // if( pf.AddToRead(TetraDesc(4))!=-1 ) + // { + // pi.mask |= ply::PLYMask::PM_WEDGCOLOR; + // } + //} + + // Descrittori definiti dall'utente, + vector VPV(pi.vdn); // property descriptor relative al tipo LoadPly_VertexAux + vector FPV(pi.fdn); // property descriptor relative al tipo LoadPly_FaceAux + if(pi.vdn>0){ + // Compute the total size needed to load additional per vertex data. + size_t totsz=0; + for(int i=0;i,data)+totsz; + totsz+=pi.VertexData[i].memtypesize(); + if( pf.AddToRead(VPV[i])==-1 ) { pi.status = pf.GetError(); return -1; } + } + if(totsz > MAX_USER_DATA) + { + pi.status = vcg::ply::E_BADTYPE; + return -1; + } + } + if(pi.fdn>0){ + size_t totsz=0; + for(int i=0;i MAX_USER_DATA) + { + pi.status = vcg::ply::E_BADTYPE; + return -1; + } + } + + /**************************************************************/ + /* Main Reading Loop */ + /**************************************************************/ + m.Clear(); + for(int i=0;i::AddVertices(m,n); + + for(j=0;j::AddTetra(m,n); + pf.SetCurElement(i); + + for(j=0;j=m.vn ) + { + pi.status = PlyInfo::E_BAD_VERT_INDEX; + return -1; + } + (*fi).V(k) = index[ fa.v[k] ]; + } + + if( pi.mask & ply::PLYMask::PM_TETRAFLAGS ) + { + (*fi).UberFlags() = fa.flags; + } + + if( pi.mask & ply::PLYMask::PM_TETRAQUALITY ) + { + (*fi).Q() = fa.q; + } + + if( pi.mask & ply::PLYMask::PM_TETRACOLOR ) + { + (*fi).C()[0] = fa.r; + (*fi).C()[1] = fa.g; + (*fi).C()[2] = fa.b; + (*fi).C()[3] = 255; + } + + if(TetraType::HasTetraColor()){ + { + (*fi).C()[0] = (unsigned char)((fa.colors[0*3+0]*255+fa.colors[1*3+0]*255+fa.colors[2*3+0]*255)/3.0f); + (*fi).C()[1] = (unsigned char)((fa.colors[0*3+1]*255+fa.colors[1*3+1]*255+fa.colors[2*3+1]*255)/3.0f); + (*fi).C()[2] = (unsigned char)((fa.colors[0*3+2]*255+fa.colors[1*3+2]*255+fa.colors[2*3+2]*255)/3.0f); + } + } + } + + for(k=0;k=numvert_tmp ) { +// pi.status = PlyInfo::E_BAD_VERT_INDEX; +// return -1; +// } +// if(tsa.v[k+2]==-1) +// { +// k+=2; +// if(k%2) remainder=0; +// else remainder=1; +// continue; +// } +// tf.V(0) = index[ tsa.v[k+0] ]; +// tf.V(1) = index[ tsa.v[k+1] ]; +// tf.V(2) = index[ tsa.v[k+2] ]; +// if((k+remainder)%2) swap (tf.V(0), tf.V(1) ); +// m.face.push_back( tf ); +// } +// } +// } + else + { + // Skippaggio elementi non gestiti + int n = pf.ElemNumber(i); + pf.SetCurElement(i); + + for(int j=0;j32 && buf[i]<125 ) buf[j++] = buf[i]; + // + // buf[j] = 0; + // char buf2[255]; + // __interpret_texture_name( buf,filename,buf2 ); + // textures.push_back( xstring(buf2) ); + // } + // if( !strncmp(c,NFILE,strlen(NFILE)) ) + // { + // strcpy(buf,c+strlen(NFILE)+1); + // n = strlen(buf); + // for(i=j=0;i32 && buf[i]<125 ) buf[j++] = buf[i]; + // + // buf[j] = 0; + // char buf2[255]; + // __interpret_texture_name( buf,filename,buf2 ); + // normalmaps.push_back( xstring(buf2) ); + // } + //} + + // vn and fn should be correct but if someone wrongly saved some deleted elements they can be wrong. + m.vn = 0; + VertexIterator vi; + for(vi=m.vert.begin();vi!=m.vert.end();++vi) + if( ! (*vi).IsD() ) + ++m.vn; + + m.tn = 0; + TetraIterator fi; + for(fi=m.tetra.begin();fi!=m.tetra.end();++fi) + if( ! (*fi).IsD() ) + ++m.tn; + + return 0; +} + + + // Caricamento camera da un ply +int LoadCamera(const char * filename) +{ + vcg::ply::PlyFile pf; + if( pf.Open(filename,vcg::ply::PlyFile::MODE_READ)==-1 ) + { + pi.status = pf.GetError(); + return -1; + } + + + bool found = true; + int i; + for(i=0;i<23;++i) + { + if( pf.AddToRead(CameraDesc(i))==-1 ) + { + found = false; + break; + } + } + + if(!found) + return -1; + + for(i=0;i + +namespace vcg { +namespace tetra { +namespace io { + +template +class ImporterTS{ + + typedef typename MESHTYPE::VertexPointer VertexPointer; + typedef typename MESHTYPE::VertexType VertexType; + typedef typename MESHTYPE::TetraType FaceType; + typedef typename MESHTYPE::VertexIterator VertexIterator; + typedef typename MESHTYPE::FaceIterator FaceIterator; + typedef MESHTYPE::ScalarType ScalarType; + typedef Point3 Point3x; + + +int Load( MESHTYPE & m, const char * filename ) { + int nvertex; + int ntetra; + float x; + float y; + float z; + int tp0; + int tp1; + int tp2; + int tp3; + float mass; + FILE *f; + Tetramesh::VertexType p1; + f = fopen(filename,"r"); + if(f == NULL ) + { + printf( "The file was not opened\n" ); + return -1; + } + else + { + fscanf(f, "%i", &nvertex ); + fscanf(f, "%i", &ntetra ); + int j; + for (j=0;j +#include + +namespace vcg { +namespace tetra { +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-tetra 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 ; + + PlyInfo() + { + status=0; + mask=0; + cb=0; + vdn=fdn=0; + VertexData=TetraData=0; + } + /// Store the error codes enconutered when parsing a ply + int status; + /// It returns a bit mask describing the field preesnt in the ply file + int mask; + + /// 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; + + /// 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; + + /// The additional vertex descriptor that a user can specify to load additional per-face non-standard data stored in a ply + PropDescriptor *TetraData; + + /// a string containing the current ply header. Useful for showing it to the user. + std::string header; + +enum Error +{ + // Funzioni superiori + E_NO_VERTEX, // 14 + E_NO_FACE, // 15 + E_SHORTFILE, // 16 + E_NO_3VERTINFACE, // 17 + E_BAD_VERT_INDEX, // 18 + E_NO_6TCOORD, // 19 + E_DIFFER_COLORS, // 20 +}; + +}; // end class +} // end namespace tri +} // end namespace io +} // end namespace vcg +#endif