TAPsHalfEdgeModel.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsHalfEdgeModel.cpp

A Polygonal Model based on half-edge data structure.
(See HalfEdgeModel.hpp for details)

SUKITTI PUNAK   (04/05/2005)
UPDATE          (12/03/2010)
******************************************************************************/
#include "TAPsHalfEdgeModel.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__OpenGL
//=============================================================================
//-----------------------------------------------------------------------------
// default constructor
template <typename T>
HalfEdgeModel<T>::HalfEdgeModel ()
    : OpenGLMeshModel<T>()
{
    m_listVertex   = new HEVertexList<T>();
    m_listFace     = new HEFaceList<T>();
    m_listHoleFace = new HEFaceList<T>();
    if (   m_listVertex   == NULL 
        || m_listFace     == NULL
        || m_listHoleFace == NULL ) {

        #ifdef TAPs_DEBUG_MODE
        std::cerr << "HalfEdgeModel ERROR: Can create an halfedge object." << std::endl;
        #endif//TAPs_DEBUG_MODE

        exit(1);
    }

    #ifdef TAPs_DEBUG_MODE
    std::cout << "HalfEdgeModel<" << typeid(T).name() << "> Constructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// destructor
template <typename T>
HalfEdgeModel<T>::~HalfEdgeModel ()
{
    delete m_listVertex;
    delete m_listFace;
    delete m_listHoleFace;
    //----------------------------------------------------------------
    // For simulation
    //delete m_prODESolver;
    #ifdef TAPs_DEBUG_MODE
    std::cout << "HalfEdgeModel<" << typeid(T).name() << "> Destructor\n";
    #endif//TAPs_DEBUG_MODE
}
//-----------------------------------------------------------------------------
// Initialize
// a virtual fn from Model class
template <typename T>
void HalfEdgeModel<T>::Initialize ()
{
    // Model Initialization
    CalAndSetNormals();
    ApplyMaterial();
    CalBoundingAABB();
    CalBoundingEllipsoid();
    CalBoundingSphere();

    // For Fast Access
    //SetListOfVertexPositionsAndNormals();

    /*
    std::cout << *this << std::endl;
    //*/
}
//-----------------------------------------------------------------------------


#ifdef  TAPs_USE_DATA_POOL
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeModel<T>::SetNumVertices( int n )
{
    m_iNoVertices = n;
    GetArrayOfVertexPositions().Resize( n, 3 );
    GetArrayOfVertexNormals().Resize( n, 3 );
}
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeModel<T>::SetNumFaces( int n )
{
    m_iNoFaces = n;
    GetArrayOfIndexFaces().Resize( n, 3 );
}
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeModel<T>::SetNumTexCoords( int n )
{
    m_iNoTexCoords = n;
}
//-----------------------------------------------------------------------------
#endif//TAPs_USE_DATA_POOL


//-----------------------------------------------------------------------------
// Get Half Length
template <typename T>
T HalfEdgeModel<T>::GetMaxHalfLength () const
{
    T maxHalfSize = 0.0;
    HEVertex<T> *ptr = m_listVertex->Head();
    while ( ptr != NULL ) {
        if ( fabs( (*ptr)[0] ) > maxHalfSize )
            maxHalfSize = fabs( (*ptr)[0] );
        if ( fabs( (*ptr)[1] ) > maxHalfSize )
            maxHalfSize = fabs( (*ptr)[1] );
        if ( fabs( (*ptr)[2] ) > maxHalfSize )
            maxHalfSize = fabs( (*ptr)[2] );
        ptr = ptr->Next();
    }
    return maxHalfSize;
}
//-----------------------------------------------------------------------------
// Calculate and set the normals
template <typename T>
void HalfEdgeModel<T>::CalAndSetNormals ()
{
    CalAndSetFaceNormalsNotNormalized();
//  DetermineFaceRings();
    CalAndSetVertexNormals();
    NormalizeFaceNormals();
}
//-----------------------------------------------------------------------------
// Calculate and set the face normals (without normalized)
template <typename T>
inline void HalfEdgeModel<T>::CalAndSetFaceNormalsNotNormalized ()
{
    // Calculate and set the normal of each face
    HEFace<T> * face = m_listFace->Head();
    while ( face != NULL ) {
        Vector3<T> const & v0 = face->IncidentHalfEdge()->Prev()->Vertex()->GetPosition();
        Vector3<T> const & v1 = face->IncidentHalfEdge()->Vertex()->GetPosition();
        Vector3<T> const & v2 = face->IncidentHalfEdge()->Next()->Vertex()->GetPosition();
        face->SetNormal( (v1 - v0) ^ (v2 - v1) );
        face = face->Next();
    }
}
//-----------------------------------------------------------------------------
// Normalize the face normals
template <typename T>
inline void HalfEdgeModel<T>::NormalizeFaceNormals ()
{
    // Normalize the normal of each face
    HEFace<T> * face = m_listFace->Head();
    while ( face != NULL ) {
        const_cast< Vector3<T> * >( &face->GetNormal() )->Normalized();
        face = face->Next();
    }
}
//-----------------------------------------------------------------------------
// Calculate and set the vertex normals
template <typename T>
inline void HalfEdgeModel<T>::CalAndSetVertexNormals ()
{
    HEVertex<T> *vertex = m_listVertex->Head();
    HEHalfEdge<T> *halfEdge;

    #ifdef TAPs_DEBUG_MODE
    std::cout << "FIND VERTEX NORMAL" << std::endl;
    #endif//TAPs_DEBUG_MODE

    while ( vertex ) {
        Vector3<T> vNormal;
        halfEdge = vertex->IncidentHalfEdge();

        #ifdef TAPs_DEBUG_MODE
        std::cout << *halfEdge << std::endl;
        #endif//TAPs_DEBUG_MODE

        vNormal = Vector3<T>(0,0,0);
        int count1 = 0;
        int count2 = 0;
        do {
            vNormal += halfEdge->Face()->GetNormal();
            halfEdge = halfEdge->Pair()->Next();
            // Cannot use previous, because of half-edge data structure
            //halfEdge = halfEdge->Pair()->Prev();
            //if ( halfEdge == NULL ) {
            //  std::cout << "--------------------=================>>>>>>> NULL\n";
                //assert( false );
            //  break;
            //}
        } while ( halfEdge != vertex->IncidentHalfEdge() );

        vertex->SetNormal( vNormal.Normalized() );
        vertex = vertex->Next();
    }
}

//******************************************************************************
// ApplyAndResetTransform
//******************************************************************************
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeModel<T>::ApplyAndResetTransform ()
{
    HEVertex<T> * heVertex = GetVertexList()->Head();
    //--------------------------------------------------------------------
    while ( heVertex ) {
        heVertex->SetPosition( 
            (     GetTransform().RefToMatrixTransform() 
                * Vector4<T>( heVertex->GetPosition() )
            ).GetVector3()
        );
        heVertex = heVertex->Next();
    }
    //--------------------------------------------------------------------
    // Set Transformation to Identity Matrix
    GetTransform().MakeIdentity();
    //--------------------------------------------------------------------
    // Recalculate Bounding Volume(s)
    CalBoundingAABB();
    CalBoundingEllipsoid();
    CalBoundingSphere();

    // Update the bounding volume tree
    if ( GetBVHTree() ) {
        GetBVHTree()->Update();
    }
}
//-----------------------------------------------------------------------------
//******************************************************************************

//******************************************************************************
// Virtual Fns from Collision Detection from ColDetSupport class
//******************************************************************************
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeModel<T>::CalBoundingAABB ()
{
    //int numOfVertices = m_listVertex->Size();
    HEVertex<T> *vertex = m_listVertex->Head();
    m_paBoundingAABB[0] = m_paBoundingAABB[1] = vertex->GetPosition();
    //for ( int i = 0; i < numOfVertices; ++i ) {
    while ( vertex ) {
        // Find lowest x, y, and z
        if ( m_paBoundingAABB[0][0] > (*vertex)[0] )
             m_paBoundingAABB[0][0] = (*vertex)[0];
        if ( m_paBoundingAABB[0][1] > (*vertex)[1] )
             m_paBoundingAABB[0][1] = (*vertex)[1];
        if ( m_paBoundingAABB[0][2] > (*vertex)[2] )
             m_paBoundingAABB[0][2] = (*vertex)[2];
        // Find highest x, y, and z
        if ( m_paBoundingAABB[1][0] < (*vertex)[0] )
             m_paBoundingAABB[1][0] = (*vertex)[0];
        if ( m_paBoundingAABB[1][1] < (*vertex)[1] )
             m_paBoundingAABB[1][1] = (*vertex)[1];
        if ( m_paBoundingAABB[1][2] < (*vertex)[2] )
             m_paBoundingAABB[1][2] = (*vertex)[2];
        // Next vertex
        vertex = vertex->Next();
    }
    // Find the bounding volume center
    m_pBoundingCenter[0] = ( m_paBoundingAABB[0][0] + m_paBoundingAABB[1][0] ) / 2.0;
    m_pBoundingCenter[1] = ( m_paBoundingAABB[0][1] + m_paBoundingAABB[1][1] ) / 2.0;
    m_pBoundingCenter[2] = ( m_paBoundingAABB[0][2] + m_paBoundingAABB[1][2] ) / 2.0;
}
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeModel<T>::CalBoundingEllipsoid ()
{
    T x = m_paBoundingAABB[1][0] - m_pBoundingCenter[0];
    x *= x;
    T y = m_paBoundingAABB[1][1] - m_pBoundingCenter[1];
    y *= y;
    T z = m_paBoundingAABB[1][2] - m_pBoundingCenter[2];
    z *= z;
    m_pBoundingEllipsoid[1] = sqrt( y + z );
    m_pBoundingEllipsoid[2] = sqrt( z + x );
    m_pBoundingEllipsoid[0] = sqrt( x + y );
}
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeModel<T>::CalBoundingSphere ()
{
    T squaredLength;
    m_pBoundingSphere = 0;
    HEVertex<T> *vertex = m_listVertex->Head();
    while ( vertex ) {
        squaredLength = (vertex->GetPosition() - m_pBoundingCenter).SquaredLength();
        if ( squaredLength > m_pBoundingSphere )
            m_pBoundingSphere = squaredLength;
        // Next vertex
        vertex = vertex->Next();
    }
    m_pBoundingSphere = sqrt( m_pBoundingSphere );
}
//-----------------------------------------------------------------------------
// Create BVHTree
template <typename T>
void HalfEdgeModel<T>::BuildBVHTree ( TAPs::Enum::CD treeType )
{
    //BVHTree<T>::
    // Call a static fn from BVHTree class
    // m_pBVHTree is inherited from ColDetSupport class

    //m_pBVHTree = BVHTree<T>::BuildBVHTree( GetTransform(), m_listFace, treeType, m_pBVHTree );

    m_pBVHTree = TAPs::CD::BuildBVHTree<T>( GetTransform(), m_listFace, treeType );

    //std::cout << "m_pVBHTree: " << m_pBVHTree << std::cout;
}
//-----------------------------------------------------------------------------
//******************************************************************************

//******************************************************************************
// For Fast Access (e.g. for OpenGL Drawing)
//******************************************************************************
//-----------------------------------------------------------------------------
// SetListOfVertexPositions
//template <typename T>
//void HalfEdgeModel<T>::SetListOfVertexPositionsAndNormals ()
//{
//  m_vListOfVertexPositions.clear();
//  m_vListOfVertexNormals.clear();
//  HEVertex<T> * vertex = m_listVertex->Head();
//  while ( vertex ) {
//      m_vListOfVertexPositions.push_back( &(vertex->GetPosition()) );
//      m_vListOfVertexNormals.push_back( &(vertex->GetNormal()) );
//      vertex = vertex->Next();
//  }
//}
//-----------------------------------------------------------------------------
//******************************************************************************

//=============================================================================
// Euler Opertator Fns
//=============================================================================
//-----------------------------------------------------------------------------
// Insert Vertex Split Edge
//-------------------------------------
//             O                     O
//            /     IVSE( he )      /
//           /     ===========>    /
//          /                     V
//         /  he             newVertex (at pos, if pos != null)
//        /                     /
//       /                     / newHalfEdge (and newPairHalfEdge)
//      /                     / 
//     V                     V
template <typename T>
void HalfEdgeModel<T>::IVSE ( HEHalfEdge<T> * he, Vector3<T> const * const pos )
{
    //---------------------------------------------------------------
    // Crete New Vertex
    HEVertex<T> * newVertex;
    if ( pos != NULL ) {
        newVertex = new HEVertex<T>( *pos, he->Vertex()->GetNormal() );
    }
    else {
        newVertex = new HEVertex<T>( he->Vertex()->GetPosition(), 
                                     he->Vertex()->GetNormal() );
    }
    //---------------------------------------------------------------
    // Update Vertex List and Number of Vertices
    //GetVertexList()->Append( newVertex ); // or Append or Prepend
    GetVertexList()->InsertAfter( newVertex );  // or Append or Prepend
    SetNoVertices( GetVertexList()->Size() );
    //SetNoVertices( GetNoVertices() + 1 );
    //---------------------------------------------------------------
    // Crete New HalfEdges
    HEHalfEdge<T> * newHalfEdge = new HEHalfEdge<T>( 
                        newVertex,      // original vertex
                        he->Face(),     // incident face
                        he,             // previous halfedge
                        he->Next(),     // next halfedge
                        he->Pair() );   // pair halfedge
    HEHalfEdge<T> * newPairHalfEdge = new HEHalfEdge<T>( 
                    newVertex,          // original vertex
                    he->Pair()->Face(), // incident face
                    he->Pair(),         // previous halfedge
                    he->Pair()->Next(), // next halfedge
                    he );               // pair halfedge
    //---------------------------------------------------------------
    // Rearrange Pointers
    newHalfEdge->Pair()->Pair( newHalfEdge );
    newHalfEdge->Prev()->Next( newHalfEdge );
    newHalfEdge->Next()->Prev( newHalfEdge );
    newPairHalfEdge->Pair()->Pair( newPairHalfEdge );
    newPairHalfEdge->Prev()->Next( newPairHalfEdge );
    newPairHalfEdge->Next()->Prev( newPairHalfEdge );
    newVertex->IncidentHalfEdge( newHalfEdge );
}
//-----------------------------------------------------------------------------
// Split Vertex Make Edge
//-------------------------------------
//     ^         /                              ^     /
//      \       /                                \   / he1
//       \     /                                  \ V
//        \   / he1                                O = pos1
//         \ V                                     |
//          O     SVME( he1, he2, pos1, pos 2 )    | newHalfEdge (and its pair)
//         ^ \   ==============================>   V
//        /   \                                newVertex = pos2
//   he2 /     \                                  ^ \
//      /       \                            he2 /   \
//     /         V                              /     V
template <typename T>
void HalfEdgeModel<T>::SVME ( HEHalfEdge<T> * he1, HEHalfEdge<T> * he2, 
    Vector3<T> const * const pos1, Vector3<T> const * const pos2 )
{
    //---------------------------------------------------------------
    // Case the same halfedge, call Insert Vertex Split Edge
    if ( he1 == he2 ) {
        if ( pos2 != NULL ) {
            he1->Pair()->Vertex()->SetPosition( *pos2 );
        }
        IVSE( he1, pos1 );
        return;
    }
    //---------------------------------------------------------------
    // Case two different vertices, cancel spliting
    if ( he1->Pair()->Vertex() != he2->Pair()->Vertex() ) {
        return;
    }
    //---------------------------------------------------------------
    // Case one vertex, do spliting
    HEVertex<T> * vertex1, * newVertex;
    vertex1 = he1->Pair()->Vertex();
    //-----------------------------------------------------
    // Create a New Vertex and set the old vertex
    if ( pos1 != NULL ) {
        vertex1->SetPosition( *pos1 );
    }
    if ( pos2 != NULL ) {
        newVertex = new HEVertex<T>( *pos2, vertex1->GetNormal() );
    }
    else {
        newVertex = new HEVertex<T>( vertex1->GetPosition(), 
                                   vertex1->GetNormal() );
    }
    //-----------------------------------------------------
    // Update Vertex List and Number of Vertices
    //GetVertexList()->Append( newVertex );
    GetVertexList()->InsertAfter( newVertex );
    SetNoVertices( GetVertexList()->Size() );
    //SetNoVertices( GetNoVertices() + 1 );
    //-----------------------------------------------------
    // Crete New HalfEdges
    HEHalfEdge<T> * newHalfEdge = new HEHalfEdge<T>( 
                        vertex1,        // original vertex
                        he1->Face(),    // incident face
                        he1,            // previous halfedge
                        he1->Next(),    // next halfedge
                        NULL );         // pair halfedge
    HEHalfEdge<T> * newPairHalfEdge = new HEHalfEdge<T>( 
                        newVertex,      // original vertex
                        he2->Face(),    // incident face
                        he2,            // previous halfedge
                        he2->Next(),    // next halfedge
                        newHalfEdge );  // pair halfedge
    newHalfEdge->Pair( newPairHalfEdge );
    //-----------------------------------------------------
    // Rearrange Pointers
    newHalfEdge->Prev()->Next( newHalfEdge );
    newHalfEdge->Next()->Prev( newHalfEdge );
    newPairHalfEdge->Prev()->Next( newPairHalfEdge );
    newPairHalfEdge->Next()->Prev( newPairHalfEdge );
    newHalfEdge->Next()->Vertex( newVertex );
    newVertex->IncidentHalfEdge( newPairHalfEdge );
    //-----------------------------------------------------
}
//-----------------------------------------------------------------------------
// Join Vertex Kill Edge
//-------------------------------------
//     ^         /               ^     /
//      \       /                 \   / he_prev
//       \     /                   \ V
//        \   / he_prev             O
//         \ V                      |
//          O     JVKE( he, pos )   | he
//         ^ \   <===============   V
//        /   \                deleteVertex
//       /     \ he_next           ^ \
//      /       \                 /   \ he_next
//     /         V               /     V
template <typename T>
void HalfEdgeModel<T>::JVKE ( HEHalfEdge<T> * he, Vector3<T> const * const pos )
{
    if ( pos != NULL )  he->Vertex()->SetPosition( *pos );
    //-----------------------------------------------------
    // Change all halfedges that eminate from delete vertex to vertex of he
    // Except the starting halfedge, which is he->Pair(),
    // since we need to delete he->Pair()->Vertex().
    HEHalfEdge<T> * pStartHalfEdge = he->Pair();
    HEHalfEdge<T> * pCurrentHalfEdge = he->Next();
    while ( pCurrentHalfEdge != pStartHalfEdge ) {
        pCurrentHalfEdge->Vertex( he->Vertex() );
        pCurrentHalfEdge = pCurrentHalfEdge->Pair()->Next();
    }
    //-----------------------------------------------------
    // Rearrange and Delete Pointers
    he->Vertex()->IncidentHalfEdge( he->Next() );
    GetVertexList()->Delete( he->Pair()->Vertex() );    // delete the vertex
    he->Pair()->Face()->IncidentHalfEdge( he->Pair()->Next() );
    he->Face()->IncidentHalfEdge( he->Next() );
    he->Prev()->Next( he->Next() );
    he->Next()->Prev( he->Prev() );
    he->Pair()->Prev()->Next( he->Pair()->Next() );
    he->Pair()->Next()->Prev( he->Pair()->Prev() );
    delete he->Pair();          // delete the halfedge's pair
    delete he;                  // delete the halfedge
    //-----------------------------------------------------
    SetNoVertices( GetVertexList()->Size() );
    //std::cout << "NoVertices: " << GetNoVertices() << "\n";
}
//-----------------------------------------------------------------------------
// Split Face Make Edge
//-------------------------------------
//        O                              O
//       / ^                            /|^
//      /   \ he1                      / | \ he1
//     v     \                        v  |  \
//    O       O                      O  g|h  O
//    |       ^   SFME( he1, he2 )   |   |   ^  h is a new halfedge (pair of g)
//    v   f1  |  =================>  v f2| f1|  f1 is the original face
//    O       O                      O   |   O  f2 is a new face
//     \     ^                        \  |  ^   g is a new halfedge (pair of h)
//  he2 \   /                      he2 \ | /
//       v /                            v|/
//        O                              O
template <typename T>
void HalfEdgeModel<T>::SFME ( HEHalfEdge<T> * he1, HEHalfEdge<T> * he2 )
{
    //------------------------------------------------------------------
    // Cancel if he1 and he2 are pointing to the same halfedge
    if ( he1 == he2 )   return;
    //------------------------------------------------------------------
    // Cancel if he1 and he2 have different incident face
    if ( he1->Face() != he2->Face() )   return;
    //------------------------------------------------------------------
    // Create a new face f2
    HEFace<T> * f1 = he1->Face();
    HEFace<T> * f2 = new HEFace<T>( f1->GetNormal() );
    //GetFaceList()->Append( f2 );          // append f2 to the face list
    GetFaceList()->InsertAfter( f2 );       // append f2 to the face list
    SetNoFaces( GetFaceList()->Size() );    // update face size
    //------------------------------------------------------------------
    // Create new halfedges spliting f1 into f1 and f2
    HEHalfEdge<T> * h = new HEHalfEdge<T>( 
                        he1->Next()->Vertex(),  // original vertex
                        f1,                     // incident face
                        he1,                    // previous halfedge
                        he2->Next(),            // next halfedge
                        NULL );                 // pair halfedge
    HEHalfEdge<T> * g = new HEHalfEdge<T>( 
                        he2->Next()->Vertex(),  // original vertex
                        f2,                     // incident face
                        he2,                    // previous halfedge
                        he1->Next(),            // next halfedge
                        h );                    // pair halfedge
    h->Pair( g );
    //------------------------------------------------------------------
    // Rearrange all halfedges between h to g to have incident face f2
    HEHalfEdge<T> * pHalfEdge = he1->Next();
    while ( pHalfEdge != he2 ) {
        pHalfEdge->Face( f2 );
        pHalfEdge = pHalfEdge->Next();
    }
    //------------------------------------------------------------------
    // Rearrange pointers
    h->Prev()->Next( h );
    h->Next()->Prev( h );
    g->Prev()->Next( g );
    g->Next()->Prev( g );
    f2->IncidentHalfEdge( g );
}
//-----------------------------------------------------------------------------
// Join Face Kill Edge
//-------------------------------------
//        O                        O
//       / ^                      /|^
//      /   \                    / | \
//     v     \                  v /|  \
//    O       O                O  g|he O
//    |       ^   JFKE( he )   |   |/  ^  he is the delete halfedge (pair of g)
//    v   f1  | <============  v f2| f1|  f1 is the face to be kept
//    O       O                O   |   O  f2 is the delete face
//     \     ^                  \  |  ^   g is the delete halfedge (pair of h)
//      \   /                    \ | /
//       v /                      v|/
//        O                        O
template <typename T>
void HalfEdgeModel<T>::JFKE ( HEHalfEdge<T> * he )
{
    //------------------------------------------------------------------
    HEFace<T> * f1 = he->Face();
    HEFace<T> * f2 = he->Pair()->Face();
    //------------------------------------------------------------------
    f1->IncidentHalfEdge( he->Prev() );
    //------------------------------------------------------------------
    // Rearrange all halfedges in f2 to have incident face f1
    int i = 0;
    HEHalfEdge<T> * pHalfEdge = he->Pair()->Next();
    while ( pHalfEdge != he->Pair() ) {
        std::cout << ++i << std::endl;
        pHalfEdge->Face( f1 );
        pHalfEdge = pHalfEdge->Next();
    }

    std::cout << "Start Rearranging Pointers" << std::endl;

    //------------------------------------------------------------------
    // Rearrange Pointers
    he->Vertex()->IncidentHalfEdge( he->Pair()->Next() );
    he->Pair()->Vertex()->IncidentHalfEdge( he->Next() );
    he->Prev()->Next( he->Pair()->Next() );
    he->Next()->Prev( he->Pair()->Prev() );
    he->Pair()->Prev()->Next( he->Next() );
    he->Pair()->Next()->Prev( he->Prev() );

    std::cout << "Start Deleting Pointers" << std::endl;

    //------------------------------------------------------------------
    // Delete Pointers
    int count = 0;
    std::cout << ++count << std::endl;
    GetFaceList()->Delete( f2 );    // delete the face (f2)
    std::cout << ++count << std::endl;
    delete he->Pair();              // delete the halfedge's pair
    std::cout << ++count << std::endl;
    delete he;                      // delete the halfedge
    std::cout << ++count << std::endl;
    //-----------------------------------------------------
    std::cout << "SetNoFaces" << std::endl;
    SetNoFaces( GetFaceList()->Size() );
    //------------------------------------------------------------------
    std::cout << "Finish" << std::endl;
}
//-----------------------------------------------------------------------------
//=============================================================================




//=============================================================================
#ifdef  TAPs_ADD_STORED_POSITION
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeModel<T>::StoreCurrentPositionsToStoredPositions ()
{
    HEVertex<T> * pVertex = GetVertexList()->Head();
    while ( pVertex != NULL ) {
        pVertex->RefToStoredPosition() = pVertex->RefToPosition();
        pVertex = GetVertexList()->NextCurrent();
    }
}
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeModel<T>::RestorePositionsFromStoredPositions ()
{
    HEVertex<T> * pVertex = GetVertexList()->Head();
    while ( pVertex != NULL ) {
        pVertex->RefToPosition() = pVertex->RefToStoredPosition();
        pVertex = GetVertexList()->NextCurrent();
    }
}
//-----------------------------------------------------------------------------
#endif//TAPs_ADD_STORED_POSITION
//=============================================================================




//=============================================================================
#if defined(__gl_h_) || defined(__GL_H__)
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeModel<T>::DrawPositions () const
{
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    glPointSize( 3 );
    glDisable( GL_LIGHTING );
    //glDisable( GL_DEPTH_TEST );
    glColor3f( 0, 1, 1 );
    glBegin( GL_POINTS );

    HEVertex<T> * pVertex = GetVertexList()->Head();
    while ( pVertex != NULL ) {
        glVertex3fv( pVertex->RefToPosition().GetDataFloat() );
        pVertex = GetVertexList()->NextCurrent();
    }

    glEnd();
    glPopAttrib();
}
//-----------------------------------------------------------------------------
#ifdef  TAPs_ADD_STORED_POSITION
template <typename T>
void HalfEdgeModel<T>::DrawStoredPositions () const
{
    glPushAttrib( GL_ALL_ATTRIB_BITS );
    glPointSize( 3 );
    glDisable( GL_LIGHTING );
    //glDisable( GL_DEPTH_TEST );
    glColor3f( 0, 1, 1 );
    glBegin( GL_POINTS );

    HEVertex<T> * pVertex = GetVertexList()->Head();
    while ( pVertex != NULL ) {
        glVertex3fv( pVertex->RefToStoredPosition().GetDataFloat() );
        pVertex = GetVertexList()->NextCurrent();
    }

    glEnd();
    glPopAttrib();
}
#endif//TAPs_ADD_STORED_POSITION
//-----------------------------------------------------------------------------
#endif  //#if defined(__gl_h_) || defined(__GL_H__)
//=============================================================================




//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8