TAPsHEFace.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsHEFace.cpp

HE <==> Half-Edge
HEFace class is a class for 3D half-edge Face.
It contains:
  - normal
  - vertex loop
  - texture coordinates for the vertex loop
  - incident half-edge
It should contain a set of pointers to its vertices in CCW order.
Example:
           2-------1
            \       \
             \       \
              \       0
               \     /
                \   /
                 \ /
                  3

Not supposed to be a parent class.
Support only manifold objects.

SUKITTI PUNAK   (04/04/2005)
UPDATE          (04/15/2006)
******************************************************************************/
#include "TAPsHEFace.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
//=============================================================================
// Constructors
//-----------------------------------------------------------------------------
template <typename T>
HEFace<T>::HEFace ( Vector3<T> normal ) 
    : m_vNormal( normal ), 
      nIncidentHalfEdge( NULL ),
      nPrev( NULL ),
      nNext( NULL )
{}
//-----------------------------------------------------------------------------
template <typename T>
HEFace<T>::HEFace ( HEHalfEdge<T> * const incidentHalfEdge ) 
    : m_vNormal(), 
      nIncidentHalfEdge( incidentHalfEdge ),
      nPrev( NULL ),
      nNext( NULL )
{}  
//-----------------------------------------------------------------------------
template <typename T>
HEFace<T>::HEFace ( HEFace<T> const &he ) 
    : m_2DTexCoordsVector( he.m_2DTexCoordsVector ),
      m_vNormal( normal ),
      nIncidentHalfEdge( he.nIncidentHalfEdge ),
      nPrev( he.nPrev ),
      nNext( he.nNext )
{}
//-----------------------------------------------------------------------------
template <typename T>
HEFace<T>::~HEFace ()
{
//  nIncidentHalfEdge->ClearExceptItself();
//  delete nIncidentHalfEdge;
}
//-----------------------------------------------------------------------------

#ifdef  TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES

#else //TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
//=============================================================================
// Member Access for Texture Coordinates
//-----------------------------------------------------------------------------
template <typename T>
inline int HEFace<T>::GetNoTexCoords () const
{   return static_cast<int>(m_2DTexCoordsVector.size()) / 2;    }
//-----------------------------------------------------------------------------
template <typename T>
inline T HEFace<T>::GetTexCoordNoS ( int i ) const
{
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size())/2 );
    return m_2DTexCoordsVector[i*2];
}
//-----------------------------------------------------------------------------
template <typename T>
inline T HEFace<T>::GetTexCoordNoT ( int i ) const
{
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size())/2 );
    return m_2DTexCoordsVector[i*2 + 1];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void HEFace<T>::GetTexCoordNoS ( int i, T &s ) const
{
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size())/2 );
    s = m_2DTexCoordsVector[i*2];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void HEFace<T>::GetTexCoordNoT ( int i, T &t ) const
{
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size())/2 );
    t = m_2DTexCoordsVector[i*2 + 1];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void HEFace<T>::SetTexCoordNoS ( int i, T s )
{
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size())/2 );
    m_2DTexCoordsVector[i*2] = s;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void HEFace<T>::SetTexCoordNoT ( int i, T t )
{
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size())/2 );
    m_2DTexCoordsVector[i*2 + 1] = t;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void HEFace<T>::GetTexCoordNo ( int i, T &s, T &t ) const
{
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size())/2 );
    s = m_2DTexCoordsVector[i*2    ];
    t = m_2DTexCoordsVector[i*2 + 1];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void HEFace<T>::SetTexCoordNo ( int i, T s, T t )
{   
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size())/2 );
    m_2DTexCoordsVector[i*2    ] = s;
    m_2DTexCoordsVector[i*2 + 1] = t;
}
//-----------------------------------------------------------------------------
template <typename T>
inline T HEFace<T>::GetTexCoordHalfNo ( int i ) const
{   
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size()) );
    return m_2DTexCoordsVector[i];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void HEFace<T>::GetTexCoordHalfNo ( int i, T &v ) const
{   
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size()) );
    v = m_2DTexCoordsVector[i];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void HEFace<T>::SetTexCoordHalfNo ( int i, T v )
{   
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size()) );
    m_2DTexCoordsVector[i] = v;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void HEFace<T>::InsertTexCoordNo ( int i, T s, T t )
{   
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size())/2 );
    m_2DTexCoordsVector.insert( i*2,   s );
    m_2DTexCoordsVector.insert( i*2+1, t );
}
//-----------------------------------------------------------------------------
template <typename T>
inline void HEFace<T>::AppendTexCoord ( T s, T t )
{   
    m_2DTexCoordsVector.push_back( s );
    m_2DTexCoordsVector.push_back( t );
}
//-----------------------------------------------------------------------------
template <typename T>
inline void HEFace<T>::RemoveTexCoordNo ( int i )
{   
    assert( 0 <= i && i < static_cast<int>(m_2DTexCoordsVector.size())/2 );
    m_2DTexCoordsVector.erase(i*2, i*2+2);
}
//-----------------------------------------------------------------------------
#endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES


