TAPsHEVertex.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsHEVertex.hpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (04/04/2005)
UPDATE          (12/03/2010)
******************************************************************************/
#ifndef TAPs_HE_VERTEX_HPP
#define TAPs_HE_VERTEX_HPP

#include "../../Core/TAPsLib.hpp"
#include "../../DataStructure/TAPsFlag.hpp"
#ifdef  TAPs_ADD_DEFORMABLE_MODEL_BASED_ON_FEM
    #include "../../GeometricDataStructure/TAPsBaseBarycentricCoordsForVertexRef.hpp"
#endif//TAPs_ADD_DEFORMABLE_MODEL_BASED_ON_FEM

#include <vector>

template <typename T> class HEHalfEdge;

BEGIN_NAMESPACE_TAPs
//=============================================================================
template <typename T>
class HEVertex {
//=============================================================================
protected:

#ifdef  TAPs_USE_DATA_POOL
    T * m_paPosition;   
    T * m_paNormal;     
#else //TAPs_USE_DATA_POOL

//public:
//  int         Counter1;           //!< use for averaging position
//protected:
//  Vector3<T>  m_vPosition_2;      //!< 2nd position used, for example, storing old position

    Vector3<T>  m_vPosition;        
    Vector3<T>  m_vNormal;          

#ifdef  TAPs_ADD_STORED_POSITION
    Vector3<T>  m_vStoredPosition;      
#endif//TAPs_ADD_STORED_POSITION


#endif//TAPs_USE_DATA_POOL

#ifdef  TAPs_ADD_DEFORMABLE_MODEL_BASED_ON_FEM
    unsigned int    m_id;           
    bool            m_bMarked;      
    BaseBarycentricCoordsForVertexRef<T> *  m_pBarycentric; 
#endif//TAPs_ADD_DEFORMABLE_MODEL_BASED_ON_FEM

    HEHalfEdge<T> * nIncidentHalfEdge;  
    HEVertex<T> *   nPrev;      
    HEVertex<T> *   nNext;      

#ifdef  TAPs_ADVANCED_SIMULATION
public:
    DS::SimulationFlags     SimFlags;   
#endif//TAPs_ADVANCED_SIMULATION

//=============================================================================
public:
    //-------------------------------------------------------------------------
    // Output Operator <<
    friend std::ostream & operator<< ( std::ostream &output, HEVertex<T> const &v )
    {
        output  << "HEVertex<" << typeid(T).name() << ">( "
                << " with Position:" << v.GetPosition()
                << " Normal:" << v.GetNormal()
                << " and Incident Edge:" << v.nIncidentHalfEdge;

        #ifdef  TAPs_ADD_DEFORMABLE_MODEL_BASED_ON_FEM
        if ( v.m_pBarycentric ) {
            output << "\nBarycentric: " << v.m_pBarycentric << "\t" << *(v.m_pBarycentric) << "\n";
        }
        #endif//TAPs_ADD_DEFORMABLE_MODEL_BASED_ON_FEM

        return output;
    }
    //-------------------------------------------------------------------------
    HEVertex ( T x, T y, T z, 
               T u, T v, T w,
           #ifdef  TAPs_USE_DATA_POOL
               T * pPosition,   T * pNormal,
           #endif//TAPs_USE_DATA_POOL
               HEHalfEdge<T> * const incidentHalfEdge = NULL
             );
    HEVertex ( Vector3<T> position, Vector3<T> normal,
           #ifdef  TAPs_USE_DATA_POOL
                T * pPosition,  T * pNormal,
           #endif//TAPs_USE_DATA_POOL
               HEHalfEdge<T> * const incidentHalfEdge = NULL
             );
    HEVertex ( Vector3<T> position,
           #ifdef  TAPs_USE_DATA_POOL
                T * pPosition,  T * pNormal,
           #endif//TAPs_USE_DATA_POOL
               HEHalfEdge<T> * const incidentHalfEdge = NULL
             );
    HEVertex ( T position[3],
           #ifdef  TAPs_USE_DATA_POOL
                T * pPosition,  T * pNormal,
           #endif//TAPs_USE_DATA_POOL
               HEHalfEdge<T> * const incidentHalfEdge = NULL
             );
    HEVertex ( T position[3], T normal[3],
           #ifdef  TAPs_USE_DATA_POOL
                T * pPosition,  T * pNormal,
           #endif//TAPs_USE_DATA_POOL
               HEHalfEdge<T> * const incidentHalfEdge = NULL
             );
private:
    HEVertex ( HEVertex<T> const &v );  

    static unsigned int g_Total;    
public:
    virtual ~HEVertex ();
    //-------------------------------------------------------------------------
    // Get/Set Fn(s)
#ifdef  TAPs_USE_DATA_POOL

    inline void SetPosition( Vector3<T> const & position )
    { m_paPosition[0] = position[0];  m_paPosition[1] = position[1];  m_paPosition[2] = position[2]; }
    inline void SetPosition( T x, T y, T z )
    { m_paPosition[0] = x; m_paPosition[1] = y; m_paPosition[2] = z; }
    inline Vector3<T> GetPosition() const
    { return Vector3<T>( m_paPosition[0], m_paPosition[1], m_paPosition[2] ); }
    inline T * GetProtectedPosition()   { return m_paPosition; }

