332 lines
8.7 KiB
C++
332 lines
8.7 KiB
C++
/****************************************************************************
|
|
* 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.5 2005/11/26 00:12:25 cignoni
|
|
added prototype of interpret_texture_name
|
|
|
|
Revision 1.4 2005/11/12 07:07:47 cignoni
|
|
Changed Offset types to remove warnings
|
|
|
|
Revision 1.3 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.2 2004/04/27 13:29:19 turini
|
|
*** empty log message ***
|
|
|
|
Revision 1.1 2004/03/03 15:00:51 cignoni
|
|
Initial commit
|
|
|
|
****************************************************************************/
|
|
|
|
#ifndef __VCG_PLYLIB
|
|
#define __VCG_PLYLIB
|
|
|
|
#include <memory.h>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <assert.h>
|
|
|
|
namespace vcg {
|
|
namespace ply {
|
|
|
|
// Data types supported by the ply format
|
|
enum PlyTypes {
|
|
T_NOTYPE,
|
|
T_CHAR,
|
|
T_SHORT,
|
|
T_INT,
|
|
T_UCHAR,
|
|
T_USHORT,
|
|
T_UINT,
|
|
T_FLOAT,
|
|
T_DOUBLE,
|
|
T_MAXTYPE
|
|
};
|
|
|
|
// Error codes reported by GetError
|
|
enum PlyError {
|
|
E_NOERROR, // 0
|
|
// Errors of open(..)
|
|
E_CANTOPEN, // 1
|
|
E_NOTHEADER, // 2
|
|
E_UNESPECTEDEOF, // 3
|
|
E_NOFORMAT, // 4
|
|
E_SYNTAX, // 5
|
|
E_PROPOUTOFELEMENT, // 6
|
|
E_BADTYPENAME, // 7
|
|
// Errors of addtoread(..)
|
|
E_ELEMNOTFOUND, // 8
|
|
E_PROPNOTFOUND, // 9
|
|
E_BADTYPE, // 10
|
|
E_INCOMPATIBLETYPE, // 11
|
|
E_BADCAST, // 12
|
|
E_MAXPLYERRORS
|
|
};
|
|
|
|
// file formats supported by the ply format
|
|
enum PlyFormat {
|
|
F_UNSPECIFIED,
|
|
F_ASCII,
|
|
F_BINLITTLE,
|
|
F_BINBIG
|
|
};
|
|
|
|
|
|
#ifdef USE_ZLIB
|
|
typedef void * GZFILE;
|
|
#else
|
|
typedef FILE * GZFILE;
|
|
#endif
|
|
|
|
|
|
// Messaggio di errore
|
|
//extern const char * ply_error_msg[];
|
|
|
|
// TIPO FILE
|
|
|
|
|
|
// Descrittore esterno di propieta'
|
|
class PropDescriptor
|
|
{
|
|
public:
|
|
char * elemname; // Nome dell'elemento
|
|
char * propname; // Nome della propieta'
|
|
int stotype1; // Tipo dell'elemento su file (se lista tipo degli elementi della lista)
|
|
int memtype1; // Tipo dell'elemento in memoria (se lista tipo degli elementi della lista)
|
|
size_t offset1; // Offset del valore in memoria
|
|
int islist; // 1 se lista, 0 altrimenti
|
|
int alloclist; // 1 se alloca lista, 0 se preallocata
|
|
int stotype2; // Tipo del numero di elementi della lista su file
|
|
int memtype2; // Tipo del numero di elementi della lista in memoria
|
|
size_t offset2; // Offset valore memoria
|
|
|
|
int format; // duplicazione del formato
|
|
|
|
size_t stotypesize() const; // per sapere quanto e'grande un dato descrittore sul file
|
|
size_t memtypesize() const; // per sapere quanto e'grande un dato descrittore in memoria
|
|
const char *memtypename() const;
|
|
const char *stotypename() const;
|
|
};
|
|
|
|
// Reading Callback (used to copy a data prop)
|
|
typedef bool (* readelemcb) ( GZFILE fp, void * mem, PropDescriptor * p );
|
|
|
|
class PlyProperty
|
|
{
|
|
public:
|
|
inline PlyProperty()
|
|
{
|
|
tipo = 0;
|
|
islist = 0;
|
|
tipoindex = 0;
|
|
bestored = 0;
|
|
}
|
|
|
|
inline PlyProperty( 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);
|
|
|
|
name = std::string(na);
|
|
tipo = ti;
|
|
islist = isl;
|
|
tipoindex = t2;
|
|
bestored = 0;
|
|
}
|
|
|
|
std::string name; // Nome della propieta'
|
|
int tipo; // Tipo di dato
|
|
int islist; // Vero se e' una lista
|
|
int tipoindex; // Tipo del contatore della lista
|
|
|
|
int bestored; // 1 se va storata
|
|
PropDescriptor desc; // Descrittore di memorizzazione
|
|
|
|
readelemcb cb; // Callback di lettura
|
|
};
|
|
|
|
|
|
class PlyElement
|
|
{
|
|
public:
|
|
|
|
inline PlyElement()
|
|
{
|
|
number = 0;
|
|
}
|
|
|
|
inline PlyElement( const char * na, int nu )
|
|
{
|
|
assert(na);
|
|
assert(nu>=0);
|
|
|
|
name = std::string(na);
|
|
number = nu;
|
|
}
|
|
|
|
|
|
inline void SetName( const char * na )
|
|
{
|
|
name = std::string(na);
|
|
}
|
|
|
|
inline void SetNumbert( int nu )
|
|
{
|
|
assert(nu>0);
|
|
number = nu;
|
|
}
|
|
|
|
void AddProp( const char * na, int ti, int isl, int t2 );
|
|
|
|
int 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
|
|
|
|
PlyProperty * FindProp( const char * name );
|
|
|
|
std::string name; // Nome dell'elemento
|
|
int number; // Numero di elementi di questo tipo
|
|
|
|
std::vector<PlyProperty> props; // Vettore dinamico delle property
|
|
};
|
|
|
|
|
|
class PlyFile
|
|
{
|
|
private:
|
|
void compile( PlyElement * e );
|
|
void compile( PlyProperty * p );
|
|
|
|
public:
|
|
// Modi di apertura
|
|
enum {
|
|
MODE_READ,
|
|
MODE_WRITE
|
|
};
|
|
|
|
PlyFile();
|
|
~PlyFile();
|
|
|
|
// Apre un file ply
|
|
int Open( const char * filename, int mode );
|
|
// Chiude un file e disalloca la memoria
|
|
void Destroy();
|
|
// Ritorna il codice dell'ultimo errore
|
|
inline int GetError() const { return error; }
|
|
// Definizione di lettura (Vedi struttura PropDescriptor)
|
|
int 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
|
|
);
|
|
// Come sopra ma con descrittore
|
|
inline int AddToRead( const PropDescriptor & p )
|
|
{
|
|
return AddToRead(p.elemname,p.propname,p.stotype1,
|
|
p.memtype1,p.offset1,p.islist,p.alloclist,p.stotype2,
|
|
p.memtype2,p.offset2
|
|
);
|
|
}
|
|
|
|
// Ritorna il numero di oggetti di un tipo di elemento
|
|
const char * ElemName( int i );
|
|
|
|
int ElemNumber( int i ) const;
|
|
// Setta il tipo di elemento corrente per effetture
|
|
// la lettura
|
|
inline void SetCurElement( int i )
|
|
{
|
|
if(i<0 || i>=int(elements.size())) cure = 0;
|
|
else
|
|
{
|
|
cure = &(elements[i]);
|
|
compile(cure);
|
|
}
|
|
}
|
|
// Lettura du un elemento
|
|
int Read( void * mem );
|
|
|
|
std::vector<PlyElement> elements; // Vettore degli elementi
|
|
std::vector<std::string> comments; // Vettore dei commenti
|
|
static const char * typenames[9];
|
|
static const char * newtypenames[9];
|
|
|
|
inline const char * GetHeader() const { return header; }
|
|
protected:
|
|
|
|
GZFILE gzfp;
|
|
|
|
float version; // Versione del file
|
|
int error; // Errore corrente (vedi enum)
|
|
int format; // Formato del file (vedi enum )
|
|
|
|
char header[4096]; // Testo dell'header
|
|
|
|
PlyElement * cure; // Elemento da leggere
|
|
|
|
// Callback di lettura: vale ReadBin o ReadAcii
|
|
int (* ReadCB)( GZFILE fp, const PlyProperty * r, void * mem, int fmt );
|
|
|
|
int OpenRead( const char * filename );
|
|
int OpenWrite( const char * filename );
|
|
|
|
PlyElement * AddElement( const char * name, int number );
|
|
int FindType( const char * name ) const;
|
|
PlyElement * FindElement( const char * name );
|
|
};
|
|
|
|
void interpret_texture_name(const char*a, const char*fn, char*output);
|
|
|
|
} // end namespace ply
|
|
} // end namespace vcg
|
|
#endif
|