TAPsHexahedronCube.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsHexahedronCube.cpp

HexahedronCube class is a class for a Cube.
A hexahedron is a polyhedron with six faces.  There are seven convex hexahedra, 
coresponding through graph duality with the seven hexahedral graphs (according 
to http://mathworld.wolfram.com/Hexahedron.html)

SUKITTI PUNAK   (09/14/2005)
UPDATE          (09/15/2005)
******************************************************************************/
#include "TAPsHexahedronCube.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
//=============================================================================
// Static Variables
//-----------------------------------------------------------------------------
//*
template <typename T>
bool    HexahedronCube<T>::m_gbHasBeenSet = false;
template <typename T>
std::vector< std::vector<int> > HexahedronCube<T>::m_vVertexValence;
template <typename T>
std::vector< std::vector<int> > HexahedronCube<T>::m_vVertexFace;
template <typename T>
std::vector< std::vector<int> > HexahedronCube<T>::m_vFace;
template <typename T>
std::vector< std::vector<int> >::iterator   HexahedronCube<T>::m_itor;
//*/
//=============================================================================
// Constructors and Destructor
//-----------------------------------------------------------------------------
template <typename T>
HexahedronCube<T>::HexahedronCube ()
    : AbstractPolyhedron<T>( 8, 6 )
{
    // Point Numbering:
    // ----------------
    // with the right-handed coordinate system
    //           7        6
    //           +--------+            y
    //          /|       /|            |
    //         / |      / |            |
    //       3+--------+2 |            |________x
    //        | 4+-----|--+5          /
    //        | /      | /           /
    //        |/       |/           z
    //        +--------+
    //        0        1
    //----------------------------------------------------------------
    m_vVertex[0] = Vector3<T>( 0, 0, 1 );
    m_vVertex[1] = Vector3<T>( 1, 0, 1 );
    m_vVertex[2] = Vector3<T>( 1, 1, 1 );
    m_vVertex[3] = Vector3<T>( 0, 1, 1 );
    m_vVertex[4] = Vector3<T>( 0, 0, 0 );
    m_vVertex[5] = Vector3<T>( 1, 0, 0 );
    m_vVertex[6] = Vector3<T>( 1, 1, 0 );
    m_vVertex[7] = Vector3<T>( 0, 1, 0 );
    Setup();
}
//-----------------------------------------------------------------------------
template <typename T>
HexahedronCube<T>::HexahedronCube ( Vector3<T> const p[8] )
    : AbstractPolyhedron<T>( 8, 6 )
{
    // Point Numbering:
    // ----------------
    // with the right-handed coordinate system
    //           7        6
    //           +--------+            y
    //          /|       /|            |
    //         / |      / |            |
    //       3+--------+2 |            |________x
    //        | 4+-----|--+5          /
    //        | /      | /           /
    //        |/       |/           z
    //        +--------+
    //        0        1
    //----------------------------------------------------------------
    m_vVertex[0] = p[0];
    m_vVertex[1] = p[1];
    m_vVertex[2] = p[2];
    m_vVertex[3] = p[3];
    m_vVertex[4] = p[4];
    m_vVertex[5] = p[5];
    m_vVertex[6] = p[6];
    m_vVertex[7] = p[7];
    Setup();
}
//-----------------------------------------------------------------------------
template <typename T>
HexahedronCube<T>::~HexahedronCube ()
{}
//-----------------------------------------------------------------------------
//=============================================================================
// Helper Function(s)
//-----------------------------------------------------------------------------
// SetupStaticMembers Fn
template <typename T>
void HexahedronCube<T>::SetupStaticMembers ()
{
    //----------------------------------------------------------------
    m_vVertexValence.resize(8);
    m_vVertexFace.resize(8);
    m_vFace.resize(6);
    //----------------------------------------------------------------
    // Initialize Vertex Valence
    //----------------------------------------------------------------
    // Vertex#0: 1 3 4 ----------------
    m_vVertexValence[0].push_back( 1 );
    m_vVertexValence[0].push_back( 3 );
    m_vVertexValence[0].push_back( 4 );
    // Vertex#1: 0 2 5 ----------------
    m_vVertexValence[1].push_back( 0 );
    m_vVertexValence[1].push_back( 2 );
    m_vVertexValence[1].push_back( 5 );
    // Vertex#2: 1 3 6 ----------------
    m_vVertexValence[2].push_back( 1 );
    m_vVertexValence[2].push_back( 3 );
    m_vVertexValence[2].push_back( 6 );
    // Vertex#3: 0 2 7 ----------------
    m_vVertexValence[3].push_back( 0 );
    m_vVertexValence[3].push_back( 2 );
    m_vVertexValence[3].push_back( 7 );
    // Vertex#4: 0 5 7 ----------------
    m_vVertexValence[4].push_back( 0 );
    m_vVertexValence[4].push_back( 5 );
    m_vVertexValence[4].push_back( 7 );
    // Vertex#5: 1 4 6 ----------------
    m_vVertexValence[5].push_back( 1 );
    m_vVertexValence[5].push_back( 4 );
    m_vVertexValence[5].push_back( 6 );
    // Vertex#6: 2 5 7 ----------------
    m_vVertexValence[6].push_back( 2 );
    m_vVertexValence[6].push_back( 5 );
    m_vVertexValence[6].push_back( 7 );
    // Vertex#7: 3 4 6 ----------------
    m_vVertexValence[7].push_back( 3 );
    m_vVertexValence[7].push_back( 4 );
    m_vVertexValence[7].push_back( 6 );
    //----------------------------------------------------------------
    // Initialize Face List
    //----------------------------------------------------------------
    // Face#0: 0 1 2 3 --------- (front)
    m_vFace[0].push_back( 0 );
    m_vFace[0].push_back( 1 );
    m_vFace[0].push_back( 2 );
    m_vFace[0].push_back( 3 );
    // Face#1: 1 5 6 2 --------- (right)
    m_vFace[1].push_back( 1 );
    m_vFace[1].push_back( 5 );
    m_vFace[1].push_back( 6 );
    m_vFace[1].push_back( 2 );
    // Face#2: 7 6 5 4 --------- (back)
    m_vFace[2].push_back( 7 );
    m_vFace[2].push_back( 6 );
    m_vFace[2].push_back( 5 );
    m_vFace[2].push_back( 4 );
    // Face#3: 0 3 7 4 --------- (left)
    m_vFace[3].push_back( 0 );
    m_vFace[3].push_back( 3 );
    m_vFace[3].push_back( 7 );
    m_vFace[3].push_back( 4 );
    // Face#4: 0 4 5 1 --------- (bottom)
    m_vFace[4].push_back( 0 );
    m_vFace[4].push_back( 4 );
    m_vFace[4].push_back( 5 );
    m_vFace[4].push_back( 1 );
    // Face#5: 2 6 7 3 --------- (top)
    m_vFace[5].push_back( 2 );
    m_vFace[5].push_back( 6 );
    m_vFace[5].push_back( 7 );
    m_vFace[5].push_back( 3 );
    //----------------------------------------------------------------
    // Initialize Vertex Face List (face that has this vertex)
    //----------------------------------------------------------------
    // Vertex#0: 0 3 4 ---------
    m_vVertexFace[0].push_back( 0 );
    m_vVertexFace[0].push_back( 3 );
    m_vVertexFace[0].push_back( 4 );
    // Vertex#1: 0 1 4 ---------
    m_vVertexFace[1].push_back( 0 );
    m_vVertexFace[1].push_back( 1 );
    m_vVertexFace[1].push_back( 4 );
    // Vertex#2: 0 1 5 ---------
    m_vVertexFace[2].push_back( 0 );
    m_vVertexFace[2].push_back( 1 );
    m_vVertexFace[2].push_back( 5 );
    // Vertex#3: 0 3 5 ---------
    m_vVertexFace[3].push_back( 0 );
    m_vVertexFace[3].push_back( 3 );
    m_vVertexFace[3].push_back( 5 );
    // Vertex#4: 2 3 4 ---------
    m_vVertexFace[4].push_back( 2 );
    m_vVertexFace[4].push_back( 3 );
    m_vVertexFace[4].push_back( 4 );
    // Vertex#5: 1 2 4 ---------
    m_vVertexFace[5].push_back( 1 );
    m_vVertexFace[5].push_back( 2 );
    m_vVertexFace[5].push_back( 4 );
    // Vertex#6: 1 2 5 ---------
    m_vVertexFace[6].push_back( 1 );
    m_vVertexFace[6].push_back( 2 );
    m_vVertexFace[6].push_back( 5 );
    // Vertex#7: 2 3 5 ---------
    m_vVertexFace[7].push_back( 2 );
    m_vVertexFace[7].push_back( 3 );
    m_vVertexFace[7].push_back( 5 );
}
//-----------------------------------------------------------------------------
// Setup Fn
template <typename T>
void HexahedronCube<T>::Setup ()
{
    // REMARK:
    // =======
    // In theory, we should be able to set m_gbHasBeenSet to true.
    // However, calling DrawByOpenGL fn will have static member size equals zero.
    // Therefore, we will set it to true in DrawByOpenGL fn.
    // See DrawByOpenGL source code below.
    // I believe this must be an effect from DrawByOpenGL is passed as an 
    // argument to a function.
    if ( !m_gbHasBeenSet ) {
        //m_gbHasBeenSet = true;
        SetupStaticMembers();
    }
    //----------------------------------------------------------------
    CalNormals();
}
//-----------------------------------------------------------------------------
// CalNormals Fn
template <typename T>
void HexahedronCube<T>::CalNormals ()
{
    // Assume all faces are planer which works perfectly for triangular faces
    //----------------------------------------------------------------
    // Calculate Face Normals (Unnormalized)
    int p = 0;
    for ( m_itor = m_vFace.begin(); m_itor != m_vFace.end(); ++m_itor, ++p ) {
        m_vFaceNormal[p] = ( m_vVertex[(*m_itor)[1]] - m_vVertex[(*m_itor)[0]] )
                         ^ ( m_vVertex[(*m_itor)[2]] - m_vVertex[(*m_itor)[0]] );
    }
    //----------------------------------------------------------------
    // Calculate Vertex Normals
    for ( p = 0; p < 8; ++p ) {
        m_vVertexNormal[p].SetXYZ( 0, 0, 0);
        for ( int i = 0; i < static_cast<int>( m_vVertexFace[p].size() ); ++i ) {
            m_vVertexNormal[p] += m_vFaceNormal[ m_vVertexFace[p][i] ];
        }
        m_vVertexNormal[p].Normalized();
        std::cout << m_vVertexNormal[p] << std::endl;
    }
    //----------------------------------------------------------------
    // Normalize Face Normals
    for ( p = 0; p < static_cast<int>(m_vFaceNormal.size()); ++p ) {
        m_vFaceNormal[p].Normalized();
        //std::cout << m_vFaceNormal[p] << std::endl;
        //m_vVertexNormal[p] = m_vFaceNormal[p];
    }
}
//-----------------------------------------------------------------------------
#if defined(__gl_h_) || defined(__GL_H__)
//=============================================================================
// DrawByOpenGL
//-----------------------------------------------------------------------------
template <typename T>
void HexahedronCube<T>::DrawByOpenGL ()
{
    if ( !m_gbHasBeenSet ) {
        std::cout << "HexahedronCube<T>::DrawByOpenGL() ==> ";
        std::cout << "Call Tetrahedron<T>::SetupStaticMembers()\n";
        m_gbHasBeenSet = true;
        SetupStaticMembers();
    }
    //----------------------------------------------------------------
    int p;
    //----------------------------------------------------------------
    glPushMatrix();
    for ( m_itor = m_vFace.begin(); m_itor != m_vFace.end(); ++m_itor ) {
        glBegin( GL_POLYGON );
        for ( int i = 0; i < static_cast<int>( (*m_itor).size() ); ++i ) {
            p = (*m_itor)[i];
            glNormal3f( m_vVertexNormal[p][0], m_vVertexNormal[p][1], m_vVertexNormal[p][2] );
            glVertex3f( m_vVertex[p][0], m_vVertex[p][1], m_vVertex[p][2] );
        }
        glEnd();

        // Draw boundary of face
        glDisable( GL_LIGHTING );
        glColor3f( 1, 0, 1 );
        glBegin( GL_LINE_LOOP );
        for ( int i = 0; i < static_cast<int>( (*m_itor).size() ); ++i ) {
            p = (*m_itor)[i];
            glNormal3f( m_vVertexNormal[p][0], m_vVertexNormal[p][1], m_vVertexNormal[p][2] );
            glVertex3f( m_vVertex[p][0], m_vVertex[p][1], m_vVertex[p][2] );
        }
        glEnd();
        glEnable( GL_LIGHTING );
    }
    glPopMatrix();
    //----------------------------------------------------------------
    DrawVertexNormals();
    DrawFaceNormals();
}
//-----------------------------------------------------------------------------
#endif
//=============================================================================
END_NAMESPACE_TAPs
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8