manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
vcglib/wrap/ply/plylib.cpp

3679 lines
81 KiB
C++
Raw Blame History

/****************************************************************************
* 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 <assert.h>
#endif
#ifdef _MSC_VER
#pragma warning( disable : 4267 )
#endif
#ifdef WIN32
#include <direct.h>
#endif
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <assert.h>
#include <vector>
#include <algorithm>
#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 <zlib.h>
//#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(ti<T_MAXTYPE);
assert( t2>0 || (t2==0 && isl==0));
assert(t2<T_MAXTYPE);
props.push_back( PlyProperty (na,ti,isl,t2) );
}
PlyProperty * PlyElement::FindProp( const char * na )
{
assert(na);
vector<PlyProperty>::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.clear();
header.reserve(1536);
// ********* Parsing header ***********
// Controllo header
if( pb_fgets(buf,MAXB-1,gzfp)==0 )
{
error = E_UNESPECTEDEOF;
goto error;
}
header.append(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;
}
header.append(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;
}
header.append(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<PlyElement>::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;i<n;++i)
//if( !SkipScalarA(fp,T_INT) ) // Cambiato come segue il 12/2/03 altrimenti se trova un float lo salta. Invece se si chiede un float va sempre bene
if( !SkipScalarA(fp,T_FLOAT) )
return false;
return true;
}
// NON OTTIMIZZATA
static bool cb_read_list_ascii( GZFILE fp, void * mem, PropDescriptor * d )
{
int i,n;
if( ReadIntA(fp,&n)==0) return false;
// Lettura con memorizzazione
char * store;
StoreInt( ((char *)mem)+d->offset2, 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;i<n;++i)
{
if( !ReadScalarA(
fp,
store+i*TypeSize[d->memtype1],
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;i<n;++i)
if( pb_fread( store+i*sizeof(char),1,1,fp)==0 ) return false;
return true;
}
static bool cb_read_list_chsh( 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;i<n;++i)
{
char c;
if( pb_fread(&c,1,1,fp)==0) return false;
*(short *)(store+i*sizeof(short)) = short(c);
}
return true;
}
static bool cb_read_list_chin( 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;i<n;++i)
{
char c;
if( pb_fread(&c,1,1,fp)==0) return false;
*(int *)(store+i*sizeof(int)) = int(c);
}
return true;
}
static bool cb_read_list_chuc( 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;i<n;++i)
{
char c;
if( pb_fread(&c,1,1,fp)==0) return false;
*(uchar *)(store+i*sizeof(uchar)) = uchar(c);
}
return true;
}
static bool cb_read_list_chus( 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;i<n;++i)
{
char c;
if( pb_fread(&c,1,1,fp)==0) return false;
*(ushort *)(store+i*sizeof(ushort)) = ushort(c);
}
return true;
}
static bool cb_read_list_chui( 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;i<n;++i)
{
char c;
if( pb_fread(&c,1,1,fp)==0) return false;
*(uint *)(store+i*sizeof(uint)) = uint(c);
}
return true;
}
static bool cb_read_list_chfl( 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;i<n;++i)
{
char c;
if( pb_fread(&c,1,1,fp)==0) return false;
*(float *)(store+i*sizeof(float)) = float(c);
}
return true;
}
static bool cb_read_list_chdo( 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;i<n;++i)
{
char c;
if( pb_fread(&c,1,1,fp)==0) return false;
*(double *)(store+i*sizeof(float)) = double(c);
}
return true;
}
static bool cb_read_list_shch( 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;i<n;++i)
{
short c; if( ReadShortB(fp,&c,d->format)==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;i<n;++i)
{
short c; if( ReadShortB(fp,&c,d->format)==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;i<n;++i)
{
short c; if( ReadShortB(fp,&c,d->format)==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;i<n;++i)
{
short c; if( ReadShortB(fp,&c,d->format)==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;i<n;++i)
{
short c; if( ReadShortB(fp,&c,d->format)==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;i<n;++i)
{
short c; if( ReadShortB(fp,&c,d->format)==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;i<n;++i)
{
short c; if( ReadShortB(fp,&c,d->format)==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;i<n;++i)
{
short c; if( ReadShortB(fp,&c,d->format)==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;i<n;++i)
{
int c; if( ReadIntB(fp,&c,d->format)==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;i<n;++i)
{
int c; if( ReadIntB(fp,&c,d->format)==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;i<n;++i)
{
if( ReadIntB(fp,(int *)(store+i*sizeof(int)),d->format)==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;i<n;++i)
{
int c; if( ReadIntB(fp,&c,d->format)==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;i<n;++i)
{
int c; if( ReadIntB(fp,&c,d->format)==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;i<n;++i)
{
int c; if( ReadIntB(fp,&c,d->format)==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;i<n;++i)
{
int c; if( ReadIntB(fp,&c,d->format)==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;i<n;++i)
{
int c; if( ReadIntB(fp,&c,d->format)==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;i<n;++i)
{
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
*(char *)(store+i*sizeof(char)) = char(c);
}
return true;
}
static bool cb_read_list_ucsh( 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;i<n;++i)
{
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
*(short *)(store+i*sizeof(short)) = short(c);
}
return true;
}
static bool cb_read_list_ucin( 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;i<n;++i)
{
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
*(int *)(store+i*sizeof(int)) = int(c);
}
return true;
}
static bool cb_read_list_ucuc( 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;i<n;++i)
{
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
*(uchar *)(store+i*sizeof(uchar)) = uchar(c);
}
return true;
}
static bool cb_read_list_ucus( 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;i<n;++i)
{
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
*(ushort *)(store+i*sizeof(ushort)) = ushort(c);
}
return true;
}
static bool cb_read_list_ucui( 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;i<n;++i)
{
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
*(uint *)(store+i*sizeof(uint)) = uint(c);
}
return true;
}
static bool cb_read_list_ucfl( 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;i<n;++i)
{
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
*(float *)(store+i*sizeof(float)) = float(c);
}
return true;
}
static bool cb_read_list_ucdo( 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;i<n;++i)
{
uchar c; if( pb_fread(&c,1,1,fp)==0 ) return false;
*(double *)(store+i*sizeof(double)) = double(c);
}
return true;
}
static bool cb_read_list_usch( 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;i<n;++i)
{
ushort c; if( ReadUShortB(fp,&c,d->format)==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;i<n;++i)
{
ushort c; if( ReadUShortB(fp,&c,d->format)==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;i<n;++i)
{
ushort c; if( ReadUShortB(fp,&c,d->format)==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;i<n;++i)
{
ushort c; if( ReadUShortB(fp,&c,d->format)==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;i<n;++i)
{
ushort c; if( ReadUShortB(fp,&c,d->format)==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;i<n;++i)
{
ushort c; if( ReadUShortB(fp,&c,d->format)==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;i<n;++i)
{
ushort c; if( ReadUShortB(fp,&c,d->format)==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;i<n;++i)
{
ushort c; if( ReadUShortB(fp,&c,d->format)==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;i<n;++i)
{
uint c; if( ReadUIntB(fp,&c,d->format)==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;i<n;++i)
{
uint c; if( ReadUIntB(fp,&c,d->format)==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;i<n;++i)
{
uint c; if( ReadUIntB(fp,&c,d->format)==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;i<n;++i)
{
uint c; if( ReadUIntB(fp,&c,d->format)==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;i<n;++i)
{
uint c; if( ReadUIntB(fp,&c,d->format)==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;i<n;++i)
{
uint c; if( ReadUIntB(fp,&c,d->format)==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;i<n;++i)
{
uint c; if( ReadUIntB(fp,&c,d->format)==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;i<n;++i)
{
uint c; if( ReadUIntB(fp,&c,d->format)==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;i<n;++i)
{
float c; if( ReadFloatB(fp,&c,d->format)==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;i<n;++i)
{
float c; if( ReadFloatB(fp,&c,d->format)==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;i<n;++i)
{
double c; if( ReadDoubleB(fp,&c,d->format)==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;i<n;++i)
{
double c; if( ReadDoubleB(fp,&c,d->format)==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<PlyProperty>::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;i<n;++i)
{
if( !ReadScalarB(
fp,
store+i*TypeSize[pr->desc.memtype1],
pr->desc.stotype1,
pr->desc.memtype1,
fmt
) )
return 0;
}
}
// Lettura senza memorizzazione
else
{
for(i=0;i<n;i++)
if( !SkipScalarB(fp,pr->tipo) )
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;i<n;++i)
{
if( !ReadScalarA(
fp,
store+i*TypeSize[pr->desc.memtype1],
pr->desc.stotype1,
pr->desc.memtype1
) )
return 0;
}
}
// Lettura senza memorizzazione
else
{
for(i=0;i<n;++i)
if( !SkipScalarA(fp,pr->tipo) )
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<PlyProperty>::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<int>(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 "<this>" 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 "<this>"
continue;
};
}
}
output[io++]=a[ia++];
};
output[io]=0;
};
}
}
Reference in New Issue View Git Blame Copy Permalink