//=============================================================================
// Operations
//-----------------------------------------------------------------------------
template <typename T>
HEFace<T> * HEFace<T>::Insert ( HEFace<T> * const n )
{
    HEFace<T> *c = nNext;
    n->nNext = c;
    n->nPrev = this;
    nNext    = n;
    c->nPrev = n;
    return n;
}
//-----------------------------------------------------------------------------
template <typename T>
HEFace<T> * HEFace<T>::Remove ()
{
    if ( nPrev ) {
        nPrev->nNext = nNext;
        nPrev = NULL;
    }
    if ( nNext ) {
        nNext->nPrev = nPrev;
        nNext = NULL;
    }
    return this;
}
//-----------------------------------------------------------------------------
template <typename T>
void HEFace<T>::Delete ()
{
    delete Remove();
}
//-----------------------------------------------------------------------------
template <typename T>
HEFace<T> * HEFace<T>::Splice ( HEFace<T> * const n )
{
    HEFace<T> *a  = this;
    HEFace<T> *an = a->nNext;
    HEFace<T> *bn = b->nNext;
    a->nNext = bn;
    b->nNext = an;
    an->nPrev = b;
    bn->nPrev = a;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Data Conversion(s) / Operation(s)
//-----------------------------------------------------------------------------
template <typename T>
int HEFace<T>::CountNumberOfVertices () const
{
    int numberOfVertices = 0;
    if ( nIncidentHalfEdge == NULL )    return 0;
    //--------------------------------------------------------------------
    HEHalfEdge<T> firstHalfEdge = nIncidentHalfEdge;
    HEHalfEdge<T> currentHalfEdge = nIncidentHalfEdge;
    do {
        ++numberOfVertices;
        currentHalfEdge = currentHalfEdge->Next();
    } while ( firstHalfEdge != currentHalfEdge );
    //--------------------------------------------------------------------
    return numberOfVertices;
}
//-----------------------------------------------------------------------------
template <typename T>
std::vector< HEVertex<T> * const > HEFace<T>::GetPtrsToVertices ()
{
    std::vector< HEVertex<T> * const > ptrsToVertices;
    if ( nIncidentHalfEdge == NULL )    return ptrsToVertices;
    //--------------------------------------------------------------------
    HEHalfEdge<T> * firstHalfEdge = nIncidentHalfEdge;
    HEHalfEdge<T> * currentHalfEdge = nIncidentHalfEdge;
    do {
        ptrsToVertices.push_back( currentHalfEdge->Vertex() );
        currentHalfEdge = currentHalfEdge->Next();
    } while ( firstHalfEdge != currentHalfEdge );
    //--------------------------------------------------------------------
    return ptrsToVertices;
}
//-----------------------------------------------------------------------------
template <typename T>
std::vector< HEVertex<T> const * const > HEFace<T>::GetPtrsToVertices () const
{
    std::vector< HEVertex<T> const * const > ptrsToVertices;
    if ( nIncidentHalfEdge == NULL )    return ptrsToVertices;
    //--------------------------------------------------------------------
    HEHalfEdge<T> * firstHalfEdge = nIncidentHalfEdge;
    HEHalfEdge<T> * currentHalfEdge = nIncidentHalfEdge;
    do {
        ptrsToVertices.push_back( currentHalfEdge->Vertex() );
        currentHalfEdge = currentHalfEdge->Next();
    } while ( firstHalfEdge != currentHalfEdge );
    //--------------------------------------------------------------------
    return ptrsToVertices;
}
//-----------------------------------------------------------------------------
template <typename T>
std::vector< HEVertex<T> * const > 
HEFace<T>::GetPtrsToVerticesAndNumberOfVertices ( int & numberOfVertices )
{
    numberOfVertices = 0;
    std::vector< HEVertex<T> * const > ptrsToVertices;
    if ( nIncidentHalfEdge == NULL )    return ptrsToVertices;
    //--------------------------------------------------------------------
    HEHalfEdge<T> * firstHalfEdge = nIncidentHalfEdge;
    HEHalfEdge<T> * currentHalfEdge = nIncidentHalfEdge;
    do {
        ++numberOfVertices;
        ptrsToVertices.push_back( currentHalfEdge->Vertex() );
        currentHalfEdge = currentHalfEdge->Next();
    } while ( firstHalfEdge != currentHalfEdge );
    //--------------------------------------------------------------------
    return ptrsToVertices;
}
//-----------------------------------------------------------------------------
template <typename T>
std::vector< HEVertex<T> const * const > 
HEFace<T>::GetPtrsToVerticesAndNumberOfVertices ( int & numberOfVertices ) const
{
    numberOfVertices = 0;
    std::vector< HEVertex<T> const * const > ptrsToVertices;
    if ( nIncidentHalfEdge == NULL )    return ptrsToVertices;
    //--------------------------------------------------------------------
    HEHalfEdge<T> * firstHalfEdge = nIncidentHalfEdge;
    HEHalfEdge<T> * currentHalfEdge = nIncidentHalfEdge;
    do {
        ++numberOfVertices;
        ptrsToVertices.push_back( currentHalfEdge->Vertex() );
        currentHalfEdge = currentHalfEdge->Next();
    } while ( firstHalfEdge != currentHalfEdge );
    //--------------------------------------------------------------------
    return ptrsToVertices;
}
//-----------------------------------------------------------------------------
template <typename T>
std::vector< HEVertex<T> * const > HEFace<T>::GetPtrsToVertices ( int i )
{
    std::vector< HEVertex<T> * const > ptrsToVertices;
    if ( nIncidentHalfEdge == NULL )    return ptrsToVertices;
    //--------------------------------------------------------------------
    int count = 0;
    HEHalfEdge<T> * firstHalfEdge = nIncidentHalfEdge;
    HEHalfEdge<T> * currentHalfEdge = nIncidentHalfEdge;
    do {
        ++count;
        ptrsToVertices.push_back( currentHalfEdge->Vertex() );
        currentHalfEdge = currentHalfEdge->Next();
    } while ( firstHalfEdge != currentHalfEdge && count < i );
    //--------------------------------------------------------------------
    return ptrsToVertices;
}
//-----------------------------------------------------------------------------
template <typename T>
std::vector< HEVertex<T> const * const > HEFace<T>::GetPtrsToVertices ( int i ) const
{
    std::vector< HEVertex<T> const * const > ptrsToVertices;
    if ( nIncidentHalfEdge == NULL )    return ptrsToVertices;
    //--------------------------------------------------------------------
    int count = 0;
    HEHalfEdge<T> * firstHalfEdge = nIncidentHalfEdge;
    HEHalfEdge<T> * currentHalfEdge = nIncidentHalfEdge;
    do {
        ++count;
        ptrsToVertices.push_back( currentHalfEdge->Vertex() );
        currentHalfEdge = currentHalfEdge->Next();
    } while ( firstHalfEdge != currentHalfEdge && count < i );
    //--------------------------------------------------------------------
    return ptrsToVertices;
}
//-----------------------------------------------------------------------------
template <typename T>
std::vector< Vector3<T> > HEFace<T>::GetCopyOfVertexPositions () const
{
    std::vector< Vector3<T> > vertexPositions;
    if ( nIncidentHalfEdge == NULL )    return vertexPositions;
    //--------------------------------------------------------------------
    HEHalfEdge<T> * firstHalfEdge = nIncidentHalfEdge;
    HEHalfEdge<T> * currentHalfEdge = nIncidentHalfEdge;
    do {
        ++count;
        vertexPositions.push_back( currentHalfEdge->Vertex()->GetPosition() );
        currentHalfEdge = currentHalfEdge->Next();
    } while ( firstHalfEdge != currentHalfEdge );
    //--------------------------------------------------------------------
    return vertexPositions;
}
//-----------------------------------------------------------------------------
template <typename T>
std::vector< Vector3<T> > HEFace<T>::GetCopyOfVertexPositions ( int i ) const
{
    std::vector< Vector3<T> > vertexPositions;
    if ( nIncidentHalfEdge == NULL )    return vertexPositions;
    //--------------------------------------------------------------------
    int count = 0;
    HEHalfEdge<T> * firstHalfEdge = nIncidentHalfEdge;
    HEHalfEdge<T> * currentHalfEdge = nIncidentHalfEdge;
    do {
        ++count;
        vertexPositions.push_back( currentHalfEdge->Vertex()->GetPosition() );
        currentHalfEdge = currentHalfEdge->Next();
    } while ( firstHalfEdge != currentHalfEdge && count < i );
    //--------------------------------------------------------------------
    return vertexPositions;
}
//-----------------------------------------------------------------------------

//===================================================================
#ifdef  TAPs_ENABLE_FACE_VERTEX_COLOR
//-------------------------------------------------------------------
    template <typename T>
    void HEFace<T>::InitVertexColorList( int i )
    {
        m_sviVertexColorList.resize( i );
    }

    template <typename T>
    int HEFace<T>::GetVertexColorNo( int i ) const
    {
        return m_sviVertexColorList.at( i );
    }

    template <typename T>
    void HEFace<T>::SetVertexColorNo( int i, int vNo )
    {
        m_sviVertexColorList.at( i ) = vNo;
    }
//-------------------------------------------------------------------
#endif//TAPs_ENABLE_FACE_VERTEX_COLOR
//===================================================================

//===================================================================
#ifdef  TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
//-------------------------------------------------------------------
    template <typename T>
    void HEFace<T>::InitVertexTextureList( int i )
    {
        m_sviVertexTextureList.resize( i );
    }

    template <typename T>
    int HEFace<T>::GetVertexTextureNo( int i ) const
    {
        return m_sviVertexTextureList.at( i );
    }

    template <typename T>
    void HEFace<T>::SetVertexTextureNo( int i, int vNo )
    {
        m_sviVertexTextureList.at( i ) = vNo;
    }
//-------------------------------------------------------------------
#endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
//===================================================================

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