plylib.h

Go to the documentation of this file.

/****************************************************************************
* 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:
        const char * elemname;                  // Nome dell'elemento
        const 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.c_str(); }
protected:

        GZFILE gzfp;

        float  version;                         // Versione del file
        int    error;                           // Errore corrente (vedi enum)
        int    format;                          // Formato del file (vedi enum )

  std::string   header;                 // 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