    inline void SetNormal( Vector3<T> const & normal )
    { m_paNormal[0] = normal[0]; m_paNormal[1] = normal[1]; m_paNormal[2] = normal[2]; }
    inline void SetNormal( T x, T y, T z )
    { m_paNormal[0] = x; m_paNormal[1] = y; m_paNormal[2] = z; }
    inline Vector3<T> GetNormal() const
    { return Vector3<T>( m_paNormal[0], m_paNormal[1], m_paNormal[2] ); }
    inline T * GetPtrToNormal()     { return m_paNormal; }

    //inline Vector3<T> const & RefToPosition () const  { return *m_paPosition; }
    //inline Vector3<T>     & RefToPosition ()          { return *m_paPosition; }

#else //TAPs_USE_DATA_POOL

    //inline void SetPosition_2 ( Vector3<T> const & position_2 )   { m_vPosition_2 = position_2; }
    //inline void SetPosition_2 ( T x, T y, T z )                   { m_vPosition_2.SetXYZ( x, y, z ); }
    //inline Vector3<T> const & GetPosition_2 () const      { return m_vPosition_2; }
    //inline Vector3<T>     & GetProtectedPosition_2 ()     { return m_vPosition_2; }

    inline void SetPosition ( Vector3<T> const & position ) { m_vPosition = position; }
    inline void SetPosition ( T x, T y, T z )               { m_vPosition.SetXYZ( x, y, z ); }
    inline Vector3<T> const & GetPosition () const          { return m_vPosition; }
    inline Vector3<T>       & GetProtectedPosition ()       { return m_vPosition; }

    inline void SetNormal ( Vector3<T> const & normal ) { m_vNormal = normal; }
    inline void SetNormal ( T x, T y, T z )             { m_vNormal.SetXYZ( x, y, z ); }
    inline Vector3<T> const & GetNormal () const        { return m_vNormal; }
    inline Vector3<T>       & GetProtectedNormal ()     { return m_vNormal; }

    inline Vector3<T> const & RefToPosition () const    { return m_vPosition; }
    inline Vector3<T>       & RefToPosition ()          { return m_vPosition; }

    #ifdef  TAPs_ADD_STORED_POSITION
    inline Vector3<T> const & RefToStoredPosition () const  { return m_vStoredPosition; }
    inline Vector3<T>       & RefToStoredPosition ()            { return m_vStoredPosition; }
    #endif//TAPs_ADD_STORED_POSITION


#endif//TAPs_USE_DATA_POOL
    //-------------------------------------------------------------------------
    // Get/Set Fn(s)
    inline HEHalfEdge<T> * IncidentHalfEdge() const
    { return nIncidentHalfEdge; }
    inline void IncidentHalfEdge( HEHalfEdge<T> * const incidentHalfEdge )
    { nIncidentHalfEdge = incidentHalfEdge; }

#ifdef  TAPs_ADD_DEFORMABLE_MODEL_BASED_ON_FEM

    inline unsigned int GetID () const  { return m_id; }
    inline void SetID ( unsigned int id )   { m_id = id; }
    inline unsigned int GetMarkedStatus () const    { return m_bMarked; }
    inline void SetMarkedStatus ( bool b )  { m_bMarked = b; }
    inline BaseBarycentricCoordsForVertexRef<T> * GetBarycentricPtr ()  { return m_pBarycentric; }
    inline void SetBarycentricPtr ( BaseBarycentricCoordsForVertexRef<T> * ptr )    { m_pBarycentric = ptr; }
#endif//TAPs_ADD_DEFORMABLE_MODEL_BASED_ON_FEM

    static inline unsigned int GetTotal ()  { return g_Total; }

    //-------------------------------------------------------------------------
    // Position Member Access i.e. return x, y, or z of this vertex position
    inline T & operator[] ( int i );
    inline T const & operator[] ( int i ) const;
    //-------------------------------------------------------------------------
    // Operations

    inline HEVertex<T> * Prev () const { return nPrev; }
    inline HEVertex<T> * Next () const { return nNext; }
    inline void Prev ( HEVertex<T> * const v ) { nPrev = v; }
    inline void Next ( HEVertex<T> * const v ) { nNext = v; }

    HEVertex<T> * Insert ( HEVertex<T> * const n );
    HEVertex<T> * Remove ();
    inline void   Delete ();
    HEVertex<T> * Splice ( HEVertex<T> * const n );

    //-------------------------------------------------------------------------
    std::vector< HEVertex<T> * >    FindTheFirstRingOfVertices ();
    //-------------------------------------------------------------------------

#if defined(__gl_h_) || defined(__GL_H__)
public:
    virtual void Draw () const;

    #ifdef  TAPs_ADD_STORED_POSITION

    virtual void DrawStoredPosition () const;
    #endif//TAPs_ADD_STORED_POSITION

#endif

}; // END CLASS HEVertex
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
//#if !defined( TAPs_USE_EXPORT )
    #include "TAPsHEVertex.cpp"
//#endif
//-----------------------------------------------------------------------------
#endif
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----