TAPsPointManager.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsPointManager.cpp

Inherited from class BasePointManager

SUKITTI PUNAK   (07/21/2005)
UPDATE          (07/30/2005)
******************************************************************************/
#include "TAPsPointManager.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_POINT_MANAGER
#endif
//-----------------------------------------------------------------------------
BEGIN_NAMESPACE_TAPs__OpenGL
//=============================================================================
//-----------------------------------------------------------------------------
// Static Data Members
template <typename T> const int PointManager<T>::K_NUM_POINTS       = 10;
template <typename T> const T   PointManager<T>::K_REGULAR_SIZE     = 10;
template <typename T> const T   PointManager<T>::K_HIGHLIGHTED_SIZE = 10;
template <typename T> const T   PointManager<T>::K_SELECTED_SIZE    = 10;
template <typename T> const Vector3<T> PointManager<T>::K_REGULAR_COLOR( 1.0, 1.0, 1.0 );
template <typename T> const Vector3<T> PointManager<T>::K_HIGHLIGHTED_COLOR( 0.0, 1.0, 0.0 );
template <typename T> const Vector3<T> PointManager<T>::K_SELECTED_COLOR( 1.0, 0.0, 0.0 );
//-----------------------------------------------------------------------------
// Default Constructor
template <typename T>
PointManager<T>::PointManager ()
    : BasePointManager<T>(),
      m_uiPointDisplayList( 0 )
{}
//-----------------------------------------------------------------------------
// Destructor
template <typename T>
PointManager<T>::~PointManager ()
{}
//-----------------------------------------------------------------------------
// Setup
// creates a random cloud of points with random colors within a canonical view.
template <typename T>
void PointManager<T>::Setup ( OpenGLBaseViewManager<T> *pViewManager )
{
    m_pViewManager = pViewManager;
    m_svPointList.reserve( K_NUM_POINTS );
    //----------------------------------------------------------------
    // Create a random set of points in a canonical volume
    srand( time(NULL) );
    for ( int i = 0; i < K_NUM_POINTS; ++i ) {
        PointStruct point;
        point.m_vPosition[0] = ( static_cast<T>( rand() )/RAND_MAX - 0.5 ) * 2;
        point.m_vPosition[1] = ( static_cast<T>( rand() )/RAND_MAX - 0.5 ) * 2;
        point.m_vPosition[2] = ( static_cast<T>( rand() )/RAND_MAX - 0.5 ) * 2;
        point.m_uiState = REGULAR;
        m_svPointList.push_back( point );
    }
}
//-----------------------------------------------------------------------------
// Cleanup
template <typename T>
void PointManager<T>::Cleanup ()
{
    m_svPointList.clear();
}
//-----------------------------------------------------------------------------
// GetPointPosition
// returns a const reference to a point position given a valid index.
// Point positions are in the world coordinates.
template <typename T>
const Vector3<T> & PointManager<T>::GetPointPosition ( int i ) const
{
    assert( 0 <= i && i < static_cast<int>( m_svPointList.size() ) );
    return m_svPointList[i].m_vPosition;
}
//-----------------------------------------------------------------------------
// GetPointPosition
// returns a non-const reference to a point position given a valid index.
// Point positions are in the world coordinates.
template <typename T>
Vector3<T> & PointManager<T>::GetPointPosition ( int i )
{
    assert( 0 <= i && i < static_cast<int>( m_svPointList.size() ) );
    return m_svPointList[i].m_vPosition;
}
//-----------------------------------------------------------------------------
// SetPointPosition
// sets the position of a point given a valid index.
// Point positions are in the world coordinates.
template <typename T>
void PointManager<T>::SetPointPosition ( int i, const Vector3<T> &position )
{
    assert( 0 <= i && i < static_cast<int>( m_svPointList.size() ) );
    m_svPointList[i].m_vPosition = position;
}
//-----------------------------------------------------------------------------
// SetPointHighlighted
// controls the highlighted state of a point.
template <typename T>
void PointManager<T>::SetPointHighlighted ( int i, bool bHighlighted )
{
    assert( 0 <= i && i < static_cast<int>( m_svPointList.size() ) );
    if ( bHighlighted ) {
        m_svPointList[i].m_uiState |= HIGHLIGHTED;
    }
    else
    {
        m_svPointList[i].m_uiState &= ~HIGHLIGHTED;
    }
}
//-----------------------------------------------------------------------------
// IsPointHighlighted
// queries if a point is highlighted.
template <typename T>
bool PointManager<T>::IsPointHighlighted ( int i ) const
{
    assert( 0 <= i && i < static_cast<int>( m_svPointList.size() ) );
    return ( m_svPointList[i].m_uiState & HIGHLIGHTED ) != 0;
}
//-----------------------------------------------------------------------------
// SetPointSelected
// controls the selected state of a point.
template <typename T>
void PointManager<T>::SetPointSelected ( int i, bool bSelected )
{
    assert( 0 <= i && i < static_cast<int>( m_svPointList.size() ) );
    if ( bSelected ) {
        m_svPointList[i].m_uiState |= SELECTED;
    }
    else
    {
        m_svPointList[i].m_uiState &= ~SELECTED;
    }
}
//-----------------------------------------------------------------------------
// IsPointSelected
// queries if a point is selected.
template <typename T>
bool PointManager<T>::IsPointSelected ( int i ) const
{
    assert( 0 <= i && i < static_cast<int>( m_svPointList.size() ) );
    return ( m_svPointList[i].m_uiState & SELECTED ) != 0;
}
//-----------------------------------------------------------------------------
// DrawPoints
// Points can be drawn in different colors based on their highlighted and 
// selected states.  Each point is drawn as a lit sphere.
template <typename T>
void PointManager<T>::DrawPoints ()
{
    glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT );
    //----------------------------------------------------------------
    if ( !m_uiPointDisplayList ) {
        m_uiPointDisplayList = glGenLists( 1 );
        glNewList( m_uiPointDisplayList, GL_COMPILE );
        GLUquadricObj *qObj = gluNewQuadric();
        gluSphere( qObj, 0.5, 10, 10 );
        gluDeleteQuadric( qObj );
        glEndList();
    }
    //----------------------------------------------------------------
    glEnable( GL_COLOR_MATERIAL );
    //----------------------------------------------------------------
    // Draw each point as a lit sphere
    GLdouble dPointSize;
    for ( int i = 0; i < GetNumPoints(); ++i ) {
        if ( IsPointHighlighted(i) ) {
            dPointSize = K_HIGHLIGHTED_SIZE;
            glColor3dv( K_HIGHLIGHTED_COLOR );
        }
        else if ( IsPointSelected(i) ) {
            dPointSize = K_SELECTED_SIZE;
            glColor3dv( K_SELECTED_COLOR );
        }
        else {
            dPointSize = K_REGULAR_SIZE;
            glColor3dv( K_REGULAR_COLOR );
        }

        glPushMatrix();
            const Vector3<T> &pos = GetPointPosition(i);
            glTranslated( pos[0], pos[1], pos[2] );
            T windowToWorldScale = m_pViewManager->GetWindowToWorldScale();
            T dPointScale = dPointSize * windowToWorldScale;
            glScaled( dPointScale, dPointScale, dPointScale );
            glCallList( m_uiPointDisplayList );
        glPopMatrix();
    }
    //----------------------------------------------------------------
    glPopAttrib();
}
//-----------------------------------------------------------------------------
// DrawLines
// draws the line segments that connect the points.
template <typename T>
void PointManager<T>::DrawLines ()
{
    glPushAttrib( GL_ENABLE_BIT );
    //----------------------------------------------------------------
    glDisable( GL_LIGHTING );
    glEnable( GL_COLOR_MATERIAL );
    glColor3f( 1.0, 0.0, 0.0 );
    glLineWidth( 2.0 );
    glBegin( GL_LINE_STRIP );
        for ( int i = 0; i < GetNumPoints(); ++i ) {
            glVertex3dv( GetPointPosition(i) );
        }
    glEnd();
    //glEnable( GL_LIGHTING );
    //----------------------------------------------------------------
    glPopAttrib();
}
//-----------------------------------------------------------------------------
// PickPoint
// finds the closest point to the x, y screen coordinates on the near plane
template <typename T>
int PointManager<T>::PickPoint( int x, int y ) const
{
    T minDistSqr = DBL_MAX;
    int iClosestPoint = -1;
    //----------------------------------------------------------------
    for ( int i = 0; i < GetNumPoints(); ++i ) {
        Vector3<T> win;
        Vector3<T> obj = GetPointPosition(i);
        assert( m_pViewManager->ToScreen( obj, win ) );
        //------------------------------------------------------
        T distX = win[0] - x;
        T distY = win[0] - y;
        T distSqr = ( distX*distX + distY*distY );
        if ( distSqr < minDistSqr ) {
            minDistSqr = distSqr;
            iClosestPoint = i;
        }
    }
    return iClosestPoint;
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8