TAPsReadPly.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsReadPly.cpp

Create an OpenGL Model Object from a .ply file

SUKITTI PUNAK   (05/24/2006)
UPDATE          (06/01/2006)
******************************************************************************/
#include "TAPsReadPly.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
//-------------------------------------------------------------------
template <typename T>
unsigned char   ReadPly<T>::m_eFormat = UNDEFINED;
template <typename T>
float           ReadPly<T>::m_fFormatVersion = 0.0f;
template <typename T>
unsigned char   ReadPly<T>::m_eCurrentListType = UNDEFINED;
//-------------------------------------------------------------------
template <typename T>
std::vector<unsigned char>  ReadPly<T>::m_veVertexListType;
template <typename T>
std::vector<unsigned char>  ReadPly<T>::m_veVertexListAttrib;
//-------------------------------------------------------------------
template <typename T>
std::vector<unsigned char>  ReadPly<T>::m_veFaceListType;
template <typename T>
std::vector<unsigned char>  ReadPly<T>::m_veFaceListAttrib;
//-------------------------------------------------------------------
template <typename T>
std::vector<unsigned char>  ReadPly<T>::m_veEdgeListType;
template <typename T>
std::vector<unsigned char>  ReadPly<T>::m_veEdgeListAttrib;
//-------------------------------------------------------------------
template <typename T>   int ReadPly<T>::halfEdgeCounter = 0;
template <typename T>   int ReadPly<T>::vertexNo = 0;
/*
template <typename T>
HEVertex<T> ** ReadPly<T>::vertexList = NULL;
template <typename T>
HashTableBySTLVector<int> * ReadPly<T>::vertexRingList = NULL;
template <typename T>
HashTableBySTLVector< HEHalfEdge<T>* > * ReadPly<T>::halfEdgeRingList = NULL;
template <typename T>
HEHalfEdge<T> * ReadPly<T>::boundaryHalfEdgePtr = NULL;
//*/
//=============================================================================
//-----------------------------------------------------------------------------
// Read an input file
template <typename T>
bool ReadPly<T>::readFile ( 
    const char *fileName, OpenGL::PolygonalModel<T> * const prModel )
{
    Clear();
    //----------------------------------------------------------------
    // Open the input file
    FILE * fileIn = fopen( fileName, "rb" );
    if ( !fileIn ) {
        std::perror( fileName );
        return false;
    }
    //----------------------------------------------------------------
#ifdef  TAPs_DEBUG_MODE
    std::cout << "START READING " << fileName << "\n";
#endif
    //----------------------------------------------------------------
    if ( ProcessHEADER( fileIn, prModel ) == false )    return false;
    if      ( FORMAT_ASCII == m_eFormat ) {
        if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_ASCII( fileIn, prModel );
        if ( prModel->GetNoFaces() > 0 )    ProcessFACE_LIST_ASCII( fileIn, prModel );
    }
    else if ( FORMAT_BINARY_BIG_ENDDIAN == m_eFormat ) {
        if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel );
        if ( prModel->GetNoFaces() > 0 )    ProcessFACE_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel );
    }
    else if ( FORMAT_BINARY_LITTLE_ENDDIAN == m_eFormat ) {
        if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel );
        if ( prModel->GetNoFaces() > 0 )    ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel );
    }
    //----------------------------------------------------------------
    fclose(fileIn);
#ifdef  TAPs_DEBUG_MODE
    std::cout << "END READING " << fileName << "\n";
#endif
    prModel->GetMaterial()->ApplyMaterial();
    return true;
}
//-----------------------------------------------------------------------------
// Read an input file
template <typename T>
bool ReadPly<T>::readFile ( 
    const char *fileName, OpenGL::XPolygonalModel<T> * const prModel )
{
    Clear();
    //----------------------------------------------------------------
    // Open the input file
    FILE * fileIn = fopen( fileName, "rb" );
    if ( !fileIn ) {
        std::perror( fileName );
        return false;
    }
    //----------------------------------------------------------------
#ifdef  TAPs_DEBUG_MODE
    std::cout << "START READING " << fileName << "\n";
#endif
    //----------------------------------------------------------------
    if ( ProcessHEADER( fileIn, prModel ) == false )    return false;
    if      ( FORMAT_ASCII == m_eFormat ) {
        if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_ASCII( fileIn, prModel );
        if ( prModel->GetNoFaces() > 0 )    ProcessFACE_LIST_ASCII( fileIn, prModel );
    }
    else if ( FORMAT_BINARY_BIG_ENDDIAN == m_eFormat ) {
        if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel );
        if ( prModel->GetNoFaces() > 0 )    ProcessFACE_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel );
    }
    else if ( FORMAT_BINARY_LITTLE_ENDDIAN == m_eFormat ) {
        if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel );
        if ( prModel->GetNoFaces() > 0 )    ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel );
    }
    //----------------------------------------------------------------
    fclose(fileIn);
#ifdef  TAPs_DEBUG_MODE
    std::cout << "END READING " << fileName << "\n";
#endif
    prModel->GetMaterial()->ApplyMaterial();
    return true;
}
//-----------------------------------------------------------------------------
// Read an input file
template <typename T>
bool ReadPly<T>::readFile ( 
    const char *fileName, OpenGL::HalfEdgeModel<T> * const prModel )
{
    Clear();
    //----------------------------------------------------------------
    // Initialization
    halfEdgeCounter = 0;
    vertexNo = 0;
    //----------------------------------------------------------------
    // Open the input file
    FILE * fileIn = fopen( fileName, "rb" );
    if ( !fileIn ) {
        std::perror( fileName );
        return false;
    }
    //----------------------------------------------------------------
#ifdef  TAPs_DEBUG_MODE
    std::cout << "START READING " << fileName << "\n";
#endif
    //----------------------------------------------------------------
    if ( ProcessHEADER( fileIn, prModel ) == false )    return false;
    if      ( FORMAT_ASCII == m_eFormat ) {
        if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_ASCII( fileIn, prModel );
        if ( prModel->GetNoFaces() > 0 )    ProcessFACE_LIST_ASCII( fileIn, prModel );
    }
    else if ( FORMAT_BINARY_BIG_ENDDIAN == m_eFormat ) {
        if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel );
        if ( prModel->GetNoFaces() > 0 )    ProcessFACE_LIST_BINARY_BIG_ENDDIAN( fileIn, prModel );
    }
    else if ( FORMAT_BINARY_LITTLE_ENDDIAN == m_eFormat ) {
        if ( prModel->GetNoVertices() > 0 ) ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel );
        if ( prModel->GetNoFaces() > 0 )    ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN( fileIn, prModel );
    }
    //----------------------------------------------------------------
    fclose(fileIn);
    //----------------------------------------------------------------
    HelpCreateHalfEdgeModel<T>::CreateHalfEdgeModel( prModel );
    //----------------------------------------------------------------
#ifdef  TAPs_DEBUG_MODE
    std::cout << "END READING " << fileName << "\n";
    std::cout << "Number of Half-Edges: " << halfEdgeCounter << "\n";
