TAPsHalfEdgeTrigonalModel.cpp

Go to the documentation of this file.

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

HalfEdgeTrigonalModel, a subclass of HalfEdgeModel, is for a triangular mesh.
(See HalfEdgeTrigonalModel.hpp for details)

SUKITTI PUNAK   (06/15/2006)
UPDATE          (06/15/2006)
******************************************************************************/
#include "TAPsHalfEdgeTrigonalModel.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.

//-----------------------------------------------------------------------------
// DEBUG ENABLE
#ifdef TAPs_ENABLE_DEBUG
    #define DEBUG_MESSAGE_TAPs_HALF_EDGE_TRIGONAL_MODEL
#endif

//#ifndef
    //#define DEBUG_MESSAGE_TAPs_HALF_EDGE_MODEL
//#endif
//-----------------------------------------------------------------------------

BEGIN_NAMESPACE_TAPs__OpenGL
//=============================================================================
//-----------------------------------------------------------------------------
// default constructor
template <typename T>
HalfEdgeTrigonalModel<T>::HalfEdgeTrigonalModel ()
    : HalfEdgeModel<T>()
{}
//-----------------------------------------------------------------------------
// destructor
template <typename T>
HalfEdgeTrigonalModel<T>::~HalfEdgeTrigonalModel ()
{
    #ifdef DEBUG_MESSAGE_TAPs_HALF_EDGE_TRIGONAL_MODEL
    std::cout << "HalfEdgeTrigonalModel<" << typeid(T).name() << "> Destructor\n";
    #endif
}
//-----------------------------------------------------------------------------
// Initialize
// a virtual fn from Model class
template <typename T>
void HalfEdgeTrigonalModel<T>::Initialize ()
{
    // Model Initialization
    CalAndSetNormals();
    ApplyMaterial();
    CalBoundingAABB();
    CalBoundingEllipsoid();
    CalBoundingSphere();

    // For Fast Access
    //SetListOfVertexPositionsAndNormals();

    /*
    std::cout << *this << std::endl;
    //*/
}
/*
//-----------------------------------------------------------------------------
// Get Half Length
template <typename T>
T HalfEdgeTrigonalModel<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 HalfEdgeTrigonalModel<T>::CalAndSetNormals ()
{
    CalAndSetFaceNormalsNotNormalized();
//  DetermineFaceRings();
    CalAndSetVertexNormals();
    NormalizeFaceNormals();
}
//-----------------------------------------------------------------------------
// Calculate and set the face normals (without normalized)
template <typename T>
void HalfEdgeTrigonalModel<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();
    }

    /*
    for ( int i = 0; i < m_iNoFaces; ++i ) {
        m_prFace[i].SetNormal(
              (   m_prXVertex[ m_prFace[i].GetVertexNo( 1 ) ].GetPosition() 
                - m_prXVertex[ m_prFace[i].GetVertexNo( 0 ) ].GetPosition() )
            ^ (   m_prXVertex[ m_prFace[i].GetVertexNo( 2 ) ].GetPosition() 
                - m_prXVertex[ m_prFace[i].GetVertexNo( 1 ) ].GetPosition() )
        );
    }
    */
}
//-----------------------------------------------------------------------------
// Normalize the face normals
template <typename T>
inline void HalfEdgeTrigonalModel<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();
    }

    //for ( int i = 0; i < m_iNoFaces; ++i ) {
    //  const_cast< Vector3<T> * >( &m_prFace[i].GetNormal() )->Normalized();
    //  //m_prFace[i].GetNormal().Normalized();
    //}
}
//-----------------------------------------------------------------------------
// Calculate and set the vertex normals
template <typename T>
inline void HalfEdgeTrigonalModel<T>::CalAndSetVertexNormals ()
{
    HEVertex<T> *vertex = m_listVertex->Head();
    HEHalfEdge<T> *halfEdge;
    #ifdef DEBUG_MESSAGE_TAPs_HALF_EDGE_TRIGONAL_MODEL
    std::cout << "FIND VERTEX NORMAL" << std::endl;
    #endif
    while ( vertex ) {
        Vector3<T> vNormal;
        halfEdge = vertex->IncidentHalfEdge();
        #ifdef DEBUG_MESSAGE_TAPs_HALF_EDGE_TRIGONAL_MODEL_HPP
        std::cout << *halfEdge << std::endl;
        #endif
        /*
        if ( halfEdge->Pair()->Next() != NULL ) {
            do {
                vNormal += halfEdge->Face()->GetNormal();
                halfEdge = halfEdge->Pair()->Next();
            } while ( halfEdge != vertex->IncidentHalfEdge() );
        }
        else {
            do {
                vNormal += halfEdge->Face()->GetNormal();
                halfEdge = halfEdge->Pair()->Prev();
            } while ( halfEdge != vertex->IncidentHalfEdge() );
        }
        //*/
        //*
        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();
    }

    /*
    for ( int v = 0; v < m_iNoVertices; ++v ) {
        Vector3<T> vNormal;
        for ( int f = 0; f < static_cast<int>( m_prXVertex[v].GetFaceRing().size() ); ++f ) {
            vNormal += m_prFace[ m_prXVertex[v].GetFaceRing()[f] ].GetNormal();
        }
        m_prXVertex[v].SetNormal( vNormal.Normalized() );
    }
    */
}

