/**************************************************************************** * 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. * * * ****************************************************************************/ /**************************************************************************** Acknowlegments Portions of this file were based on the original code of the Ply library of Greg Turk and on the work of Claudio Rocchini ****************************************************************************/ /**************************************************************************** History $Log: not supported by cvs2svn $ Revision 1.12 2006/01/27 09:09:10 corsini Fix signed/unsigned mismatch Revision 1.11 2005/12/02 00:00:53 cignoni Moved and corrected interpret_texture_name from plystuff.h to plylib.cpp Revision 1.10 2005/11/26 00:22:46 cignoni added untested code of interpret_texture Revision 1.9 2005/11/12 07:07:47 cignoni Changed Offset types to remove warnings Revision 1.8 2005/03/15 11:46:52 cignoni Cleaning of the automatic bbox caching support for ply files. First working version. Revision 1.7 2005/01/03 10:35:59 cignoni Improved the compatibility for ply format for faces having the list size (e.g. number of vertexes of a face) as a char instead of a uchar. Added a couple of new face descriptors, corrected a bug in error reporting function (and restructured) and translated a few comments. Thanks to Patrick Min for the careful bug reporting Revision 1.6 2004/06/23 15:36:57 cignoni Restructured management of error, now the standard open for any mesh type return the error code, the default success value is zero Any import class has a method ErrorMsg that give a verbal description of an error code. Revision 1.5 2004/06/23 00:06:45 ponchio Moved #define LITTLE_MACHINE outside of #ifdef WIN32 (linux on PC is little too). Revision 1.4 2004/05/12 17:21:08 ganovelli inclusion of io.h removed (unnecessary) Revision 1.3 2004/05/12 10:13:29 ganovelli direct.h was included also without WIN32 definition Revision 1.2 2004/04/06 21:48:50 cignoni Commented out unused parameter names Revision 1.1 2004/03/03 15:00:51 cignoni Initial commit ****************************************************************************/ // Note that on ppc mac (the only bigendian machine around) // the preprocessor def __BIG_ENDIAN__ is always defined. // Otherwise we should be on a little endian machine (intel/amd based) #ifndef __BIG_ENDIAN__ #define LITTLE_MACHINE #endif #ifdef WIN32 #define assert ASSERT #else #include #endif #ifdef _MSC_VER #pragma warning( disable : 4267 ) #endif #ifdef WIN32 #include #endif #include #include #include #include #include #include #include #include #include #include #include #include "plylib.h" using namespace std; namespace vcg{ namespace ply{ typedef unsigned short ushort; typedef unsigned long ulong; typedef unsigned char uchar; typedef unsigned int uint; //#ifdef USE_ZLIB //#include //#define XFILE void //#define pb_fclose gzclose //#define pb_fopen gzopen //#define pb_fgets(s,n,f) gzgets(f,s,n) //#define pb_fread(b,s,n,f) gzread(f,b,(s)*(n)) //#else #define XFILE FILE #define pb_fclose fclose #define pb_fopen fopen #define pb_fgets(s,n,f) fgets(s,n,f) #define pb_fread(b,s,n,f) fread(b,s,n,f) //#endif //#ifdef WIN32 #define pb_mkdir(n) _mkdir(n) #define pb_access _access #define pb_stat _stat #define pb_open _open #define pb_close _close /* #else #define pb_mkdir(n) mkdir(n,0) #define pb_access access #define pb_stat stat #define pb_open open #define pb_close close #endif */ // Funzioni statiche per la lettura di un elemento int ReadBin ( XFILE * fp, const PlyProperty * pr, void * mem, int fmt ); int ReadAscii( XFILE * fp, const PlyProperty * pr, void * mem, int fmt ); const char * ::vcg::ply::PlyFile::typenames[9]= { "none", "char", "short", "int", "uchar", "ushort", "uint", "float", "double" }; const char * PlyFile::newtypenames[9]= { "none", "int8", "int16", "int32", "uint8", "uint16", "uint32", "float32", "float64" }; static int TypeSize[] = { 0, 1, 2, 4, 1, 2, 4, 4, 8 }; size_t PropDescriptor::memtypesize() const {return TypeSize[memtype1];} size_t PropDescriptor::stotypesize() const {return TypeSize[stotype1];} const char *PropDescriptor::memtypename() const {return PlyFile::typenames[memtype1];} const char *PropDescriptor::stotypename() const {return PlyFile::typenames[stotype1];} static char CrossType[9][9]= { {0,0,0,0,0,0,0,0,0}, {0,1,1,1,1,1,1,0,0}, {0,0,1,1,0,1,1,0,0}, {0,0,0,1,0,0,1,0,0}, {0,1,1,1,1,1,1,0,0}, {0,0,1,1,0,1,1,0,0}, {0,0,0,1,0,0,1,0,0}, {0,0,0,0,0,0,0,1,1}, {0,0,0,0,0,0,0,1,1} }; // ****************************************************** // Funzioni di supporto per la lettura/scrittura dei dati // ****************************************************** // Big-little endian static inline void SwapShort( ushort * s ) { assert(s); *s = ushort( (int(*s)>>8) | (int(*s)<<8) ); } static inline void SwapInt( uint * x ) { assert(x); *x = ( ((*x)>>24) & 0x000000FF ) | ( ((*x)>> 8) & 0x0000FF00 ) | ( ((*x)<< 8) & 0x00FF0000 ) | ( ((*x)<<24) & 0xFF000000 ) ; } static inline void SwapDouble( double * /*d*/ ) { // Come si fa? assert(0); } // Lettura tipi binari static inline int ReadCharB( XFILE * fp, char * c, int /*format*/ ) { assert(fp); assert(c); return pb_fread(c,1,1,fp); } static inline int ReadShortB( XFILE * fp, short * s, int format ) { assert(fp); assert(s); int r; r = pb_fread(s,sizeof(short),1,fp); #ifdef LITTLE_MACHINE if(format==F_BINBIG) #else if(format==F_BINLITTLE) #endif SwapShort((ushort *)s); return r; } static inline int ReadIntB( XFILE * fp, int * i, int format ) { assert(fp); assert(i); int r; r = pb_fread(i,sizeof(int),1,fp); #ifdef LITTLE_MACHINE if(format==F_BINBIG) #else if(format==F_BINLITTLE) #endif SwapInt((uint *)i); return r; } static inline int ReadUCharB( XFILE * fp, uchar * uc, int /*format*/ ) { assert(fp); assert(uc); return pb_fread(uc,1,1,fp); } static inline int ReadUShortB( XFILE * fp, ushort * us, int format ) { assert(fp); assert(us); int r; r = pb_fread(us,sizeof(ushort),1,fp); #ifdef LITTLE_MACHINE if(format==F_BINBIG) #else if(format==F_BINLITTLE) #endif SwapShort(us); return r; } static inline int ReadUIntB( XFILE * fp, uint * ui, int format ) { assert(fp); assert(ui); int r; r = pb_fread(ui,sizeof(uint),1,fp); #ifdef LITTLE_MACHINE if(format==F_BINBIG) #else if(format==F_BINLITTLE) #endif SwapInt(ui); return r; } static inline int ReadFloatB( XFILE * fp, float * f, int format ) { assert(fp); assert(f); int r; r = pb_fread(f,sizeof(float),1,fp); #ifdef LITTLE_MACHINE if(format==F_BINBIG) #else if(format==F_BINLITTLE) #endif SwapInt((uint *)f); return r; } static inline int ReadDoubleB( XFILE * fp, double * d, int format ) { assert(fp); assert(d); int r; r = pb_fread(d,sizeof(double),1,fp); #ifdef LITTLE_MACHINE if(format==F_BINBIG) #else if(format==F_BINLITTLE) #endif SwapDouble(d); return r; } // --- simulazione di scanf ------ //static bool sbuffer_ok = false; //static const int SBUFFERSIZE = 4096; //static char sbuffer[SBUFFERSIZE]; //static const char * separators = " \t,\n\r\f"; static void InitSBuffer() { //sbuffer_ok = false; } static inline int ReadInt( XFILE * fp, int & t ) { /* char * p; if(!sbuffer_ok) { pb_fgets(sbuffer,SBUFFERSIZE,fp); p = strtok(sbuffer,separators); sbuffer_ok = true; } else p = strtok(0,separators); if(p==0) { pb_fgets(sbuffer,SBUFFERSIZE,fp); p = strtok(sbuffer,separators); } t = atoi(p); return 1; */ int r = fscanf(fp,"%d",&t); if(r==EOF) r = 0; return r; } static inline int ReadUInt( XFILE * fp, unsigned int & t ) { /* char * p; if(!sbuffer_ok) { pb_fgets(sbuffer,SBUFFERSIZE,fp); p = strtok(sbuffer,separators); sbuffer_ok = true; } else p = strtok(0,separators); if(p==0) { pb_fgets(sbuffer,SBUFFERSIZE,fp); p = strtok(sbuffer,separators); } t = atoi(p); return 1; */ int r = fscanf(fp,"%u",&t); if(r==EOF) r = 0; return r; } static inline int ReadFloat( XFILE * fp, float & f ) { /* char * p; if(!sbuffer_ok) { pb_fgets(sbuffer,SBUFFERSIZE,fp); p = strtok(sbuffer,separators); sbuffer_ok = true; } else p = strtok(0,separators); if(p==0) { pb_fgets(sbuffer,SBUFFERSIZE,fp); p = strtok(sbuffer,separators); } f = atof(p); return 1; */ int r = fscanf(fp,"%f",&f); if(r==EOF) r = 0; return r; } static inline int ReadDouble( XFILE * fp, double & d ) { /* char * p; if(!sbuffer_ok) { pb_fgets(sbuffer,SBUFFERSIZE,fp); p = strtok(sbuffer,separators); sbuffer_ok = true; } else p = strtok(0,separators); if(p==0) { pb_fgets(sbuffer,SBUFFERSIZE,fp); p = strtok(sbuffer,separators); } d = atof(p); return 1; */ int r = fscanf(fp,"%lf",&d); if(r==EOF) r = 0; return r; } // Lettura tipi ascii static inline int ReadCharA( XFILE * fp, char * c ) { assert(fp); assert(c); int r,t; r = ReadInt(fp,t); *c = (char)t; return r; } static inline int ReadShortA( XFILE * fp, short * s ) { assert(fp); assert(s); int r,t; r = ReadInt(fp,t); *s = (short)t; return r; } static inline int ReadIntA( XFILE * fp, int * i ) { assert(fp); assert(i); return ReadInt(fp,*i); } static inline int ReadUCharA( XFILE * fp, uchar * uc ) { assert(fp); assert(uc); int r; uint t; r = ReadUInt(fp,t); *uc = (uchar)t; return r; } static inline int ReadUShortA( XFILE * fp, ushort * us ) { assert(fp); assert(us); int r; uint t; r = ReadUInt(fp,t); *us = (ushort)t; return r; } static inline int ReadUIntA( XFILE * fp, uint * ui ) { assert(fp); assert(ui); return ReadUInt(fp,*ui); } static inline int ReadFloatA( XFILE * fp, float * f ) { assert(fp); assert(f); return ReadFloat(fp,*f); } static inline int ReadDoubleA( XFILE * fp, double * d ) { assert(fp); assert(d); return ReadDouble(fp,*d); } // Memorizza il valore val nella variabile mem di tipo tm static inline void StoreInt( void * mem, const int tm, const int val ) { assert(mem); switch(tm) { case T_CHAR: *(char *)mem = (char )val; break; case T_SHORT: *(short *)mem = (short )val; break; case T_INT: *(int *)mem = (int )val; break; case T_UCHAR: *(uchar *)mem = (uchar )val; break; case T_USHORT: *(ushort *)mem = (ushort)val; break; case T_UINT: *(uint *)mem = (uint )val; break; case T_FLOAT: *(float *)mem = (float )val; break; case T_DOUBLE: *(double *)mem = (double)val; break; default: assert(0); } } // Salta un valore nel file static inline int SkipScalarA( XFILE * fp, const int tf ) { int t; float f; assert(fp); switch(tf) { case T_CHAR: case T_SHORT: case T_INT: case T_UCHAR: case T_USHORT: case T_UINT: return ReadInt(fp,t); case T_FLOAT: case T_DOUBLE: return ReadFloat(fp,f); default: assert(0); return 0; } } static inline int SkipScalarB( XFILE * fp, const int tf) { static char dummy[8]; assert(fp); return pb_fread(dummy,1,TypeSize[tf],fp); } static int ReadScalarB( XFILE * fp, void * mem, const int tf, const int tm, int fmt ) { static char ch; static short sh; static int in; static uchar uc; static ushort us; static uint ui; static float fl; static double dd; int r = 0; switch(tf) { case T_CHAR: //================== Lettura char r = ReadCharB(fp,&ch,fmt); switch(tm) { case T_CHAR: *(char *)mem = (char )ch; break; case T_SHORT: *(short *)mem = (short )ch; break; case T_INT: *(int *)mem = (int )ch; break; case T_UCHAR: *(uchar *)mem = (uchar )ch; break; case T_USHORT: *(ushort *)mem = (ushort)ch; break; case T_UINT: *(uint *)mem = (uint )ch; break; case T_FLOAT: *(float *)mem = (float )ch; break; case T_DOUBLE: *(double *)mem = (double)ch; break; default: assert(0); } break; case T_SHORT: //================== Lettura short r = ReadShortB(fp,&sh,fmt); switch(tm) { case T_CHAR: *(char *)mem = (char )sh; break; case T_SHORT: *(short *)mem = (short )sh; break; case T_INT: *(int *)mem = (int )sh; break; case T_UCHAR: *(uchar *)mem = (uchar )sh; break; case T_USHORT: *(ushort *)mem = (ushort)sh; break; case T_UINT: *(uint *)mem = (uint )sh; break; case T_FLOAT: *(float *)mem = (float )sh; break; case T_DOUBLE: *(double *)mem = (double)sh; break; default: assert(0); } break; case T_INT: //================== Lettura int r = ReadIntB(fp,&in,fmt); switch(tm) { case T_CHAR: *(char *)mem = (char )in; break; case T_SHORT: *(short *)mem = (short )in; break; case T_INT: *(int *)mem = (int )in; break; case T_UCHAR: *(uchar *)mem = (uchar )in; break; case T_USHORT: *(ushort *)mem = (ushort)in; break; case T_UINT: *(uint *)mem = (uint )in; break; case T_FLOAT: *(float *)mem = (float )in; break; case T_DOUBLE: *(double *)mem = (double)in; break; default: assert(0); } break; case T_UCHAR: //================== Lettura uchar r = ReadUCharB(fp,&uc,fmt); switch(tm) { case T_CHAR: *(char *)mem = (char )uc; break; case T_SHORT: *(short *)mem = (short )uc; break; case T_INT: *(int *)mem = (int )uc; break; case T_UCHAR: *(uchar *)mem = (uchar )uc; break; case T_USHORT: *(ushort *)mem = (ushort)uc; break; case T_UINT: *(uint *)mem = (uint )uc; break; case T_FLOAT: *(float *)mem = (float )uc; break; case T_DOUBLE: *(double *)mem = (double)uc; break; default: assert(0); } break; case T_USHORT: //================== Lettura ushort r = ReadUShortB(fp,&us,fmt); switch(tm) { case T_CHAR: *(char *)mem = (char )us; break; case T_SHORT: *(short *)mem = (short )us; break; case T_INT: *(int *)mem = (int )us; break; case T_UCHAR: *(uchar *)mem = (uchar )us; break; case T_USHORT: *(ushort *)mem = (ushort)us; break; case T_UINT: *(uint *)mem = (uint )us; break; case T_FLOAT: *(float *)mem = (float )us; break; case T_DOUBLE: *(double *)mem = (double)us; break; default: assert(0); } break; case T_UINT: //================== Lettura uint r = ReadUIntB(fp,&ui,fmt); switch(tm) { case T_CHAR: *(char *)mem = (char )ui; break; case T_SHORT: *(short *)mem = (short )ui; break; case T_INT: *(int *)mem = (int )ui; break; case T_UCHAR: *(uchar *)mem = (uchar )ui; break; case T_USHORT: *(ushort *)mem = (ushort)ui; break; case T_UINT: *(uint *)mem = (uint )ui; break; case T_FLOAT: *(float *)mem = (float )ui; break; case T_DOUBLE: *(double *)mem = (double)ui; break; default: assert(0); } break; case T_FLOAT: //================== Lettura float r = ReadFloatB(fp,&fl,fmt); switch(tm) { case T_FLOAT: *(float *)mem = fl; break; case T_DOUBLE: *(double *)mem = fl; break; default: assert(0); } break; case T_DOUBLE: //================== Lettura double r = ReadDoubleB(fp,&dd,fmt); switch(tm) { case T_FLOAT: *(float *)mem = (float)dd; break; case T_DOUBLE: *(double *)mem = dd; break; default: assert(0); } break; default: assert(0); } return r; } // Legge un valore di tipo tf e lo memorizza col tipo tm static int ReadScalarA( XFILE * fp, void * mem, const int tf, const int tm ) { static char ch; static short sh; static int in; static uchar uc; static ushort us; static uint ui; static float fl; static double dd; int r = 0; switch(tf) { case T_CHAR: //================== Lettura char r = ReadCharA(fp,&ch); switch(tm) { case T_CHAR: *(char *)mem = (char )ch; break; case T_SHORT: *(short *)mem = (short )ch; break; case T_INT: *(int *)mem = (int )ch; break; case T_UCHAR: *(uchar *)mem = (uchar )ch; break; case T_USHORT: *(ushort *)mem = (ushort)ch; break; case T_UINT: *(uint *)mem = (uint )ch; break; case T_FLOAT: *(float *)mem = (float )ch; break; case T_DOUBLE: *(double *)mem = (double)ch; break; default: assert(0); } break; case T_SHORT: //================== Lettura short r = ReadShortA(fp,&sh); switch(tm) { case T_CHAR: *(char *)mem = (char )sh; break; case T_SHORT: *(short *)mem = (short )sh; break; case T_INT: *(int *)mem = (int )sh; break; case T_UCHAR: *(uchar *)mem = (uchar )sh; break; case T_USHORT: *(ushort *)mem = (ushort)sh; break; case T_UINT: *(uint *)mem = (uint )sh; break; case T_FLOAT: *(float *)mem = (float )sh; break; case T_DOUBLE: *(double *)mem = (double)sh; break; default: assert(0); } break; case T_INT: //================== Lettura int r = ReadIntA(fp,&in); switch(tm) { case T_CHAR: *(char *)mem = (char )in; break; case T_SHORT: *(short *)mem = (short )in; break; case T_INT: *(int *)mem = (int )in; break; case T_UCHAR: *(uchar *)mem = (uchar )in; break; case T_USHORT: *(ushort *)mem = (ushort)in; break; case T_UINT: *(uint *)mem = (uint )in; break; case T_FLOAT: *(float *)mem = (float )in; break; case T_DOUBLE: *(double *)mem = (double)in; break; default: assert(0); } break; case T_UCHAR: //================== Lettura uchar r = ReadUCharA(fp,&uc); switch(tm) { case T_CHAR: *(char *)mem = (char )uc; break; case T_SHORT: *(short *)mem = (short )uc; break; case T_INT: *(int *)mem = (int )uc; break; case T_UCHAR: *(uchar *)mem = (uchar )uc; break; case T_USHORT: *(ushort *)mem = (ushort)uc; break; case T_UINT: *(uint *)mem = (uint )uc; break; case T_FLOAT: *(float *)mem = (float )uc; break; case T_DOUBLE: *(double *)mem = (double)uc; break; default: assert(0); } break; case T_USHORT: //================== Lettura ushort r = ReadUShortA(fp,&us); switch(tm) { case T_CHAR: *(char *)mem = (char )us; break; case T_SHORT: *(short *)mem = (short )us; break; case T_INT: *(int *)mem = (int )us; break; case T_UCHAR: *(uchar *)mem = (uchar )us; break; case T_USHORT: *(ushort *)mem = (ushort)us; break; case T_UINT: *(uint *)mem = (uint )us; break; case T_FLOAT: *(float *)mem = (float )us; break; case T_DOUBLE: *(double *)mem = (double)us; break; default: assert(0); } break; case T_UINT: //================== Lettura uint r = ReadUIntA(fp,&ui); switch(tm) { case T_CHAR: *(char *)mem = (char )ui; break; case T_SHORT: *(short *)mem = (short )ui; break; case T_INT: *(int *)mem = (int )ui; break; case T_UCHAR: *(uchar *)mem = (uchar )ui; break; case T_USHORT: *(ushort *)mem = (ushort)ui; break; case T_UINT: *(uint *)mem = (uint )ui; break; case T_FLOAT: *(float *)mem = (float )ui; break; case T_DOUBLE: *(double *)mem = (double)ui; break; default: assert(0); } break; case T_FLOAT: //================== Lettura float r = ReadFloatA(fp,&fl); switch(tm) { case T_FLOAT: *(float *)mem = fl; break; case T_DOUBLE: *(double *)mem = fl; break; default: assert(0); } break; case T_DOUBLE: //================== Lettura double r = ReadDoubleA(fp,&dd); switch(tm) { case T_FLOAT: *(float *)mem = (float)dd; break; case T_DOUBLE: *(double *)mem = dd; break; default: assert(0); } break; default: assert(0); } return r; } //####################### Classe PlyElement void PlyElement::AddProp( const char * na, int ti, int isl, int t2 ) { assert(na); assert(ti>0); assert(ti0 || (t2==0 && isl==0)); assert(t2::iterator i; for(i=props.begin();i!=props.end();++i) if( i->name == na ) return &*i; return 0; } int PlyElement::AddToRead( const char * propname, int stotype1, int memtype1, size_t offset1, int islist, int alloclist, int stotype2, int memtype2, size_t offset2 ) // Vedi struttura PropDescriptor { assert(propname); PlyProperty * p = FindProp(propname); if(p==0) { return E_PROPNOTFOUND; } if( stotype1<1 || stotype1>=T_MAXTYPE || memtype1<1 || memtype1>=T_MAXTYPE ) { return E_BADTYPE; } if( islist && (stotype2<1 || stotype2>=T_MAXTYPE || memtype2<1 || memtype2>=T_MAXTYPE ) ) { return E_BADTYPE; } if( islist!= p->islist || stotype1 != p->tipo || ( islist && stotype2!=p->tipoindex) ) { return E_INCOMPATIBLETYPE; } if( !CrossType[p->tipo][stotype1] || (islist && !CrossType[p->tipoindex][stotype2] ) ) { return E_BADCAST; } p->bestored = 1; p->desc.stotype1 = stotype1; p->desc.memtype1 = memtype1; p->desc.offset1 = offset1; p->desc.islist = islist; p->desc.alloclist = alloclist; p->desc.stotype2 = stotype2; p->desc.memtype2 = memtype2; p->desc.offset2 = offset2; return E_NOERROR; } //####################### Classe PlyFile PlyFile::PlyFile( void ) { gzfp = 0; version = 0.0f; error = E_NOERROR; format = F_UNSPECIFIED; cure = 0; ReadCB = 0; InitSBuffer(); } PlyFile::~PlyFile( void ) { Destroy(); } int PlyFile::Open( const char * filename, int mode ) { if(filename==0 || (mode!=MODE_READ && mode!=MODE_WRITE) ) { error = E_CANTOPEN; return -1; } if(mode==MODE_READ) return OpenRead(filename); else return OpenWrite(filename); } void PlyFile::Destroy( void ) { if(gzfp!=0) { pb_fclose(gzfp); gzfp = 0; } ReadCB = 0; } int PlyFile::OpenRead( const char * filename ) { // Tokens dell'intestazione static const char * SEP = " \t\n\r"; static const char * HEADER = "ply"; static const char * FORMAT = "format"; static const char * TASCII = "ascii"; static const char * TBINBIG = "binary_big_endian"; static const char * TBINLITTLE = "binary_little_endian"; static const char * COMMENT = "comment"; static const char * OBJ_INFO = "obj_info"; static const char * ELEMENT = "element"; static const char * PROPERTY = "property"; static const char * ENDHEADER = "end_header"; static const char * LIST = "list"; const int MAXB = 512; char buf[MAXB]; char * token; PlyElement * curelement; // Predistruzione Destroy(); // Apertura file gzfp = pb_fopen(filename,"rb"); if(gzfp==0) { error = E_CANTOPEN; goto error; } header[0] = 0; // ********* Parsing header *********** // Controllo header if( pb_fgets(buf,MAXB-1,gzfp)==0 ) { error = E_UNESPECTEDEOF; goto error; } strcat(header,buf); if( strncmp(buf,HEADER,strlen(HEADER)) ) { error = E_NOTHEADER; goto error; } // Lettura tipo e versione if( pb_fgets(buf,MAXB-1,gzfp)==0 ) { error = E_UNESPECTEDEOF; goto error; } strcat(header,buf); token = strtok(buf,SEP); if(token==0) { error = E_UNESPECTEDEOF; goto error; } if( strcmp(token,FORMAT) ) { error = E_NOFORMAT; goto error; } token = strtok(0,SEP); if(token==0) { error = E_UNESPECTEDEOF; goto error; } if( !strcmp(token,TASCII) ) format = F_ASCII; else if( !strcmp(token,TBINBIG) ) format = F_BINBIG; else if( !strcmp(token,TBINLITTLE) ) format = F_BINLITTLE; else { error = E_NOFORMAT; goto error; } token = strtok(0,SEP); if(token==0) { error = E_UNESPECTEDEOF; goto error; } version = float(atof(token)); //************* Ciclo lettura elementi **************** curelement = 0; for(;;) { if( pb_fgets(buf,MAXB-1,gzfp)==0 ) { error = E_UNESPECTEDEOF; goto error; } strcat(header,buf); token = strtok(buf,SEP); if(token==0) { error = E_UNESPECTEDEOF; goto error; } if( !strcmp(token,COMMENT) ) { comments.push_back( string(token+strlen(token)+1) ); //AddComment( token+strlen(token)+1 ); } else if( !strcmp(token,OBJ_INFO) ) { comments.push_back( string(token+strlen(token)+1) ); //AddComment( token+strlen(token)+1 ); } else if( !strcmp(token,ENDHEADER) ) { break; } else if( !strcmp(token,ELEMENT) ) { // Lettura nome elemento char * name = strtok(0,SEP); if(name==0) { error = E_SYNTAX; goto error; } // Lettura numero di elementi token = strtok(0,SEP); if(name==0) { error = E_SYNTAX; goto error; } int number = atoi(token); PlyElement t(name,number); elements.push_back(t); curelement = &(elements.back()); } else if( !strcmp(token,PROPERTY) ) { if(curelement==0) { error = E_PROPOUTOFELEMENT; goto error; } token = strtok(0,SEP); if(token==0) { error = E_SYNTAX; goto error; } if( !strcmp(token,LIST) ) { token = strtok(0,SEP); if(token==0) { error = E_SYNTAX; goto error; } int t2 = FindType(token); if(t2==-1) { error = E_BADTYPENAME; goto error; } token = strtok(0,SEP); if(token==0) { error = E_SYNTAX; goto error; } int t1 = FindType(token); if(t1==-1) { error = E_BADTYPENAME; goto error; } token = strtok(0,SEP); if(token==0) { error = E_SYNTAX; goto error; } //curelement->AddProp(token,t1,1,t2); prima del 5/9/03 era cosi' ma swappava i due tipi. curelement->AddProp(token,t1,1,t2); } else { int t1 = FindType(token); if(t1==-1) { error = E_BADTYPENAME; goto error; } token = strtok(0,SEP); if(token==0) { error = E_SYNTAX; goto error; } curelement->AddProp(token,t1,0,T_NOTYPE); } } else { error = E_SYNTAX; goto error; } } if(format==F_ASCII) ReadCB = ReadAscii; else ReadCB = ReadBin; return 0; error: Destroy(); return -1; } int PlyFile::OpenWrite( const char * /*filename*/ ) { // Per ora non implementato assert(0); return -1; } //################# Funzioni di supporto int PlyFile::FindType( const char * name ) const { int i; assert(name); for(i=1;i<9;++i) if( !strcmp(name,typenames[i]) || !strcmp(name,newtypenames[i])) return i; return -1; } PlyElement * PlyFile::FindElement( const char * na ) { assert(na); vector::iterator i; for(i=elements.begin();i!=elements.end();++i) if( i->name == na ) return &*i; return 0; } int PlyFile::AddToRead( const char * elemname, const char * propname, int stotype1, int memtype1, size_t offset1, int islist, int alloclist, int stotype2, int memtype2, size_t offset2 ) // Vedi struttura PropDescriptor { assert(elemname); PlyElement * e = FindElement(elemname); if(e==0) { error = E_ELEMNOTFOUND; return -1; } int r = e->AddToRead(propname,stotype1,memtype1,offset1,islist, alloclist,stotype2,memtype2,offset2 ); if(r==E_NOERROR) return 0; else { error = r; return -1; } } const char * PlyFile::ElemName( int i ) { if(i<0 || i>=int(elements.size())) return 0; else return elements[i].name.c_str(); } int PlyFile::ElemNumber( int i ) const { if(i<0 || i>=int(elements.size())) return 0; else return elements[i].number; } // *** callbacks *** static bool cb_skip_bin1( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ ) { static char dummy[1]; assert(fp); return pb_fread(dummy,1,1,fp)!=0; } static bool cb_skip_bin2( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ ) { static char dummy[2]; assert(fp); return pb_fread(dummy,1,2,fp)!=0; } static bool cb_skip_bin4( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ ) { static char dummy[4]; assert(fp); return pb_fread(dummy,1,4,fp)!=0; } static bool cb_skip_bin8( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ ) { static char dummy[8]; assert(fp); return pb_fread(dummy,1,8,fp)!=0; } static bool cb_skip_float_ascii( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ ) { static float dummy; assert(fp); return fscanf(fp,"%f",&dummy)!=EOF; } static bool cb_skip_int_ascii( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ ) { static int dummy; assert(fp); return fscanf(fp,"%d",&dummy)!=EOF; } static bool cb_read_chch( GZFILE fp, void * mem, PropDescriptor * d ) { return pb_fread( ((char *)mem)+d->offset1,1,1,fp)!=0; } static bool cb_read_chsh( GZFILE fp, void * mem, PropDescriptor * d ) { char c; if( pb_fread(&c,1,1,fp)==0) return false; return true; *(short *)(((char *)mem)+d->offset1) = short(c); return true; } static bool cb_read_chin( GZFILE fp, void * mem, PropDescriptor * d ) { char c; if( pb_fread(&c,1,1,fp)==0) return false; return true; *(int *)(((char *)mem)+d->offset1) = int(c); return true; } static bool cb_read_chuc( GZFILE fp, void * mem, PropDescriptor * d ) { char c; if( pb_fread(&c,1,1,fp)==0) return false; return true; *(uchar *)(((char *)mem)+d->offset1) = uchar(c); return true; } static bool cb_read_chus( GZFILE fp, void * mem, PropDescriptor * d ) { char c; if( pb_fread(&c,1,1,fp)==0) return false; return true; *(ushort *)(((char *)mem)+d->offset1) = ushort(c); return true; } static bool cb_read_chui( GZFILE fp, void * mem, PropDescriptor * d ) { char c; if( pb_fread(&c,1,1,fp)==0) return false; return true; *(uint *)(((char *)mem)+d->offset1) = uint(c); return true; } static bool cb_read_chfl( GZFILE fp, void * mem, PropDescriptor * d ) { char c; if( pb_fread(&c,1,1,fp)==0) return false; return true; *(float *)(((char *)mem)+d->offset1) = float(c); return true; } static bool cb_read_chdo( GZFILE fp, void * mem, PropDescriptor * d ) { char c; if( pb_fread(&c,1,1,fp)==0) return false; return true; *(double *)(((char *)mem)+d->offset1) = double(c); return true; } static bool cb_read_shch( GZFILE fp, void * mem, PropDescriptor * d ) { short c; if( ReadShortB(fp,&c,d->format)==0) return false; *(char *)(((char *)mem)+d->offset1) = char(c); return true; } static bool cb_read_shsh( GZFILE fp, void * mem, PropDescriptor * d ) { short c; if( ReadShortB(fp,&c,d->format)==0) return false; *(short *)(((char *)mem)+d->offset1) = short(c); return true; } static bool cb_read_shin( GZFILE fp, void * mem, PropDescriptor * d ) { short c; if( ReadShortB(fp,&c,d->format)==0) return false; *(int *)(((char *)mem)+d->offset1) = int(c); return true; } static bool cb_read_shuc( GZFILE fp, void * mem, PropDescriptor * d ) { short c; if( ReadShortB(fp,&c,d->format)==0) return false; *(uchar *)(((char *)mem)+d->offset1) = uchar(c); return true; } static bool cb_read_shus( GZFILE fp, void * mem, PropDescriptor * d ) { short c; if( ReadShortB(fp,&c,d->format)==0) return false; *(ushort *)(((char *)mem)+d->offset1) = ushort(c); return true; } static bool cb_read_shui( GZFILE fp, void * mem, PropDescriptor * d ) { short c; if( ReadShortB(fp,&c,d->format)==0) return false; *(uint *)(((char *)mem)+d->offset1) = uint(c); return true; } static bool cb_read_shfl( GZFILE fp, void * mem, PropDescriptor * d ) { short c; if( ReadShortB(fp,&c,d->format)==0) return false; *(float *)(((char *)mem)+d->offset1) = float(c); return true; } static bool cb_read_shdo( GZFILE fp, void * mem, PropDescriptor * d ) { short c; if( ReadShortB(fp,&c,d->format)==0) return false; *(double *)(((char *)mem)+d->offset1) = double(c); return true; } static bool cb_read_inch( GZFILE fp, void * mem, PropDescriptor * d ) { int c; if( ReadIntB(fp,&c,d->format)==0 ) return false; *(char *)(((char *)mem)+d->offset1) = char(c); return true; } static bool cb_read_insh( GZFILE fp, void * mem, PropDescriptor * d ) { int c; if( ReadIntB(fp,&c,d->format)==0 ) return false; *(short *)(((char *)mem)+d->offset1) = short(c); return true; } static bool cb_read_inin( GZFILE fp, void * mem, PropDescriptor * d ) { int c; if( ReadIntB(fp,&c,d->format)==0 ) return false; *(int *)(((char *)mem)+d->offset1) = int(c); return true; } static bool cb_read_inuc( GZFILE fp, void * mem, PropDescriptor * d ) { int c; if( ReadIntB(fp,&c,d->format)==0 ) return false; *(uchar *)(((char *)mem)+d->offset1) = uchar(c); return true; } static bool cb_read_inus( GZFILE fp, void * mem, PropDescriptor * d ) { int c; if( ReadIntB(fp,&c,d->format)==0 ) return false; *(ushort *)(((char *)mem)+d->offset1) = ushort(c); return true; } static bool cb_read_inui( GZFILE fp, void * mem, PropDescriptor * d ) { int c; if( ReadIntB(fp,&c,d->format)==0 ) return false; *(uint *)(((char *)mem)+d->offset1) = uint(c); return true; } static bool cb_read_infl( GZFILE fp, void * mem, PropDescriptor * d ) { int c; if( ReadIntB(fp,&c,d->format)==0 ) return false; *(float *)(((char *)mem)+d->offset1) = float(c); return true; } static bool cb_read_indo( GZFILE fp, void * mem, PropDescriptor * d ) { int c; if( ReadIntB(fp,&c,d->format)==0 ) return false; *(double *)(((char *)mem)+d->offset1) = double(c); return true; } static bool cb_read_ucch( GZFILE fp, void * mem, PropDescriptor * d ) { uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false; *(char *)(((char *)mem)+d->offset1) = char(c); return true; } static bool cb_read_ucsh( GZFILE fp, void * mem, PropDescriptor * d ) { uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false; *(short *)(((char *)mem)+d->offset1) = short(c); return true; } static bool cb_read_ucin( GZFILE fp, void * mem, PropDescriptor * d ) { uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false; *(int *)(((char *)mem)+d->offset1) = int(c); return true; } static bool cb_read_ucuc( GZFILE fp, void * mem, PropDescriptor * d ) { uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false; *(uchar *)(((char *)mem)+d->offset1) = uchar(c); return true; } static bool cb_read_ucus( GZFILE fp, void * mem, PropDescriptor * d ) { uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false; *(ushort *)(((char *)mem)+d->offset1) = ushort(c); return true; } static bool cb_read_ucui( GZFILE fp, void * mem, PropDescriptor * d ) { uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false; *(uint *)(((char *)mem)+d->offset1) = uint(c); return true; } static bool cb_read_ucfl( GZFILE fp, void * mem, PropDescriptor * d ) { uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false; *(float *)(((char *)mem)+d->offset1) = float(c); return true; } static bool cb_read_ucdo( GZFILE fp, void * mem, PropDescriptor * d ) { uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false; *(double *)(((char *)mem)+d->offset1) = double(c); return true; } static bool cb_read_usch( GZFILE fp, void * mem, PropDescriptor * d ) { ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false; *(char *)(((char *)mem)+d->offset1) = char(c); return true; } static bool cb_read_ussh( GZFILE fp, void * mem, PropDescriptor * d ) { ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false; *(short *)(((char *)mem)+d->offset1) = short(c); return true; } static bool cb_read_usin( GZFILE fp, void * mem, PropDescriptor * d ) { ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false; *(int *)(((char *)mem)+d->offset1) = int(c); return true; } static bool cb_read_usuc( GZFILE fp, void * mem, PropDescriptor * d ) { ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false; *(uchar *)(((char *)mem)+d->offset1) = uchar(c); return true; } static bool cb_read_usus( GZFILE fp, void * mem, PropDescriptor * d ) { ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false; *(ushort *)(((char *)mem)+d->offset1) = ushort(c); return true; } static bool cb_read_usui( GZFILE fp, void * mem, PropDescriptor * d ) { ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false; *(uint *)(((char *)mem)+d->offset1) = uint(c); return true; } static bool cb_read_usfl( GZFILE fp, void * mem, PropDescriptor * d ) { ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false; *(float *)(((char *)mem)+d->offset1) = float(c); return true; } static bool cb_read_usdo( GZFILE fp, void * mem, PropDescriptor * d ) { ushort c; if( ReadUShortB(fp,&c,d->format)==0) return false; *(double *)(((char *)mem)+d->offset1) = double(c); return true; } static bool cb_read_uich( GZFILE fp, void * mem, PropDescriptor * d ) { uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false; *(char *)(((char *)mem)+d->offset1) = char(c); return true; } static bool cb_read_uish( GZFILE fp, void * mem, PropDescriptor * d ) { uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false; *(short *)(((char *)mem)+d->offset1) = short(c); return true; } static bool cb_read_uiin( GZFILE fp, void * mem, PropDescriptor * d ) { uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false; *(int *)(((char *)mem)+d->offset1) = int(c); return true; } static bool cb_read_uiuc( GZFILE fp, void * mem, PropDescriptor * d ) { uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false; *(uchar *)(((char *)mem)+d->offset1) = uchar(c); return true; } static bool cb_read_uius( GZFILE fp, void * mem, PropDescriptor * d ) { uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false; *(ushort *)(((char *)mem)+d->offset1) = ushort(c); return true; } static bool cb_read_uiui( GZFILE fp, void * mem, PropDescriptor * d ) { uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false; *(uint *)(((char *)mem)+d->offset1) = uint(c); return true; } static bool cb_read_uifl( GZFILE fp, void * mem, PropDescriptor * d ) { uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false; *(float *)(((char *)mem)+d->offset1) = float(c); return true; } static bool cb_read_uido( GZFILE fp, void * mem, PropDescriptor * d ) { uint c; if( ReadUIntB(fp,&c,d->format)==0 ) return false; *(double *)(((char *)mem)+d->offset1) = double(c); return true; } static bool cb_read_flfl( GZFILE fp, void * mem, PropDescriptor * d ) { float c; if( ReadFloatB(fp,&c,d->format)==0 ) return false; *(float *)(((char *)mem)+d->offset1) = float(c); return true; } static bool cb_read_fldo( GZFILE fp, void * mem, PropDescriptor * d ) { float c; if( ReadFloatB(fp,&c,d->format)==0 ) return false; *(double *)(((char *)mem)+d->offset1) = double(c); return true; } static bool cb_read_dofl( GZFILE fp, void * mem, PropDescriptor * d ) { double c; if( ReadDoubleB(fp,&c,d->format)==0 ) return false; *(float *)(((char *)mem)+d->offset1) = float(c); return true; } static bool cb_read_dodo( GZFILE fp, void * mem, PropDescriptor * d ) { double c; if( ReadDoubleB(fp,&c,d->format)==0 ) return false; *(double *)(((char *)mem)+d->offset1) = double(c); return true; } // NON OTTIMIZZATO!! static bool cb_read_ascii( GZFILE fp, void * mem, PropDescriptor * d ) { return ReadScalarA(fp, ((char *)mem)+d->offset1, d->stotype1, d->memtype1)!=0; } const int SKIP_MAX_BUF = 512; static char skip_buf[SKIP_MAX_BUF]; static bool cb_skip_list_bin1( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ ) { uchar n; // Solo indici uchar if( pb_fread(&n,1,1,fp)==0 ) return false; if( pb_fread(skip_buf,1,n,fp)==0) return false; return true; } static bool cb_skip_list_bin2( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ ) { uchar n; // Solo indici uchar if( pb_fread(&n,1,1,fp)==0 ) return false; if( pb_fread(skip_buf,2,n,fp)==0) return false; return true; } static bool cb_skip_list_bin4( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ ) { uchar n; // Solo indici uchar if( pb_fread(&n,1,1,fp)==0 ) return false; if( pb_fread(skip_buf,4,n,fp)==0) return false; return true; } static bool cb_skip_list_bin8( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ ) { uchar n; // Solo indici uchar if( pb_fread(&n,1,1,fp)==0 ) return false; if( pb_fread(skip_buf,8,n,fp)==0) return false; return true; } static bool cb_skip_list_ascii ( GZFILE fp, void * /*mem*/, PropDescriptor * /*d*/ ) { int i,n; if( !ReadScalarA(fp,&n,T_INT, T_INT) )return false; for(i=0;ioffset2, d->memtype2, n); // Determinazione memoria vettore if(d->alloclist) { store = (char *)calloc(n,TypeSize[d->memtype1]); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else { store = ((char *)mem)+d->offset1; } for(i=0;imemtype1], d->stotype1, d->memtype1 ) ) return 0; } return true; } // static bool cb_read_list_chch( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(char)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(short)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(int)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uchar)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(ushort)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uint)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(float)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(double)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(char)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(char *)(store+i*sizeof(char)) = char(c); } return true; } static bool cb_read_list_shsh( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(short)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(short *)(store+i*sizeof(short)) = short(c); } return true; } static bool cb_read_list_shin( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(int)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(int *)(store+i*sizeof(int)) = int(c); } return true; } static bool cb_read_list_shuc( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uchar)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(uchar *)(store+i*sizeof(uchar)) = uchar(c); } return true; } static bool cb_read_list_shus( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(ushort)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(ushort *)(store+i*sizeof(ushort)) = ushort(c); } return true; } static bool cb_read_list_shui( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uint)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(uint *)(store+i*sizeof(uint)) = uint(c); } return true; } static bool cb_read_list_shfl( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(float)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(float *)(store+i*sizeof(float)) = float(c); } return true; } static bool cb_read_list_shdo( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(double)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(double *)(store+i*sizeof(double)) = double(c); } return true; } static bool cb_read_list_inch( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(char)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(char *)(store+i*sizeof(char)) = char(c); } return true; } static bool cb_read_list_insh( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(short)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(short *)(store+i*sizeof(short)) = short(c); } return true; } static bool cb_read_list_inin( GZFILE fp, void * mem, PropDescriptor * d ) { // uchar n,i; prima del 5/9/03 era cosi' // if( pb_fread(&n,1,1,fp)==0 ) return false; int n=0,i; switch(d->stotype2) { case T_CHAR : { char val; if( ReadCharB(fp,&val,d->format)==0 ) return false; n=val; } break; case T_UCHAR : { uchar val; if( ReadUCharB(fp,&val,d->format)==0 ) return false; n=val; } break; case T_SHORT : { short val; if( ReadShortB(fp,&val,d->format)==0 ) return false; n=val; } break; case T_UINT : { uint val; if( ReadUIntB(fp,&val,d->format)==0 ) return false; n=val; } break; case T_INT : { int val; if( ReadIntB(fp,&val,d->format)==0 ) return false; n=val; } break; default: assert(0); break; } char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(int)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; } return true; } static bool cb_read_list_inuc( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uchar)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(uchar *)(store+i*sizeof(uchar)) = uchar(c); } return true; } static bool cb_read_list_inus( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(ushort)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(ushort *)(store+i*sizeof(ushort)) = ushort(c); } return true; } static bool cb_read_list_inui( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uint)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(uint *)(store+i*sizeof(uint)) = uint(c); } return true; } static bool cb_read_list_infl( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(float)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(float *)(store+i*sizeof(float)) = float(c); } return true; } static bool cb_read_list_indo( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(double)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(double *)(store+i*sizeof(double)) = double(c); } return true; } static bool cb_read_list_ucch( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(char)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(short)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(int)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uchar)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(ushort)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uint)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(float)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(double)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;ioffset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(char)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(char *)(store+i*sizeof(char)) = char(c); } return true; } static bool cb_read_list_ussh( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(short)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(short *)(store+i*sizeof(short)) = short(c); } return true; } static bool cb_read_list_usin( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(int)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(int *)(store+i*sizeof(int)) = int(c); } return true; } static bool cb_read_list_usuc( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uchar)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(uchar *)(store+i*sizeof(uchar)) = uchar(c); } return true; } static bool cb_read_list_usus( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(ushort)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(ushort *)(store+i*sizeof(ushort)) = ushort(c); } return true; } static bool cb_read_list_usui( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uint)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(uint *)(store+i*sizeof(uint)) = uint(c); } return true; } static bool cb_read_list_usfl( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(float)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(float *)(store+i*sizeof(float)) = float(c); } return true; } static bool cb_read_list_usdo( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(double)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0) return false; *(double *)(store+i*sizeof(double)) = double(c); } return true; } static bool cb_read_list_uich( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(char)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(char *)(store+i*sizeof(char)) = char(c); } return true; } static bool cb_read_list_uish( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(short)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(short *)(store+i*sizeof(short)) = short(c); } return true; } static bool cb_read_list_uiin( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(int)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(int *)(store+i*sizeof(int)) = int(c); } return true; } static bool cb_read_list_uiuc( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uchar)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(uchar *)(store+i*sizeof(uchar)) = uchar(c); } return true; } static bool cb_read_list_uius( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(ushort)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(ushort *)(store+i*sizeof(ushort)) = ushort(c); } return true; } static bool cb_read_list_uiui( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(uint)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(uint *)(store+i*sizeof(uint)) = uint(c); } return true; } static bool cb_read_list_uifl( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(float)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(float *)(store+i*sizeof(float)) = float(c); } return true; } static bool cb_read_list_uido( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(double)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(double *)(store+i*sizeof(double)) = double(c); } return true; } static bool cb_read_list_flfl( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(float)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(float *)(store+i*sizeof(float)) = float(c); } return true; } static bool cb_read_list_fldo( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(double)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(double *)(store+i*sizeof(double)) = double(c); } return true; } static bool cb_read_list_dofl( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(float)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(float *)(store+i*sizeof(float)) = float(c); } return true; } static bool cb_read_list_dodo( GZFILE fp, void * mem, PropDescriptor * d ) { uchar n,i; if( pb_fread(&n,1,1,fp)==0 ) return false; char * store; StoreInt( ((char *)mem)+d->offset2, d->memtype2, int(n)); if(d->alloclist) { store = (char *)calloc(n,sizeof(double)); assert(store); *(char **)(((char *)mem)+d->offset1) = store; } else store = ((char *)mem)+d->offset1; for(i=0;iformat)==0 ) return false; *(double *)(store+i*sizeof(double)) = double(c); } return true; } void PlyFile::compile( PlyProperty * p ) { p->desc.format = format; // copiatura formato if(format==F_ASCII) { if(p->islist) { if(p->bestored) p->cb = cb_read_list_ascii; else p->cb = cb_skip_list_ascii; } else { if(p->bestored) { p->cb = cb_read_ascii; } else { switch(p->tipo) { case T_CHAR: case T_SHORT: case T_INT: case T_UCHAR: case T_USHORT: case T_UINT: p->cb = cb_skip_int_ascii; break; case T_FLOAT: case T_DOUBLE: p->cb = cb_skip_float_ascii; break; default: p->cb = 0; assert(0); break; } } } } else { if(p->islist) { if(p->bestored) { switch(p->desc.stotype1) { case T_CHAR: //================== Lettura char switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_list_chch; break; case T_SHORT: p->cb = cb_read_list_chsh; break; case T_INT: p->cb = cb_read_list_chin; break; case T_UCHAR: p->cb = cb_read_list_chuc; break; case T_USHORT: p->cb = cb_read_list_chus; break; case T_UINT: p->cb = cb_read_list_chui; break; case T_FLOAT: p->cb = cb_read_list_chfl; break; case T_DOUBLE: p->cb = cb_read_list_chdo; break; default: assert(0); } break; case T_SHORT: //================== Lettura short switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_list_shch; break; case T_SHORT: p->cb = cb_read_list_shsh; break; case T_INT: p->cb = cb_read_list_shin; break; case T_UCHAR: p->cb = cb_read_list_shuc; break; case T_USHORT: p->cb = cb_read_list_shus; break; case T_UINT: p->cb = cb_read_list_shui; break; case T_FLOAT: p->cb = cb_read_list_shfl; break; case T_DOUBLE: p->cb = cb_read_list_shdo; break; default: assert(0); } break; case T_INT: //================== Lettura int switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_list_inch; break; case T_SHORT: p->cb = cb_read_list_insh; break; case T_INT: p->cb = cb_read_list_inin; break; case T_UCHAR: p->cb = cb_read_list_inuc; break; case T_USHORT: p->cb = cb_read_list_inus; break; case T_UINT: p->cb = cb_read_list_inui; break; case T_FLOAT: p->cb = cb_read_list_infl; break; case T_DOUBLE: p->cb = cb_read_list_indo; break; default: assert(0); } break; case T_UCHAR: //================== Lettura uchar switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_list_ucch; break; case T_SHORT: p->cb = cb_read_list_ucsh; break; case T_INT: p->cb = cb_read_list_ucin; break; case T_UCHAR: p->cb = cb_read_list_ucuc; break; case T_USHORT: p->cb = cb_read_list_ucus; break; case T_UINT: p->cb = cb_read_list_ucui; break; case T_FLOAT: p->cb = cb_read_list_ucfl; break; case T_DOUBLE: p->cb = cb_read_list_ucdo; break; default: assert(0); } break; case T_USHORT: //================== Lettura ushort switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_list_usch; break; case T_SHORT: p->cb = cb_read_list_ussh; break; case T_INT: p->cb = cb_read_list_usin; break; case T_UCHAR: p->cb = cb_read_list_usuc; break; case T_USHORT: p->cb = cb_read_list_usus; break; case T_UINT: p->cb = cb_read_list_usui; break; case T_FLOAT: p->cb = cb_read_list_usfl; break; case T_DOUBLE: p->cb = cb_read_list_usdo; break; default: assert(0); } break; case T_UINT: //================== Lettura uint switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_list_uich; break; case T_SHORT: p->cb = cb_read_list_uish; break; case T_INT: p->cb = cb_read_list_uiin; break; case T_UCHAR: p->cb = cb_read_list_uiuc; break; case T_USHORT: p->cb = cb_read_list_uius; break; case T_UINT: p->cb = cb_read_list_uiui; break; case T_FLOAT: p->cb = cb_read_list_uifl; break; case T_DOUBLE: p->cb = cb_read_list_uido; break; default: assert(0); } break; case T_FLOAT: //================== Lettura float switch(p->desc.memtype1) { case T_FLOAT: p->cb = cb_read_list_flfl; break; case T_DOUBLE: p->cb = cb_read_list_fldo; break; default: assert(0); } break; case T_DOUBLE: //================== Lettura double switch(p->desc.memtype1) { case T_FLOAT: p->cb = cb_read_list_dofl; break; case T_DOUBLE: p->cb = cb_read_list_dodo; break; default: assert(0); } break; default: assert(0); } } else { switch(TypeSize[p->tipo]) { case 1: p->cb = cb_skip_list_bin1; break; case 2: p->cb = cb_skip_list_bin2; break; case 4: p->cb = cb_skip_list_bin4; break; case 8: p->cb = cb_skip_list_bin8; break; // before 29/6/08 was p->cb = cb_skip_list_bin4 but by simmetry... default:p->cb = 0; assert(0); break; } } } else { if(p->bestored) { switch(p->desc.stotype1) { case T_CHAR: //================== Lettura char switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_chch; break; case T_SHORT: p->cb = cb_read_chsh; break; case T_INT: p->cb = cb_read_chin; break; case T_UCHAR: p->cb = cb_read_chuc; break; case T_USHORT: p->cb = cb_read_chus; break; case T_UINT: p->cb = cb_read_chui; break; case T_FLOAT: p->cb = cb_read_chfl; break; case T_DOUBLE: p->cb = cb_read_chdo; break; default: assert(0); } break; case T_SHORT: //================== Lettura short switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_shch; break; case T_SHORT: p->cb = cb_read_shsh; break; case T_INT: p->cb = cb_read_shin; break; case T_UCHAR: p->cb = cb_read_shuc; break; case T_USHORT: p->cb = cb_read_shus; break; case T_UINT: p->cb = cb_read_shui; break; case T_FLOAT: p->cb = cb_read_shfl; break; case T_DOUBLE: p->cb = cb_read_shdo; break; default: assert(0); } break; case T_INT: //================== Lettura int switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_inch; break; case T_SHORT: p->cb = cb_read_insh; break; case T_INT: p->cb = cb_read_inin; break; case T_UCHAR: p->cb = cb_read_inuc; break; case T_USHORT: p->cb = cb_read_inus; break; case T_UINT: p->cb = cb_read_inui; break; case T_FLOAT: p->cb = cb_read_infl; break; case T_DOUBLE: p->cb = cb_read_indo; break; default: assert(0); } break; case T_UCHAR: //================== Lettura uchar switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_ucch; break; case T_SHORT: p->cb = cb_read_ucsh; break; case T_INT: p->cb = cb_read_ucin; break; case T_UCHAR: p->cb = cb_read_ucuc; break; case T_USHORT: p->cb = cb_read_ucus; break; case T_UINT: p->cb = cb_read_ucui; break; case T_FLOAT: p->cb = cb_read_ucfl; break; case T_DOUBLE: p->cb = cb_read_ucdo; break; default: assert(0); } break; case T_USHORT: //================== Lettura ushort switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_usch; break; case T_SHORT: p->cb = cb_read_ussh; break; case T_INT: p->cb = cb_read_usin; break; case T_UCHAR: p->cb = cb_read_usuc; break; case T_USHORT: p->cb = cb_read_usus; break; case T_UINT: p->cb = cb_read_usui; break; case T_FLOAT: p->cb = cb_read_usfl; break; case T_DOUBLE: p->cb = cb_read_usdo; break; default: assert(0); } break; case T_UINT: //================== Lettura uint switch(p->desc.memtype1) { case T_CHAR: p->cb = cb_read_uich; break; case T_SHORT: p->cb = cb_read_uish; break; case T_INT: p->cb = cb_read_uiin; break; case T_UCHAR: p->cb = cb_read_uiuc; break; case T_USHORT: p->cb = cb_read_uius; break; case T_UINT: p->cb = cb_read_uiui; break; case T_FLOAT: p->cb = cb_read_uifl; break; case T_DOUBLE: p->cb = cb_read_uido; break; default: assert(0); } break; case T_FLOAT: //================== Lettura float switch(p->desc.memtype1) { case T_FLOAT: p->cb = cb_read_flfl; break; case T_DOUBLE: p->cb = cb_read_fldo; break; default: assert(0); } break; case T_DOUBLE: //================== Lettura double switch(p->desc.memtype1) { case T_FLOAT: p->cb = cb_read_dofl; break; case T_DOUBLE: p->cb = cb_read_dodo; break; default: assert(0); } break; default: assert(0); } } else { switch(TypeSize[p->tipo]) { case 1: p->cb = cb_skip_bin1; break; case 2: p->cb = cb_skip_bin2; break; case 4: p->cb = cb_skip_bin4; break; case 8: p->cb = cb_skip_bin8; break; default:p->cb = 0; assert(0); break; } } } } } void PlyFile::compile( PlyElement * e ) { vector::iterator i; for(i=e->props.begin();i!=e->props.end();++i) compile(&*i); } // Funzioni statiche per la lettura di un elemento int ReadBin ( XFILE * fp, const PlyProperty * pr, void * mem, int fmt ) { assert(pr); // Lettura di una lista if(pr->islist) { int i,n; if( !ReadScalarB(fp,&n,pr->tipoindex, T_INT, fmt) ) return 0; assert(n<12); // Valore abbastanza aleatorio // Lettura con memorizzazione if(pr->bestored) { char * store; StoreInt( ((char *)mem)+pr->desc.offset2, pr->desc.memtype2, n); // Determinazione memoria vettore if(pr->desc.alloclist) { store = (char *)calloc(n,TypeSize[pr->desc.memtype1]); assert(store); *(char **)(((char *)mem)+pr->desc.offset1) = store; } else { store = ((char *)mem)+pr->desc.offset1; } for(i=0;idesc.memtype1], pr->desc.stotype1, pr->desc.memtype1, fmt ) ) return 0; } } // Lettura senza memorizzazione else { for(i=0;itipo) ) return 0; } } // Lettura di uno scalare else { // Lettura con memorizzazione if(pr->bestored) return ReadScalarB( fp, ((char *)mem)+pr->desc.offset1, pr->desc.stotype1, pr->desc.memtype1, fmt ); // Lettura senza memorizzazione else return SkipScalarB(fp,pr->tipo); } return 1; } int ReadAscii( XFILE * fp, const PlyProperty * pr, void * mem, int /*fmt*/ ) { assert(pr); assert(mem); // Lettura di una lista if(pr->islist) { int i,n; if( !ReadScalarA(fp,&n,pr->tipoindex, T_INT) ) return 0; assert(n<12); // Valore abbastanza aleatorio // Lettura con memorizzazione if(pr->bestored) { char * store; StoreInt( ((char *)mem)+pr->desc.offset2, pr->desc.memtype2, n); // Determinazione memoria vettore if(pr->desc.alloclist) { store = (char *)calloc(n,TypeSize[pr->desc.memtype1]); assert(store); *(char **)(((char *)mem)+pr->desc.offset1) = store; } else { store = ((char *)mem)+pr->desc.offset1; } for(i=0;idesc.memtype1], pr->desc.stotype1, pr->desc.memtype1 ) ) return 0; } } // Lettura senza memorizzazione else { for(i=0;itipo) ) return 0; } } // Lettura scalare else { // Lettura con memorizzazione if(pr->bestored) return ReadScalarA( fp, ((char *)mem)+pr->desc.offset1, pr->desc.stotype1, pr->desc.memtype1 ); // Lettura senza memorizzazione else return SkipScalarA(fp,pr->tipo); } return 1; } // Finally! the main function int PlyFile::Read( void * mem ) { assert(cure); assert(ReadCB); vector::iterator i; for(i=cure->props.begin();i!=cure->props.end();++i) { if( ! i->cb(gzfp,mem,&(i->desc)) ) return -1; /* int r = ReadCB(gzfp,i,mem,format); if(!r) return -1; */ } return 0; } void interpret_texture_name(const char*a, const char*fn, char*output){ int ia=0,io=0; output[0]=0; while (a[ia]!=0){ if (a[ia]=='<') { if (static_cast(strlen(a)) > ia+5) { if ( ( (a[ia+1]=='t') || (a[ia+1]=='T') ) && ( (a[ia+2]=='h') || (a[ia+2]=='H') ) && ( (a[ia+3]=='i') || (a[ia+3]=='I') ) && ( (a[ia+4]=='s') || (a[ia+4]=='S') ) && ( a[ia+5]=='>' ) ) { // substitute "" with filename: // 1) remove path from filename int lastbar=0; int ifn=0; while (fn[ifn]!=0) { if ((fn[ifn]=='/') || (fn[ifn]=='\\')) lastbar=ifn+1; ifn++;} ifn=lastbar; char fn2[255]; while (fn[ifn]!=0) { fn2[ifn-lastbar]=fn[ifn]; ifn++;} fn2[ifn-lastbar]=0; // 2) remove ".ply" extention from filename int l=ifn-lastbar; if ((fn2[l-4]=='.') && ((fn2[l-3]=='P') || (fn2[l-3]=='p')) && ((fn2[l-2]=='L') || (fn2[l-2]=='l')) && ((fn2[l-1]=='Y') || (fn2[l-1]=='y')) ) fn2[l-4]=0; // 3) append output[io]=0; sprintf(output,"%s%s",output,fn2); io=strlen(output); ia+=6; //skip the "" continue; }; } } output[io++]=a[ia++]; }; output[io]=0; }; } }