#endif
    prModel->GetMaterial()->ApplyMaterial();
    return true;
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Clear History / Refresh
template <typename T>
void ReadPly<T>::Clear () 
{
    m_eFormat           = UNDEFINED;
    m_fFormatVersion    = 0.0;
    m_eCurrentListType  = UNDEFINED;
    //-----------------------------------------------------
    m_veVertexListType.clear();
    m_veVertexListAttrib.clear();
    m_veFaceListType.clear();
    m_veFaceListAttrib.clear();
    m_veEdgeListType.clear();
    m_veEdgeListAttrib.clear();
    //-----------------------------------------------------
    halfEdgeCounter = 0;
    vertexNo = 0;
    HelpCreateHalfEdgeModel<T>::vertexList = NULL;
    HelpCreateHalfEdgeModel<T>::vertexRingList = NULL;
    HelpCreateHalfEdgeModel<T>::halfEdgeRingList = NULL;
    HelpCreateHalfEdgeModel<T>::boundaryHalfEdgePtr = NULL;
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Process HEADER
template <typename T>
bool ReadPly<T>::ProcessHEADER ( 
    FILE * inputFile, OpenGL::MeshModel<T> * const prModel )
{
    //---------------------------------------------------------------
    //m_iNumOfVertices = 0;
    //m_iNumOfFaces    = 0;
    //---------------------------------------------------------------
    char line[256];
    char node[128];
//  while ( !feof(fileIn) ) {
    do {
        fgets( line, 256, inputFile );  // read the first line
    } while ( strlen( line ) < 3 || line[0] == '#' );
    sscanf( line, "%s", node );
    //-------------------------------------------
    // Check for ply format
    if ( strncmp( node, "ply", strlen("ply") ) ) {
        return false;
    }
    //-------------------------------------------
    bool bKeepRunning = true;
    while ( bKeepRunning ) {
        do {
            fgets( line, 256, inputFile );  // read the next line
        } while ( strlen( line ) < 3 || line[0] == '#' );
        sscanf( line, "%s", node );
        if      ( !strncmp( node, "property", strlen("property") ) ) {
            ProcessPROPERTY( line );
        }
        else if ( !strncmp( node, "element", strlen("element") ) ) {
            ProcessELEMENT( line, prModel );
        }
        else if ( !strncmp( node, "end_header", strlen("end_header") ) ) {
            bKeepRunning = false;
        }
        else if ( !strncmp( node, "format", strlen("format") ) ) {
            if ( !ProcessFORMAT( line ) ) {
                return false;
            }
        }
    }
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Number of Vertices: " << prModel->GetNoVertices() << "\n";
    std::cout << "Number of Faces:    " << prModel->GetNoFaces() << "\n";
#endif
#ifdef  TAPs_DEBUG_MODE_DETAIL_1
    std::cout << "\nVertex Prop:\n";
    for ( int i = 0; i < static_cast<int>( m_veVertexListType.size() ); ++i ) {
        std::cout << "\t" << static_cast<int>( m_veVertexListType[i] );
    }
    std::cout << "\n";
    for ( int i = 0; i < static_cast<int>( m_veVertexListAttrib.size() ); ++i ) {
        std::cout << "\t" << static_cast<int>( m_veVertexListAttrib[i] );
    }
    std::cout << "\nFace Prop:\n";
    for ( int i = 0; i < static_cast<int>( m_veFaceListType.size() ); ++i ) {
        std::cout << "\t" << static_cast<int>( m_veFaceListType[i] );
    }
    std::cout << "\n";
    for ( int i = 0; i < static_cast<int>( m_veFaceListAttrib.size() ); ++i ) {
        std::cout << "\t" << static_cast<int>( m_veFaceListAttrib[i] );
    }
    std::cout << "\nEdge Prop:\n";
    for ( int i = 0; i < static_cast<int>( m_veEdgeListType.size() ); ++i ) {
        std::cout << "\t" << static_cast<int>( m_veEdgeListType[i] );
    }
    std::cout << "\n";
    for ( int i = 0; i < static_cast<int>( m_veEdgeListAttrib.size() ); ++i ) {
        std::cout << "\t" << static_cast<int>( m_veEdgeListAttrib[i] );
    }
#endif
    return true;
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Process FORMAT
template <typename T>
bool ReadPly<T>::ProcessFORMAT ( char * line )
{
    //---------------------------------------------------------------
    char *delimiters = "\t ";
    char *token = NULL;
    char *end;
// Example on using string token
//  token = strtok( line, delimiters );     // start
//  token = strtok( '\0', delimiters );     // next
//  token = strtok( NULL, delimiters );     // next
//  while ( token != NULL ) { ... }         // not reach the end yet
//  numberOfVertices = static_cast<int>( strtol( token, &end, 10 ) );
    //---------------------------------------------------------------
    token = strtok( line, delimiters );     // "format"
    token = strtok( '\0', delimiters );     // format type
    if      ( !strncmp( token, "ascii", strlen("ascii") ) ) {
        m_eFormat = FORMAT_ASCII;
#ifdef  TAPs_DEBUG_MODE_DETAIL_1
        std::cout << "Format: ASCII\n";
#endif
    }
    else if ( !strncmp( token, "binary_big_endian", strlen("binary_big_endian") ) ) {
        m_eFormat = FORMAT_BINARY_BIG_ENDDIAN;
#ifdef  TAPs_DEBUG_MODE_DETAIL_1
        std::cout << "Format: Binary Big Enddian\n";
#endif
    }
    else if ( !strncmp( token, "binary_little_endian", strlen("binary_little_endian") ) ) {
        m_eFormat = FORMAT_BINARY_LITTLE_ENDDIAN;
#ifdef  TAPs_DEBUG_MODE_DETAIL_1
        std::cout << "Format: Binary Little Enddian\n";
#endif
    }
    else {
#ifdef  TAPs_DEBUG_MODE
        std::cout << "Ply \"" << token << "\" format is unrecognizable!" << std::endl;
        return false;
#endif
    }
    //---------------------------------------------------------------
    token = strtok( '\0', delimiters ); // format version
    if ( token != NULL ) {
        m_fFormatVersion = static_cast<int>( strtol( token, &end, 10 ) );
    }
    //---------------------------------------------------------------
    return true;
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Process ELEMENT
template <typename T>
void ReadPly<T>::ProcessELEMENT ( 
    char * line, OpenGL::MeshModel<T> * const prModel )
{
    //---------------------------------------------------------------
    char *delimiters = "\t ";
    char *token = NULL;
    char *end;
    //---------------------------------------------------------------
    token = strtok( line, delimiters );     // "element"
    token = strtok( '\0', delimiters );     // type of element
    if      ( !strncmp( token, "vertex", strlen("vertex") ) ) {
        token = strtok( '\0', delimiters ); // # of vertices
        prModel->SetNoVertices( static_cast<int>( strtol( token, &end, 10 ) ) );
        m_eCurrentListType = ELEMENT_VERTEX;
    }
    else if ( !strncmp( token, "face", strlen("face") ) ) {
        token = strtok( '\0', delimiters ); // # of faces
        prModel->SetNoFaces( static_cast<int>( strtol( token, &end, 10 ) ) );
        m_eCurrentListType = ELEMENT_FACE;
    }
    else if ( !strncmp( token, "edge", strlen("edge") ) ) {
        token = strtok( '\0', delimiters ); // # of faces
        // prModel doesn't support edge list
        //prModel->SetNoFaces( static_cast<int>( strtol( token, &end, 10 ) ) );
        m_eCurrentListType = ELEMENT_EDGE;
    }
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Process ELEMENT
template <typename T>
void ReadPly<T>::ProcessPROPERTY ( char * line )
{
    int bListForFace = 0;                               // for face
    unsigned char dataType_0 = UNDEFINED;       // for face
    unsigned char dataType   = UNDEFINED;
    unsigned char attribute  = UNDEFINED;
    //---------------------------------------------------------------
    char *delimiters = "\t\n ";
    char *token = NULL;
    //char *end;
    //---------------------------------------------------------------
    token = strtok( line, delimiters );     // "property"
    //---------------------------------------------------------------
    token = strtok( '\0', delimiters );
    do {
        //std::cout << "\t" << token;
        //-------------------------------------------------
        // Data Type
        if      ( !strcmp( token, "int8" ) ) {
            dataType = INT_8;
        }
        else if ( !strcmp( token, "uint8" ) 
               || !strcmp( token, "uchar" ) ) {
            dataType = UINT_8;
        }
        else if ( !strcmp( token, "int16" ) ) {
            dataType = INT_16;
        }
        else if ( !strcmp( token, "uint16" ) ) {
            dataType = UINT_16;
        }
        else if ( !strcmp( token, "int32" ) 
               || !strcmp( token, "int" ) ) {
            dataType = INT_32;
        }
        else if ( !strcmp( token, "uint32" ) ) {
            dataType = UINT_32;
        }
        else if ( !strcmp( token, "float32" ) 
               || !strcmp( token, "float" ) ) {
            dataType = FLOAT_32;
        }
        else if ( !strcmp( token, "float64" ) 
               || !strcmp( token, "double" ) ) {
            dataType = FLOAT_64;
        }
        //-------------------------------------------------
        // Attribute
        else if ( !strcmp( token, "x" ) ) {
            attribute = X;
        }
        else if ( !strcmp( token, "y" ) ) {
            attribute = Y;
        }
        else if ( !strcmp( token, "z" ) ) {
            attribute = Z;
        }
        else if ( !strcmp( token, "red" ) ) {
            attribute = RED;
        }
        else if ( !strcmp( token, "green" ) ) {
            attribute = GREEN;
        }
        else if ( !strcmp( token, "blue" ) ) {
            attribute = BLUE;
        }
        else if ( !strcmp( token, "confidence" ) ) {
            attribute = CONFIDENCE;
        }
        else if ( !strcmp( token, "intensity" ) ) {
            attribute = INTENSITY;
        }
        else if ( !strcmp( token, "vertex1" ) ) {
            attribute = VERTEX1;
        }
        else if ( !strcmp( token, "vertex2" ) ) {
            attribute = VERTEX2;
        }
        //-------------------------------------------------
        // List
        else if ( !strcmp( token, "list" ) ) {
            if ( m_eCurrentListType == ELEMENT_FACE ) {
                bListForFace = 2;
            }
            token = strtok( '\0', delimiters );
            continue;
        }
        else if ( !strcmp( token, "vertex_indices" ) ) {
            attribute = LIST_VERTEX_INDICES;
        }
        //-------------------------------------------------
        // For Face List
        if ( bListForFace == 2 )    {
            dataType_0 = dataType;
            bListForFace = 1;
        }
        //-------------------------------------------------
        token = strtok( '\0', delimiters );
    } while ( token != NULL );
    //---------------------------------------------------------------
    if      ( m_eCurrentListType == ELEMENT_VERTEX ) {
        m_veVertexListType.push_back( dataType );
        m_veVertexListAttrib.push_back( attribute );
    }
    // Since an element can be declared after "element face #ofFaces",
    // this element belongs to face element.
    // For face element "property list dataType_0 dataType vertex_indices",
    // they are put back into m_veFaceListType and Attrib by 
    // the ProcessPROPERTY fn
    else if ( m_eCurrentListType == ELEMENT_FACE ) {
        if ( bListForFace == 1 ) {
            m_veFaceListType.push_back( dataType_0 );
            m_veFaceListType.push_back( dataType );
            m_veFaceListAttrib.push_back( attribute );
            m_veFaceListAttrib.push_back( 0 );
            // push 0 for dummy value
        }
        else {
            m_veFaceListType.push_back( dataType );
            m_veFaceListAttrib.push_back( attribute );
        }
        bListForFace = 0;
    }
    else if ( m_eCurrentListType == ELEMENT_EDGE ) {
        m_veEdgeListType.push_back( dataType );
        m_veEdgeListAttrib.push_back( attribute );
    }
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Process VERTEX LIST ASCII
template <typename T>
void ReadPly<T>::ProcessVERTEX_LIST_ASCII ( 
    FILE * inputFile, OpenGL::PolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing VERTEX LIST\n";
#endif
    //-------------------------------------------------------------------
    // Example: x y z values
    //   0 0 0
    //   ...
    //   0 0 1
    //-------------------------------------------------------------------
    char vertexStr[128];
    int vertexNumber = 0;
    float x, y, z;      // since sscanf does not work for T (template)
    //-------------------------------------------------------------------
    prModel->NewVertexListByNoVertices();
    do {
        do {
            fgets( vertexStr, 128, inputFile );
        } while ( strlen( vertexStr ) < 3 || vertexStr[0] == '#' );
        sscanf( vertexStr, "%g %g %g", &x, &y, &z );
        prModel->GetVertexList()[vertexNumber][0] = x;
        prModel->GetVertexList()[vertexNumber][1] = y;
        prModel->GetVertexList()[vertexNumber][2] = z;
        ++vertexNumber;
    } while ( vertexNumber < prModel->GetNoVertices() );
}
//-----------------------------------------------------------------------------
// Process VERTEX LIST ASCII
template <typename T>
void ReadPly<T>::ProcessVERTEX_LIST_ASCII ( 
    FILE * inputFile, OpenGL::XPolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing VERTEX LIST\n";
#endif
    //-------------------------------------------------------------------
    // Example: x y z values
    //   0 0 0
    //   ...
    //   0 0 1
    //-------------------------------------------------------------------
    char vertexStr[128];
    int vertexNumber = 0;
    float x, y, z;      // since sscanf does not work for T (template)
    //-------------------------------------------------------------------
    prModel->NewVertexListByNoVertices();
    do {
        do {
            fgets( vertexStr, 128, inputFile );
        } while ( strlen( vertexStr ) < 3 || vertexStr[0] == '#' );
        sscanf( vertexStr, "%g %g %g", &x, &y, &z );
        prModel->GetVertexList()[vertexNumber][0] = x;
        prModel->GetVertexList()[vertexNumber][1] = y;
        prModel->GetVertexList()[vertexNumber][2] = z;
        ++vertexNumber;
    } while ( vertexNumber < prModel->GetNoVertices() );
}
//-----------------------------------------------------------------------------
// Process VERTEX LIST ASCII
template <typename T>
void ReadPly<T>::ProcessVERTEX_LIST_ASCII ( 
    FILE * inputFile, OpenGL::HalfEdgeModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing VERTEX LIST\n";
#endif
    //-------------------------------------------------------------------
    // Example:
    //  *MESH_VERTEX_LIST {
    //      *MESH_VERTEX    0   -10.000000  -5.000000   0.000000
    //      *MESH_VERTEX    1   10.000000   -5.000000   0.000000
    //      *MESH_VERTEX    2   -10.000000  5.000000    0.000000
    //      ...
    //  }
    //-------------------------------------------------------------------
    char node[128];
    int n;
    float x, y, z;
    fgets( line, 128, inputFile );
    sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z );
    while ( node[0] != '}' ) {
        //------------------------------------------------------
        // Put created vertex in vertexList for look up later
        HelpCreateHalfEdgeModel<T>::vertexList[vertexNo] = new HEVertex<T>( x, y, z );
        // Put created vertex in vertexList of the model
        prModel->GetVertexList()->Append( HelpCreateHalfEdgeModel<T>::vertexList[vertexNo] );
        ++vertexNo; // next vertex#
        //std::cout << "Vertex: " << vertexNo << "\n";
        //------------------------------------------------------
        fgets( line, 128, fileIn );
        sscanf( line, "%s %d %g %g %g", node, &n, &x, &y, &z );
    }
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Process FACE LIST ASCII
template <typename T>
void ReadPly<T>::ProcessFACE_LIST_ASCII ( 
    FILE * inputFile, OpenGL::PolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing FACE LIST\n";
#endif
    //---------------------------------------------------------------
    // Example:  number of vertices for this face followed by vertex numbers
    //   4 0  1  2  3
    //   ...
    //   3 10 11 12
    //---------------------------------------------------------------
    char line[128];
    char *delimiters = "\t ";
    char *token = NULL;
    char *end;
    int numberOfVertices;
    int vertexNo;
    int faceNo = 0;
    //---------------------------------------------------------------
    prModel->NewFaceListByNoFaces();
    do {
        do {
            fgets( line, 128, inputFile );
        } while ( strlen( line ) < 3 || line[0] == '#' );
        token = strtok( line, delimiters );     // number of vertices
        numberOfVertices = static_cast<int>( strtol( token, &end, 10 ) );
        prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices );
        for ( int i = 0; i < numberOfVertices; ++i ) {
            token = strtok( '\0', delimiters ); // vertex number
            vertexNo = static_cast<int>( strtol( token, &end, 10 ) );
            prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo );
        }
        ++faceNo;
    } while ( faceNo < prModel->GetNoFaces() );
    //---------------------------------------------------------------
}
//-----------------------------------------------------------------------------
// Process FACE LIST ASCII
template <typename T>
void ReadPly<T>::ProcessFACE_LIST_ASCII ( 
    FILE * inputFile, OpenGL::XPolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing FACE LIST\n";
#endif
    //---------------------------------------------------------------
    // Example:  number of vertices for this face followed by vertex numbers
    //   4 0  1  2  3
    //   ...
    //   3 10 11 12
    //---------------------------------------------------------------
    char line[128];
    char *delimiters = "\t ";
    char *token = NULL;
    char *end;
    int numberOfVertices;
    int vertexNo;
    int faceNo = 0;
    //---------------------------------------------------------------
    prModel->NewFaceListByNoFaces();
    do {
        do {
            fgets( line, 128, inputFile );
        } while ( strlen( line ) < 3 || line[0] == '#' );
        token = strtok( line, delimiters );     // number of vertices
        numberOfVertices = static_cast<int>( strtol( token, &end, 10 ) );
        prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices );
        for ( int i = 0; i < numberOfVertices; ++i ) {
            token = strtok( '\0', delimiters ); // vertex number
            vertexNo = static_cast<int>( strtol( token, &end, 10 ) );
            prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo );
        }
        ++faceNo;
    } while ( faceNo < prModel->GetNoFaces() );
    //---------------------------------------------------------------
}
//-----------------------------------------------------------------------------
// Process FACE LIST ASCII
template <typename T>
void ReadPly<T>::ProcessFACE_LIST_ASCII ( 
    FILE * inputFile, OpenGL::HalfEdgeModel<T> * const prModel )
{
    std::cout << "Processing Node MESH_FACE_LIST\n";
    //-------------------------------------------------------------------
    // Example:
    //  *MESH_FACE_LIST {
    //      *MESH_FACE    0:    A:    0 B:    2 C:    3 AB:    1 BC:    1 CA:    0   *MESH_SMOOTHING 2  *MESH_MTLID 1
    //      *MESH_FACE    1:    A:    3 B:    1 C:    0 AB:    1 BC:    1 CA:    0   *MESH_SMOOTHING 2  *MESH_MTLID 1
    //      *MESH_FACE    2:    A:    4 B:    5 C:    7 AB:    1 BC:    1 CA:    0   *MESH_SMOOTHING 3  *MESH_MTLID 0
    //      ...
    //  }
    //-------------------------------------------------------------------
    HEFace<T> *heFace;
    char node[128];
    char N[16], A[4], B[4], C[4];
    int  v0, v1, v2;
    fgets( line, 128, fileIn );
    sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 );
    while ( node[0] != '}' ) {
        heFace = new HEFace<T>();
        prModel->GetFaceList()->Append( heFace );
        //----------------------------------------------------------------
        // Create and Set all three half-edges
        HEHalfEdge<T> *heHalfEdge0 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
            HelpCreateHalfEdgeModel<T>::vertexList[v0], 
            HelpCreateHalfEdgeModel<T>::vertexList[v1], 
            heFace );
        HEHalfEdge<T> *heHalfEdge1 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
            HelpCreateHalfEdgeModel<T>::vertexList[v1], 
            HelpCreateHalfEdgeModel<T>::vertexList[v2], 
            heFace, heHalfEdge0 );
        HEHalfEdge<T> *heHalfEdge2 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
            HelpCreateHalfEdgeModel<T>::vertexList[v2], 
            HelpCreateHalfEdgeModel<T>::vertexList[v0], 
            heFace, heHalfEdge1, heHalfEdge0 );
        halfEdgeCounter += 3;
        //----------------------------------------------------------------
        // Set incident half-edge of this face
        heFace->IncidentHalfEdge( heHalfEdge0 );
        //----------------------------------------------------------------
        // (CCW) Record v0 to v1, v1 to v2, and v2 to v0 in vertexRingList
        HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v1, v0 );   // put v1 in bucket v0
        HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v2, v1 );   // put v2 in bucket v1
        HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v0, v2 );   // put v0 in bucket v2
        //----------------------------------------------------------------
        // Record half-edges in halfEdgeRingList
        HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge0, v0 );    // put in bucket v0
        HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge1, v1 );    // put in bucket v1
        HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge2, v2 );    // put in bucket v2
        //----------------------------------------------------------------
        fgets( line, 128, fileIn );
        sscanf( line, "%s %s %s %d %s %d %s %d", node, N, A, &v0, B, &v1, C, &v2 );
    }
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Process VERTEX LIST BINARY BIG ENDDIAN
template <typename T>
void ReadPly<T>::ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN ( 
    FILE * inputFile, OpenGL::PolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing VERTEX LIST\n";
#endif
    //-------------------------------------------------------------------
    // Example: x y z and other values
    //   0 0 0 ...
    //   ...
    //   0 0 1 ...
    //---------------------------------------------------------------
    int readingSize = 0;
    //---------------------------------------------------------------
    for ( int i = 0; i < static_cast<int>(m_veVertexListType.size()); ++i ) {
        if      ( m_veVertexListType[i] == INT_8 )      readingSize += 1;
        else if ( m_veVertexListType[i] == UINT_8 ) readingSize += 1;
        else if ( m_veVertexListType[i] == INT_16 ) readingSize += 2;
        else if ( m_veVertexListType[i] == UINT_16 )    readingSize += 2;
        else if ( m_veVertexListType[i] == INT_32 ) readingSize += 4;
        else if ( m_veVertexListType[i] == UINT_32 )    readingSize += 4;
        else if ( m_veVertexListType[i] == FLOAT_32 )   readingSize += 4;
        else if ( m_veVertexListType[i] == FLOAT_64 )   readingSize += 8;
    }
    //---------------------------------------------------------------
    prModel->NewVertexListByNoVertices();
    int vertexNumber = 0;
    int index, dim;
    unsigned char * prBuffer = new unsigned char[ readingSize ];
    //---------------------------------------------------------------
    do {
        fread( prBuffer, readingSize, 1, inputFile );
        index = 0;
        //-------------------------------------------------
        for ( int i = 0; i < static_cast<int>(m_veVertexListAttrib.size()); ++i ) {
            //-----------------------------------
            if (   ( m_veVertexListAttrib[i] == X )
                || ( m_veVertexListAttrib[i] == Y ) 
                || ( m_veVertexListAttrib[i] == Z ) ) { 
                //---------------------
                if      ( m_veVertexListAttrib[i] == X )    dim = 0;
                else if ( m_veVertexListAttrib[i] == Y )    dim = 1;
                else                                        dim = 2;
                //else if ( m_veVertexListAttrib[i] == Z )  dim = 2;
                //---------------------
                ConvertBigEnddianToLittleEnddian( m_veVertexListType[i], &(prBuffer[index]) );
                if      ( m_veVertexListType[i] == INT_8 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((char *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_8 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned char *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == INT_16 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((short int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_16 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned short int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == INT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((long int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned long int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == FLOAT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((float *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == FLOAT_64 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((double *)( &( prBuffer[index] ) ));
                }
            }
            //-----------------------------------
            if      ( m_veVertexListType[i] == INT_8 )      index += 1;
            else if ( m_veVertexListType[i] == UINT_8 ) index += 1;
            else if ( m_veVertexListType[i] == INT_16 ) index += 2;
            else if ( m_veVertexListType[i] == UINT_16 )    index += 2;
            else if ( m_veVertexListType[i] == INT_32 ) index += 4;
            else if ( m_veVertexListType[i] == UINT_32 )    index += 4;
            else if ( m_veVertexListType[i] == FLOAT_32 )   index += 4;
            else if ( m_veVertexListType[i] == FLOAT_64 )   index += 8;
            //-----------------------------------
        }
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_3
        std::cout << "Vertex# " << vertexNumber << " --> ";
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][0];
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][1];
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][2];
        std::cout << "\n";
#endif
        //-------------------------------------------------
        ++vertexNumber;
    } while ( vertexNumber < prModel->GetNoVertices() );
    //---------------------------------------------------------------
    delete [] prBuffer;
}
//-----------------------------------------------------------------------------
// Process VERTEX LIST BINARY BIG ENDDIAN
template <typename T>
void ReadPly<T>::ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN ( 
    FILE * inputFile, OpenGL::XPolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing VERTEX LIST\n";
#endif
    //-------------------------------------------------------------------
    // Example: x y z and other values
    //   0 0 0 ...
    //   ...
    //   0 0 1 ...
    //---------------------------------------------------------------
    int readingSize = 0;
    //---------------------------------------------------------------
    for ( int i = 0; i < static_cast<int>(m_veVertexListType.size()); ++i ) {
        if      ( m_veVertexListType[i] == INT_8 )      readingSize += 1;
        else if ( m_veVertexListType[i] == UINT_8 ) readingSize += 1;
        else if ( m_veVertexListType[i] == INT_16 ) readingSize += 2;
        else if ( m_veVertexListType[i] == UINT_16 )    readingSize += 2;
        else if ( m_veVertexListType[i] == INT_32 ) readingSize += 4;
        else if ( m_veVertexListType[i] == UINT_32 )    readingSize += 4;
        else if ( m_veVertexListType[i] == FLOAT_32 )   readingSize += 4;
        else if ( m_veVertexListType[i] == FLOAT_64 )   readingSize += 8;
    }
    //---------------------------------------------------------------
    prModel->NewVertexListByNoVertices();
    int vertexNumber = 0;
    int index, dim;
    unsigned char * prBuffer = new unsigned char[ readingSize ];
    //---------------------------------------------------------------
    do {
        fread( prBuffer, readingSize, 1, inputFile );
        index = 0;
        //-------------------------------------------------
        for ( int i = 0; i < static_cast<int>(m_veVertexListAttrib.size()); ++i ) {
            //-----------------------------------
            if (   ( m_veVertexListAttrib[i] == X )
                || ( m_veVertexListAttrib[i] == Y ) 
                || ( m_veVertexListAttrib[i] == Z ) ) { 
                //---------------------
                if      ( m_veVertexListAttrib[i] == X )    dim = 0;
                else if ( m_veVertexListAttrib[i] == Y )    dim = 1;
                else                                        dim = 2;
                //else if ( m_veVertexListAttrib[i] == Z )  dim = 2;
                //---------------------
                ConvertBigEnddianToLittleEnddian( m_veVertexListType[i], &(prBuffer[index]) );
                if      ( m_veVertexListType[i] == INT_8 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((char *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_8 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned char *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == INT_16 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((short int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_16 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned short int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == INT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((long int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned long int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == FLOAT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((float *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == FLOAT_64 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((double *)( &( prBuffer[index] ) ));
                }
            }
            //-----------------------------------
            if      ( m_veVertexListType[i] == INT_8 )      index += 1;
            else if ( m_veVertexListType[i] == UINT_8 ) index += 1;
            else if ( m_veVertexListType[i] == INT_16 ) index += 2;
            else if ( m_veVertexListType[i] == UINT_16 )    index += 2;
            else if ( m_veVertexListType[i] == INT_32 ) index += 4;
            else if ( m_veVertexListType[i] == UINT_32 )    index += 4;
            else if ( m_veVertexListType[i] == FLOAT_32 )   index += 4;
            else if ( m_veVertexListType[i] == FLOAT_64 )   index += 8;
            //-----------------------------------
        }
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_3
        std::cout << "Vertex# " << vertexNumber << " --> ";
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][0];
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][1];
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][2];
        std::cout << "\n";
#endif
        //-------------------------------------------------
        ++vertexNumber;
    } while ( vertexNumber < prModel->GetNoVertices() );
    //---------------------------------------------------------------
    delete [] prBuffer;
}
//-----------------------------------------------------------------------------
// Process VERTEX LIST BINARY BIG ENDDIAN
template <typename T>
void ReadPly<T>::ProcessVERTEX_LIST_BINARY_BIG_ENDDIAN ( 
    FILE * inputFile, OpenGL::HalfEdgeModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing VERTEX LIST\n";
#endif
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Process FACE LIST BINARY BIG ENDDIAN
template <typename T>
void ReadPly<T>::ProcessFACE_LIST_BINARY_BIG_ENDDIAN ( 
    FILE * inputFile, OpenGL::PolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing FACE LIST\n";
#endif
    //---------------------------------------------------------------
    // Example:  number of vertices for this face followed by vertex numbers
    //   4 0  1  2  3
    //   ...
    //   3 10 11 12
    //---------------------------------------------------------------
    prModel->NewFaceListByNoFaces();
    if ( prModel->GetNoFaces() == 0 )   return;
    //---------------------------------------------------------------
    int readingSizeBefore = 0;
    int readingSizeAfter = 0;
    int numberOfVerticesSize = 0;
    int vertexIndexSize = 0;
    int faceNo = 0;
    int vertexNo = 0;
    int numberOfVertices = 0;
    int index = -1;
    unsigned char prBuffer[256];
    //---------------------------------------------------------------
    for ( int i = 0; i < static_cast<int>( m_veFaceListAttrib.size() ); ++i ) {
        if ( m_veFaceListAttrib[i] == LIST_VERTEX_INDICES ) {
            index = i;
            //---------------------------------------------
            // Set data type for number of vertices
            switch ( m_veFaceListType[i] ) {
                case INT_8:
                case UINT_8:
                    numberOfVerticesSize = 1;
                    break;
                case INT_16:
                case UINT_16:
                    numberOfVerticesSize = 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    numberOfVerticesSize = 4;
                    break;
                case FLOAT_64:
                    numberOfVerticesSize = 8;
                    break;
            }
            //---------------------------------------------
            // Set data type for the list of vertex indices
            switch ( m_veFaceListType[++i] ) {
                case INT_8:
                case UINT_8:
                    vertexIndexSize = 1;
                    break;
                case INT_16:
                case UINT_16:
                    vertexIndexSize = 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    vertexIndexSize = 4;
                    break;
                case FLOAT_64:
                    vertexIndexSize = 8;
                    break;
            }
        }
        else {
            //---------------------------------------------
            // Set data type for this attribute
            switch ( m_veFaceListType[i] ) {
                case INT_8:
                case UINT_8:
                    if ( index == -1 )  readingSizeBefore += 1;
                    else                readingSizeAfter  += 1;
                    break;
                case INT_16:
                case UINT_16:
                    if ( index == -1 )  readingSizeBefore += 2;
                    else                readingSizeAfter  += 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    if ( index == -1 )  readingSizeBefore += 4;
                    else                readingSizeAfter  += 4;
                    break;
                case FLOAT_64:
                    if ( index == -1 )  readingSizeBefore += 8;
                    else                readingSizeAfter  += 8;
                    break;
            }
        }
    }
    //---------------------------------------------------------------
    // Set Faces
    do {
        //-------------------------------------------------
        // Get some attributes before face info
        fread( prBuffer, readingSizeBefore, 1, inputFile );
        //-------------------------------------------------
        // Get number of vertices for each face
        fread( prBuffer, numberOfVerticesSize, 1, inputFile );
        ConvertBigEnddianToLittleEnddian( m_veFaceListType[index], prBuffer );
        switch ( m_veFaceListType[index] ) {
            case INT_8:
                numberOfVertices = *((char *)(prBuffer));
                break;
            case UINT_8:
                numberOfVertices = *((unsigned char *)(prBuffer));
                break;
            case INT_16:
                numberOfVertices = *((short int *)(prBuffer));
                break;
            case UINT_16:
                numberOfVertices = *((unsigned short int *)(prBuffer));
                break;
            case INT_32:
                numberOfVertices = *((long int *)(prBuffer));
                break;
            case UINT_32:
                numberOfVertices = *((unsigned long int *)(prBuffer));
                break;
            case FLOAT_32:
                numberOfVertices = *((float *)(prBuffer));
                break;
            case FLOAT_64:
                numberOfVertices = *((double *)(prBuffer));
                break;
        }
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_4
        if ( numberOfVertices <= 0 ) {
            std::cerr << "ERROR: This face has " 
                      << numberOfVertices << " of vertices!" << std::endl;
        }
#endif
        prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices );
        //-------------------------------------------------
        // Get the list of vertex indices for each face
        fread( prBuffer, vertexIndexSize, numberOfVertices, inputFile );
        int index2 = 0;
        for ( int i = 0; i < numberOfVertices; ++i ) {
            if ( vertexIndexSize > 1 ) {
                ConvertBigEnddianToLittleEnddian( m_veFaceListType[index+1], &(prBuffer[index2]) );
            }
            switch ( m_veFaceListType[index+1] ) {
                case INT_8:
                    vertexNo = *((char *)( &(prBuffer[index2]) ));
                    break;
                case UINT_8:
                    vertexNo = *((unsigned char *)( &(prBuffer[index2]) ));
                    break;
                case INT_16:
                    vertexNo = *((short int *)( &(prBuffer[index2]) ));
                    break;
                case UINT_16:
                    vertexNo = *((unsigned short int *)( &(prBuffer[index2]) ));
                    break;
                case INT_32:
                    vertexNo = *((long int *)( &(prBuffer[index2]) ));
                    break;
                case UINT_32:
                    vertexNo = *((unsigned long int *)( &(prBuffer[index2]) ));
                    break;
                case FLOAT_32:
                    vertexNo = *((float *)( &(prBuffer[index2]) ));
                    break;
                case FLOAT_64:
                    vertexNo = *((double *)( &(prBuffer[index2]) ));
                    break;
            }
            prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo );
            index2 += vertexIndexSize;
        }
        //-------------------------------------------------
        // Get some attributes after face info
        fread( prBuffer, readingSizeAfter, 1, inputFile );
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_3
        std::cout << "Face# " << faceNo << " has " << numberOfVertices << " vertices --> ";
        for ( int i = 0; i < numberOfVertices; ++i ) {
            std::cout << "\t" << vertexNo;
        }
        std::cout << "\n";
#endif
        //-------------------------------------------------
        ++faceNo;
        //-------------------------------------------------
    } while ( faceNo < prModel->GetNoFaces() );
}
//-----------------------------------------------------------------------------
// Process FACE LIST BINARY BIG ENDDIAN
template <typename T>
void ReadPly<T>::ProcessFACE_LIST_BINARY_BIG_ENDDIAN ( 
    FILE * inputFile, OpenGL::XPolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing FACE LIST\n";
#endif
    //---------------------------------------------------------------
    // Example:  number of vertices for this face followed by vertex numbers
    //   4 0  1  2  3
    //   ...
    //   3 10 11 12
    //---------------------------------------------------------------
    prModel->NewFaceListByNoFaces();
    if ( prModel->GetNoFaces() == 0 )   return;
    //---------------------------------------------------------------
    int readingSizeBefore = 0;
    int readingSizeAfter = 0;
    int numberOfVerticesSize = 0;
    int vertexIndexSize = 0;
    int faceNo = 0;
    int vertexNo = 0;
    int numberOfVertices = 0;
    int index = -1;
    unsigned char prBuffer[256];
    //---------------------------------------------------------------
    for ( int i = 0; i < static_cast<int>( m_veFaceListAttrib.size() ); ++i ) {
        if ( m_veFaceListAttrib[i] == LIST_VERTEX_INDICES ) {
            index = i;
            //---------------------------------------------
            // Set data type for number of vertices
            switch ( m_veFaceListType[i] ) {
                case INT_8:
                case UINT_8:
                    numberOfVerticesSize = 1;
                    break;
                case INT_16:
                case UINT_16:
                    numberOfVerticesSize = 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    numberOfVerticesSize = 4;
                    break;
                case FLOAT_64:
                    numberOfVerticesSize = 8;
                    break;
            }
            //---------------------------------------------
            // Set data type for the list of vertex indices
            switch ( m_veFaceListType[++i] ) {
                case INT_8:
                case UINT_8:
                    vertexIndexSize = 1;
                    break;
                case INT_16:
                case UINT_16:
                    vertexIndexSize = 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    vertexIndexSize = 4;
                    break;
                case FLOAT_64:
                    vertexIndexSize = 8;
                    break;
            }
        }
        else {
            //---------------------------------------------
            // Set data type for this attribute
            switch ( m_veFaceListType[i] ) {
                case INT_8:
                case UINT_8:
                    if ( index == -1 )  readingSizeBefore += 1;
                    else                readingSizeAfter  += 1;
                    break;
                case INT_16:
                case UINT_16:
                    if ( index == -1 )  readingSizeBefore += 2;
                    else                readingSizeAfter  += 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    if ( index == -1 )  readingSizeBefore += 4;
                    else                readingSizeAfter  += 4;
                    break;
                case FLOAT_64:
                    if ( index == -1 )  readingSizeBefore += 8;
                    else                readingSizeAfter  += 8;
                    break;
            }
        }
    }
    //---------------------------------------------------------------
    // Set Faces
    do {
        //-------------------------------------------------
        // Get some attributes before face info
        fread( prBuffer, readingSizeBefore, 1, inputFile );
        //-------------------------------------------------
        // Get number of vertices for each face
        fread( prBuffer, numberOfVerticesSize, 1, inputFile );
        ConvertBigEnddianToLittleEnddian( m_veFaceListType[index], prBuffer );
        switch ( m_veFaceListType[index] ) {
            case INT_8:
                numberOfVertices = *((char *)(prBuffer));
                break;
            case UINT_8:
                numberOfVertices = *((unsigned char *)(prBuffer));
                break;
            case INT_16:
                numberOfVertices = *((short int *)(prBuffer));
                break;
            case UINT_16:
                numberOfVertices = *((unsigned short int *)(prBuffer));
                break;
            case INT_32:
                numberOfVertices = *((long int *)(prBuffer));
                break;
            case UINT_32:
                numberOfVertices = *((unsigned long int *)(prBuffer));
                break;
            case FLOAT_32:
                numberOfVertices = *((float *)(prBuffer));
                break;
            case FLOAT_64:
                numberOfVertices = *((double *)(prBuffer));
                break;
        }
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_4
        if ( numberOfVertices <= 0 ) {
            std::cerr << "ERROR: This face has " 
                      << numberOfVertices << " of vertices!" << std::endl;
        }
#endif
        prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices );
        //-------------------------------------------------
        // Get the list of vertex indices for each face
        fread( prBuffer, vertexIndexSize, numberOfVertices, inputFile );
        int index2 = 0;
        for ( int i = 0; i < numberOfVertices; ++i ) {
            if ( vertexIndexSize > 1 ) {
                ConvertBigEnddianToLittleEnddian( m_veFaceListType[index+1], &(prBuffer[index2]) );
            }
            switch ( m_veFaceListType[index+1] ) {
                case INT_8:
                    vertexNo = *((char *)( &(prBuffer[index2]) ));
                    break;
                case UINT_8:
                    vertexNo = *((unsigned char *)( &(prBuffer[index2]) ));
                    break;
                case INT_16:
                    vertexNo = *((short int *)( &(prBuffer[index2]) ));
                    break;
                case UINT_16:
                    vertexNo = *((unsigned short int *)( &(prBuffer[index2]) ));
                    break;
                case INT_32:
                    vertexNo = *((long int *)( &(prBuffer[index2]) ));
                    break;
                case UINT_32:
                    vertexNo = *((unsigned long int *)( &(prBuffer[index2]) ));
                    break;
                case FLOAT_32:
                    vertexNo = *((float *)( &(prBuffer[index2]) ));
                    break;
                case FLOAT_64:
                    vertexNo = *((double *)( &(prBuffer[index2]) ));
                    break;
            }
            prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo );
            index2 += vertexIndexSize;
        }
        //-------------------------------------------------
        // Get some attributes after face info
        fread( prBuffer, readingSizeAfter, 1, inputFile );
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_3
        std::cout << "Face# " << faceNo << " has " << numberOfVertices << " vertices --> ";
        for ( int i = 0; i < numberOfVertices; ++i ) {
            std::cout << "\t" << vertexNo;
        }
        std::cout << "\n";
#endif
        //-------------------------------------------------
        ++faceNo;
        //-------------------------------------------------
    } while ( faceNo < prModel->GetNoFaces() );
}
//-----------------------------------------------------------------------------
// Process FACE LIST BINARY BIG ENDDIAN
template <typename T>
void ReadPly<T>::ProcessFACE_LIST_BINARY_BIG_ENDDIAN ( 
    FILE * inputFile, OpenGL::HalfEdgeModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing FACE LIST\n";
#endif
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Process VERTEX LIST BINARY LITTLE ENDDIAN
template <typename T>
void ReadPly<T>::ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN ( 
    FILE * inputFile, OpenGL::PolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing VERTEX LIST\n";
#endif
    //-------------------------------------------------------------------
    // Example: x y z and other values
    //   0 0 0 ...
    //   ...
    //   0 0 1 ...
    //---------------------------------------------------------------
    int readingSize = 0;
    //---------------------------------------------------------------
    for ( int i = 0; i < static_cast<int>(m_veVertexListType.size()); ++i ) {
        if      ( m_veVertexListType[i] == INT_8 )      readingSize += 1;
        else if ( m_veVertexListType[i] == UINT_8 ) readingSize += 1;
        else if ( m_veVertexListType[i] == INT_16 ) readingSize += 2;
        else if ( m_veVertexListType[i] == UINT_16 )    readingSize += 2;
        else if ( m_veVertexListType[i] == INT_32 ) readingSize += 4;
        else if ( m_veVertexListType[i] == UINT_32 )    readingSize += 4;
        else if ( m_veVertexListType[i] == FLOAT_32 )   readingSize += 4;
        else if ( m_veVertexListType[i] == FLOAT_64 )   readingSize += 8;
    }
    //---------------------------------------------------------------
    prModel->NewVertexListByNoVertices();
    int vertexNumber = 0;
    int index, dim;
    unsigned char * prBuffer = new unsigned char[ readingSize ];
    //---------------------------------------------------------------
    do {
        fread( prBuffer, readingSize, 1, inputFile );
        index = 0;
        //-------------------------------------------------
        for ( int i = 0; i < static_cast<int>(m_veVertexListAttrib.size()); ++i ) {
            //-----------------------------------
            if (   ( m_veVertexListAttrib[i] == X )
                || ( m_veVertexListAttrib[i] == Y ) 
                || ( m_veVertexListAttrib[i] == Z ) ) { 
                //---------------------
                if      ( m_veVertexListAttrib[i] == X )    dim = 0;
                else if ( m_veVertexListAttrib[i] == Y )    dim = 1;
                else                                        dim = 2;
                //else if ( m_veVertexListAttrib[i] == Z )  dim = 2;
                //---------------------
                if      ( m_veVertexListType[i] == INT_8 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((char *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_8 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned char *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == INT_16 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((short int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_16 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned short int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == INT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((long int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned long int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == FLOAT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((float *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == FLOAT_64 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((double *)( &( prBuffer[index] ) ));
                }
            }
            //-----------------------------------
            if      ( m_veVertexListType[i] == INT_8 )      index += 1;
            else if ( m_veVertexListType[i] == UINT_8 ) index += 1;
            else if ( m_veVertexListType[i] == INT_16 ) index += 2;
            else if ( m_veVertexListType[i] == UINT_16 )    index += 2;
            else if ( m_veVertexListType[i] == INT_32 ) index += 4;
            else if ( m_veVertexListType[i] == UINT_32 )    index += 4;
            else if ( m_veVertexListType[i] == FLOAT_32 )   index += 4;
            else if ( m_veVertexListType[i] == FLOAT_64 )   index += 8;
            //-----------------------------------
        }
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_3
        std::cout << "Vertex# " << vertexNumber << " --> ";
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][0];
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][1];
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][2];
        std::cout << "\n";
#endif
        //-------------------------------------------------
        ++vertexNumber;
    } while ( vertexNumber < prModel->GetNoVertices() );
    //---------------------------------------------------------------
    delete [] prBuffer;
}
//-----------------------------------------------------------------------------
// Process VERTEX LIST BINARY LITTLE ENDDIAN
template <typename T>
void ReadPly<T>::ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN ( 
    FILE * inputFile, OpenGL::XPolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing VERTEX LIST\n";
#endif
    //-------------------------------------------------------------------
    // Example: x y z and other values
    //   0 0 0 ...
    //   ...
    //   0 0 1 ...
    //---------------------------------------------------------------
    int readingSize = 0;
    //---------------------------------------------------------------
    for ( int i = 0; i < static_cast<int>(m_veVertexListType.size()); ++i ) {
        if      ( m_veVertexListType[i] == INT_8 )      readingSize += 1;
        else if ( m_veVertexListType[i] == UINT_8 ) readingSize += 1;
        else if ( m_veVertexListType[i] == INT_16 ) readingSize += 2;
        else if ( m_veVertexListType[i] == UINT_16 )    readingSize += 2;
        else if ( m_veVertexListType[i] == INT_32 ) readingSize += 4;
        else if ( m_veVertexListType[i] == UINT_32 )    readingSize += 4;
        else if ( m_veVertexListType[i] == FLOAT_32 )   readingSize += 4;
        else if ( m_veVertexListType[i] == FLOAT_64 )   readingSize += 8;
    }
    //---------------------------------------------------------------
    prModel->NewVertexListByNoVertices();
    int vertexNumber = 0;
    int index, dim;
    unsigned char * prBuffer = new unsigned char[ readingSize ];
    //---------------------------------------------------------------
    do {
        fread( prBuffer, readingSize, 1, inputFile );
        index = 0;
        //-------------------------------------------------
        for ( int i = 0; i < static_cast<int>(m_veVertexListAttrib.size()); ++i ) {
            //-----------------------------------
            if (   ( m_veVertexListAttrib[i] == X )
                || ( m_veVertexListAttrib[i] == Y ) 
                || ( m_veVertexListAttrib[i] == Z ) ) { 
                //---------------------
                if      ( m_veVertexListAttrib[i] == X )    dim = 0;
                else if ( m_veVertexListAttrib[i] == Y )    dim = 1;
                else                                        dim = 2;
                //else if ( m_veVertexListAttrib[i] == Z )  dim = 2;
                //---------------------
                if      ( m_veVertexListType[i] == INT_8 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((char *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_8 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned char *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == INT_16 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((short int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_16 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned short int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == INT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((long int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == UINT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((unsigned long int *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == FLOAT_32 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((float *)( &( prBuffer[index] ) ));
                }
                else if ( m_veVertexListType[i] == FLOAT_64 ) {
                    prModel->GetVertexList()[vertexNumber][dim] = *((double *)( &( prBuffer[index] ) ));
                }
            }
            //-----------------------------------
            if      ( m_veVertexListType[i] == INT_8 )      index += 1;
            else if ( m_veVertexListType[i] == UINT_8 ) index += 1;
            else if ( m_veVertexListType[i] == INT_16 ) index += 2;
            else if ( m_veVertexListType[i] == UINT_16 )    index += 2;
            else if ( m_veVertexListType[i] == INT_32 ) index += 4;
            else if ( m_veVertexListType[i] == UINT_32 )    index += 4;
            else if ( m_veVertexListType[i] == FLOAT_32 )   index += 4;
            else if ( m_veVertexListType[i] == FLOAT_64 )   index += 8;
            //-----------------------------------
        }
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_3
        std::cout << "Vertex# " << vertexNumber << " --> ";
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][0];
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][1];
        std::cout << "\t" << prModel->GetVertexList()[vertexNumber][2];
        std::cout << "\n";
#endif
        //-------------------------------------------------
        ++vertexNumber;
    } while ( vertexNumber < prModel->GetNoVertices() );
    //---------------------------------------------------------------
    delete [] prBuffer;
}
//-----------------------------------------------------------------------------
// Process VERTEX LIST BINARY LITTLE ENDDIAN
template <typename T>
void ReadPly<T>::ProcessVERTEX_LIST_BINARY_LITTLE_ENDDIAN ( 
    FILE * inputFile, OpenGL::HalfEdgeModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing VERTEX LIST\n";
#endif
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Process FACE LIST BINARY LITTLE ENDDIAN
template <typename T>
void ReadPly<T>::ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN ( 
    FILE * inputFile, OpenGL::PolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing FACE LIST\n";
#endif
    //---------------------------------------------------------------
    // Example:  number of vertices for this face followed by vertex numbers
    //   4 0  1  2  3
    //   ...
    //   3 10 11 12
    //---------------------------------------------------------------
    prModel->NewFaceListByNoFaces();
    if ( prModel->GetNoFaces() == 0 )   return;
    //---------------------------------------------------------------
    int readingSizeBefore = 0;
    int readingSizeAfter = 0;
    int numberOfVerticesSize = 0;
    int vertexIndexSize = 0;
    int faceNo = 0;
    int vertexNo = 0;
    int numberOfVertices = 0;
    int index = -1;
    unsigned char prBuffer[256];
    //---------------------------------------------------------------
    for ( int i = 0; i < static_cast<int>( m_veFaceListAttrib.size() ); ++i ) {
        if ( m_veFaceListAttrib[i] == LIST_VERTEX_INDICES ) {
            index = i;
            //---------------------------------------------
            // Set data type for number of vertices
            switch ( m_veFaceListType[i] ) {
                case INT_8:
                case UINT_8:
                    numberOfVerticesSize = 1;
                    break;
                case INT_16:
                case UINT_16:
                    numberOfVerticesSize = 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    numberOfVerticesSize = 4;
                    break;
                case FLOAT_64:
                    numberOfVerticesSize = 8;
                    break;
            }
            //---------------------------------------------
            // Set data type for the list of vertex indices
            switch ( m_veFaceListType[++i] ) {
                case INT_8:
                case UINT_8:
                    vertexIndexSize = 1;
                    break;
                case INT_16:
                case UINT_16:
                    vertexIndexSize = 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    vertexIndexSize = 4;
                    break;
                case FLOAT_64:
                    vertexIndexSize = 8;
                    break;
            }
        }
        else {
            //---------------------------------------------
            // Set data type for this attribute
            switch ( m_veFaceListType[i] ) {
                case INT_8:
                case UINT_8:
                    if ( index == -1 )  readingSizeBefore += 1;
                    else                readingSizeAfter  += 1;
                    break;
                case INT_16:
                case UINT_16:
                    if ( index == -1 )  readingSizeBefore += 2;
                    else                readingSizeAfter  += 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    if ( index == -1 )  readingSizeBefore += 4;
                    else                readingSizeAfter  += 4;
                    break;
                case FLOAT_64:
                    if ( index == -1 )  readingSizeBefore += 8;
                    else                readingSizeAfter  += 8;
                    break;
            }
        }
    }
    //---------------------------------------------------------------
    // Set Faces
    do {
        //-------------------------------------------------
        // Get some attributes before face info
        fread( prBuffer, readingSizeBefore, 1, inputFile );
        //-------------------------------------------------
        // Get number of vertices for each face
        fread( prBuffer, numberOfVerticesSize, 1, inputFile );
        switch ( m_veFaceListType[index] ) {
            case INT_8:
                numberOfVertices = *((char *)(prBuffer));
                break;
            case UINT_8:
                numberOfVertices = *((unsigned char *)(prBuffer));
                break;
            case INT_16:
                numberOfVertices = *((short int *)(prBuffer));
                break;
            case UINT_16:
                numberOfVertices = *((unsigned short int *)(prBuffer));
                break;
            case INT_32:
                numberOfVertices = *((long int *)(prBuffer));
                break;
            case UINT_32:
                numberOfVertices = *((unsigned long int *)(prBuffer));
                break;
            case FLOAT_32:
                numberOfVertices = *((float *)(prBuffer));
                break;
            case FLOAT_64:
                numberOfVertices = *((double *)(prBuffer));
                break;
        }
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_4
        if ( numberOfVertices <= 0 ) {
            std::cerr << "ERROR: This face has " 
                      << numberOfVertices << " of vertices!" << std::endl;
        }
#endif
        prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices );
        //-------------------------------------------------
        // Get the list of vertex indices for each face
        fread( prBuffer, vertexIndexSize, numberOfVertices, inputFile );
        int index2 = 0;
        for ( int i = 0; i < numberOfVertices; ++i ) {
            switch ( m_veFaceListType[index+1] ) {
                case INT_8:
                    vertexNo = *((char *)( &(prBuffer[index2]) ));
                    break;
                case UINT_8:
                    vertexNo = *((unsigned char *)( &(prBuffer[index2]) ));
                    break;
                case INT_16:
                    vertexNo = *((short int *)( &(prBuffer[index2]) ));
                    break;
                case UINT_16:
                    vertexNo = *((unsigned short int *)( &(prBuffer[index2]) ));
                    break;
                case INT_32:
                    vertexNo = *((long int *)( &(prBuffer[index2]) ));
                    break;
                case UINT_32:
                    vertexNo = *((unsigned long int *)( &(prBuffer[index2]) ));
                    break;
                case FLOAT_32:
                    vertexNo = *((float *)( &(prBuffer[index2]) ));
                    break;
                case FLOAT_64:
                    vertexNo = *((double *)( &(prBuffer[index2]) ));
                    break;
            }
            prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo );
            index2 += vertexIndexSize;
        }
        //-------------------------------------------------
        // Get some attributes after face info
        fread( prBuffer, readingSizeAfter, 1, inputFile );
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_3
        std::cout << "Face# " << faceNo << " has " << numberOfVertices << " vertices --> ";
        for ( int i = 0; i < numberOfVertices; ++i ) {
            std::cout << "\t" << vertexNo;
        }
        std::cout << "\n";
#endif
        //-------------------------------------------------
        ++faceNo;
        //-------------------------------------------------
    } while ( faceNo < prModel->GetNoFaces() );
}
//-----------------------------------------------------------------------------
// Process FACE LIST BINARY LITTLE ENDDIAN
template <typename T>
void ReadPly<T>::ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN ( 
    FILE * inputFile, OpenGL::XPolygonalModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing FACE LIST\n";
#endif
    //---------------------------------------------------------------
    // Example:  number of vertices for this face followed by vertex numbers
    //   4 0  1  2  3
    //   ...
    //   3 10 11 12
    //---------------------------------------------------------------
    prModel->NewFaceListByNoFaces();
    if ( prModel->GetNoFaces() == 0 )   return;
    //---------------------------------------------------------------
    int readingSizeBefore = 0;
    int readingSizeAfter = 0;
    int numberOfVerticesSize = 0;
    int vertexIndexSize = 0;
    int faceNo = 0;
    int vertexNo = 0;
    int numberOfVertices = 0;
    int index = -1;
    unsigned char prBuffer[256];
    //---------------------------------------------------------------
    for ( int i = 0; i < static_cast<int>( m_veFaceListAttrib.size() ); ++i ) {
        if ( m_veFaceListAttrib[i] == LIST_VERTEX_INDICES ) {
            index = i;
            //---------------------------------------------
            // Set data type for number of vertices
            switch ( m_veFaceListType[i] ) {
                case INT_8:
                case UINT_8:
                    numberOfVerticesSize = 1;
                    break;
                case INT_16:
                case UINT_16:
                    numberOfVerticesSize = 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    numberOfVerticesSize = 4;
                    break;
                case FLOAT_64:
                    numberOfVerticesSize = 8;
                    break;
            }
            //---------------------------------------------
            // Set data type for the list of vertex indices
            switch ( m_veFaceListType[++i] ) {
                case INT_8:
                case UINT_8:
                    vertexIndexSize = 1;
                    break;
                case INT_16:
                case UINT_16:
                    vertexIndexSize = 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    vertexIndexSize = 4;
                    break;
                case FLOAT_64:
                    vertexIndexSize = 8;
                    break;
            }
        }
        else {
            //---------------------------------------------
            // Set data type for this attribute
            switch ( m_veFaceListType[i] ) {
                case INT_8:
                case UINT_8:
                    if ( index == -1 )  readingSizeBefore += 1;
                    else                readingSizeAfter  += 1;
                    break;
                case INT_16:
                case UINT_16:
                    if ( index == -1 )  readingSizeBefore += 2;
                    else                readingSizeAfter  += 2;
                    break;
                case INT_32:
                case UINT_32:
                case FLOAT_32:
                    if ( index == -1 )  readingSizeBefore += 4;
                    else                readingSizeAfter  += 4;
                    break;
                case FLOAT_64:
                    if ( index == -1 )  readingSizeBefore += 8;
                    else                readingSizeAfter  += 8;
                    break;
            }
        }
    }
    //---------------------------------------------------------------
    // Set Faces
    do {
        //-------------------------------------------------
        // Get some attributes before face info
        fread( prBuffer, readingSizeBefore, 1, inputFile );
        //-------------------------------------------------
        // Get number of vertices for each face
        fread( prBuffer, numberOfVerticesSize, 1, inputFile );
        switch ( m_veFaceListType[index] ) {
            case INT_8:
                numberOfVertices = *((char *)(prBuffer));
                break;
            case UINT_8:
                numberOfVertices = *((unsigned char *)(prBuffer));
                break;
            case INT_16:
                numberOfVertices = *((short int *)(prBuffer));
                break;
            case UINT_16:
                numberOfVertices = *((unsigned short int *)(prBuffer));
                break;
            case INT_32:
                numberOfVertices = *((long int *)(prBuffer));
                break;
            case UINT_32:
                numberOfVertices = *((unsigned long int *)(prBuffer));
                break;
            case FLOAT_32:
                numberOfVertices = *((float *)(prBuffer));
                break;
            case FLOAT_64:
                numberOfVertices = *((double *)(prBuffer));
                break;
        }
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_4
        if ( numberOfVertices <= 0 ) {
            std::cerr << "ERROR: This face has " 
                      << numberOfVertices << " of vertices!" << std::endl;
        }
#endif
        prModel->GetFaceList()[faceNo].SetNoVertices( numberOfVertices );
        //-------------------------------------------------
        // Get the list of vertex indices for each face
        fread( prBuffer, vertexIndexSize, numberOfVertices, inputFile );
        int index2 = 0;
        for ( int i = 0; i < numberOfVertices; ++i ) {
            switch ( m_veFaceListType[index+1] ) {
                case INT_8:
                    vertexNo = *((char *)( &(prBuffer[index2]) ));
                    break;
                case UINT_8:
                    vertexNo = *((unsigned char *)( &(prBuffer[index2]) ));
                    break;
                case INT_16:
                    vertexNo = *((short int *)( &(prBuffer[index2]) ));
                    break;
                case UINT_16:
                    vertexNo = *((unsigned short int *)( &(prBuffer[index2]) ));
                    break;
                case INT_32:
                    vertexNo = *((long int *)( &(prBuffer[index2]) ));
                    break;
                case UINT_32:
                    vertexNo = *((unsigned long int *)( &(prBuffer[index2]) ));
                    break;
                case FLOAT_32:
                    vertexNo = *((float *)( &(prBuffer[index2]) ));
                    break;
                case FLOAT_64:
                    vertexNo = *((double *)( &(prBuffer[index2]) ));
                    break;
            }
            prModel->GetFaceList()[faceNo].SetVertexNo( i, vertexNo );
            index2 += vertexIndexSize;
        }
        //-------------------------------------------------
        // Get some attributes after face info
        fread( prBuffer, readingSizeAfter, 1, inputFile );
        //-------------------------------------------------
#ifdef  TAPs_DEBUG_MODE_DETAIL_3
        std::cout << "Face# " << faceNo << " has " << numberOfVertices << " vertices --> ";
        for ( int i = 0; i < numberOfVertices; ++i ) {
            std::cout << "\t" << vertexNo;
        }
        std::cout << "\n";
#endif
        //-------------------------------------------------
        ++faceNo;
        //-------------------------------------------------
    } while ( faceNo < prModel->GetNoFaces() );
}
//-----------------------------------------------------------------------------
// Process FACE LIST BINARY LITTLE ENDDIAN
template <typename T>
void ReadPly<T>::ProcessFACE_LIST_BINARY_LITTLE_ENDDIAN ( 
    FILE * inputFile, OpenGL::HalfEdgeModel<T> * const prModel )
{
#ifdef  TAPs_DEBUG_MODE
    std::cout << "Processing FACE LIST\n";
#endif
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Convert Big Enddian to Little Enddian
template <typename T>
void ReadPly<T>::ConvertBigEnddianToLittleEnddian ( 
    unsigned char dataType, unsigned char * prData )
{
    unsigned char temp;
    switch ( dataType ) {
        case INT_16:
        case UINT_16:
            temp      = prData[0];
            prData[0] = prData[1];
            prData[1] = temp;
            break;
        case INT_32:
        case UINT_32:
        case FLOAT_32:
            temp      = prData[0];
            prData[0] = prData[3];
            prData[3] = temp;
            temp      = prData[1];
            prData[1] = prData[2];
            prData[2] = temp;
            break;
        case FLOAT_64:
            temp      = prData[0];
            prData[0] = prData[7];
            prData[7] = temp;
            temp      = prData[1];
            prData[1] = prData[6];
            prData[6] = temp;
            temp      = prData[2];
            prData[2] = prData[5];
            prData[5] = temp;
            temp      = prData[3];
            prData[3] = prData[4];
            prData[4] = temp;
            break;
    }
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----