/*
//******************************************************************************
// Transformation by Model's translation, rotation, and scale
//******************************************************************************
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeTrigonalModel<T>::TransformByTranslationRatationAndScale ()
{
    HEVertex<T> * heVertex = GetVertexList()->Head();
    //--------------------------------------------------------------------
    // Adjust Center of X-, Y-, And Z-Axes
    Vector3<T> vTransform = GetTransform().GetTranslation();
    if ( vTransform.SquaredLength() > Math<T>::ZERO ) {
        while ( heVertex ) {
            heVertex->SetPosition( heVertex->GetPosition() + vTransform );
            heVertex = heVertex->Next();
        }
        GetTransform().SetTranslation( Math<T>::ZERO, Math<T>::ZERO, Math<T>::ZERO );
    }
    //--------------------------------------------------------------------
    // Adjust Rotation of X-, Y-, And Z-Axes
    vTransform = GetTransform().GetRotationAngles();
    Vector3<T> vPos;
    if ( vTransform[0] != Math<T>::ZERO ) {
        T deg = static_cast<T>( vTransform[0] * Math<T>::PI / 180.0 );
        T c = Math<T>::Cos( deg );
        T s = Math<T>::Sin( deg );
        heVertex = GetVertexList()->Head();
        while ( heVertex ) {
            vPos = heVertex->GetPosition();
            heVertex->SetPosition( vPos[0], vPos[1]*c - vPos[2]*s, vPos[1]*s + vPos[2]*c ) ;
            heVertex = heVertex->Next();
        }
        //GetTransform().SetRotationAxisAngle( 0, Math<T>::ZERO );
    }
    if ( vTransform[1] != Math<T>::ZERO ) {
        T deg = static_cast<T>( vTransform[1] * Math<T>::PI / 180.0 );
        T c = Math<T>::Cos( deg );
        T s = Math<T>::Sin( deg );
        heVertex = GetVertexList()->Head();
        while ( heVertex ) {
            vPos = heVertex->GetPosition();
            heVertex->SetPosition( vPos[0]*c + vPos[2]*s, vPos[1], vPos[2]*c - vPos[0]*s );
            heVertex = heVertex->Next();
        }
        //GetTransform().SetRotationAxisAngle( 1, Math<T>::ZERO );
    }
    if ( vTransform[2] != Math<T>::ZERO ) {
        T deg = static_cast<T>( vTransform[2] * Math<T>::PI / 180.0 );
        T c = Math<T>::Cos( deg );
        T s = Math<T>::Sin( deg );
        heVertex = GetVertexList()->Head();
        while ( heVertex ) {
            vPos = heVertex->GetPosition();
            heVertex->SetPosition( vPos[0]*c - vPos[1]*s, vPos[0]*s + vPos[1]*c, vPos[2] );
            heVertex = heVertex->Next();
        }
        //GetTransform().SetRotationAxisAngle( 2, Math<T>::ZERO );
    }
    //--------------------------------------------------------------------
    // Adjust Scale of X-, Y-, And Z-Axes
    vTransform = GetTransform().GetScale();
    heVertex = GetVertexList()->Head();
    //if ( vTransform.SquaredLength() > Math<T>::ZERO ) {}
    while ( heVertex ) {
        heVertex->SetPosition( 
            heVertex->GetPosition()[0] * vTransform[0], 
            heVertex->GetPosition()[1] * vTransform[1], 
            heVertex->GetPosition()[2] * vTransform[2] 
        );
        heVertex = heVertex->Next();
    }
    //--------------------------------------------------------------------
    // Reset Transformation
    GetTransform().Reset();
    //--------------------------------------------------------------------
    // Recalculate Bounding Volume(s)
    CalBoundingAABB();
    CalBoundingEllipsoid();
    CalBoundingSphere();
}
//-----------------------------------------------------------------------------
//******************************************************************************
//*/

//******************************************************************************
// Virtual Fns from Collision Detection from ColDetSupport class
//******************************************************************************
/*
//-----------------------------------------------------------------------------
template <typename T>
void HalfEdgeTrigonalModel<T>::CalBoundingAABB ()
{
    HEVertex<T> *vertex = m_listVertex->Head();
    m_paBoundingAABB[0] = m_paBoundingAABB[1] = vertex->GetPosition();
    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 HalfEdgeTrigonalModel<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 HalfEdgeTrigonalModel<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 HalfEdgeTrigonalModel<T>::BuildBVHTree ( TAPs::Enum::CD treeType )
{
    // Call a static fn from BVHTree class
    // m_pBVHTree is inherited from ColDetSupport class
    m_pBVHTree = TAPs::CD::BuildBVHTree<T>( GetTransform(), m_listFace, treeType );
}
//-----------------------------------------------------------------------------
//******************************************************************************

/*
//******************************************************************************
// For Fast Access (e.g. for OpenGL Drawing)
//******************************************************************************
//-----------------------------------------------------------------------------
// SetListOfVertexPositions
template <typename T>
void HalfEdgeTrigonalModel<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();
    }
}
//-----------------------------------------------------------------------------
//******************************************************************************
//*/

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