HalfEdgeModel< T > Class Template Reference

#include <TAPsHalfEdgeModel.hpp>

Inheritance diagram for HalfEdgeModel< T >:

[legend]

Collaboration diagram for HalfEdgeModel< T >:

[legend]

List of all members.

Public Member Functions
virtual void	ApplyAndResetTransform ()
	Apply the current transformation to the model permanently. Then reset the transformation to identity.
virtual void	BuildBVHTree (TAPs::Enum::CD treeType)
virtual void	CalAndSetNormals ()
HEFaceList< T > *const	GetFaceList () const
HEFaceList< T > *const	GetHoleFaceList () const
virtual T	GetMaxHalfLength () const
HEVertexList< T > *const	GetVertexList () const
	HalfEdgeModel ()
virtual void	Initialize ()
void	InsertVertexSplitEdge ()
void	IVSE (HEHalfEdge< T > *he, Vector3< T > const *const pos=NULL)
void	JFKE (HEHalfEdge< T > *he)
void	JoinFaceKillEdge ()
void	JoinVertexKillEdge ()
void	JVKE (HEHalfEdge< T > *he, Vector3< T > const *const pos=NULL)
void	SFME (HEHalfEdge< T > *he1, HEHalfEdge< T > *he2)
void	SplitFaceMakeEdge ()
void	SplitVertexMakeEdge ()
void	SVME (HEHalfEdge< T > *he1, HEHalfEdge< T > *he2, Vector3< T > const *const pos1=NULL, Vector3< T > const *const pos2=NULL)
virtual	~HalfEdgeModel ()
Protected Member Functions
virtual void	CalAndSetFaceNormalsNotNormalized ()
virtual void	CalAndSetVertexNormals ()
virtual void	CalBoundingAABB ()
virtual void	CalBoundingEllipsoid ()
virtual void	CalBoundingSphere ()
virtual void	NormalizeFaceNormals ()
Protected Attributes
HEFaceList< T > *	m_listFace
HEFaceList< T > *	m_listHoleFace
HEVertexList< T > *	m_listVertex
Friends
std::ostream &	operator<< (std::ostream &output, HalfEdgeModel< T > const &o)

---

Detailed Description

template<typename T>
class HalfEdgeModel< T >

Definition at line 74 of file TAPsHalfEdgeModel.hpp.

---

Constructor & Destructor Documentation

template<typename T>

BEGIN_NAMESPACE_TAPs__OpenGL HalfEdgeModel< T >::HalfEdgeModel

(

)

[inline]

Definition at line 22 of file TAPsHalfEdgeModel.cpp.

    : OpenGLMeshModel<T>()
{
    m_listVertex   = new HEVertexList<T>();
    m_listFace     = new HEFaceList<T>();
    m_listHoleFace = new HEFaceList<T>();
    if (   m_listVertex   == NULL 
        || m_listFace     == NULL
        || m_listHoleFace == NULL ) {

        #ifdef TAPs_DEBUG_MODE
        std::cerr << "HalfEdgeModel ERROR: Can create an halfedge object." << std::endl;
        #endif//TAPs_DEBUG_MODE

        exit(1);
    }

    #ifdef TAPs_DEBUG_MODE
    std::cout << "HalfEdgeModel<" << typeid(T).name() << "> Constructor\n";
    #endif//TAPs_DEBUG_MODE
}

template<typename T>

HalfEdgeModel< T >::~HalfEdgeModel

(

)

[inline, virtual]

Definition at line 46 of file TAPsHalfEdgeModel.cpp.

{
    delete m_listVertex;
    delete m_listFace;
    delete m_listHoleFace;
    //----------------------------------------------------------------
    // For simulation
    //delete m_prODESolver;
    #ifdef TAPs_DEBUG_MODE
    std::cout << "HalfEdgeModel<" << typeid(T).name() << "> Destructor\n";
    #endif//TAPs_DEBUG_MODE
}

---

Member Function Documentation

template<typename T>

void HalfEdgeModel< T >::ApplyAndResetTransform

(

)

[inline, virtual]

Apply the current transformation to the model permanently. Then reset the transformation to identity.

So that the transformation can be turned off to save the computation time that have to use when the model has the transformation on.

The side effect is that the model's original shape is permanently changed by the transformation (before the transformation is reset).

Reimplemented from Model< T >.

Reimplemented in HETriMeshOneModelMultiParts< T >.

Definition at line 207 of file TAPsHalfEdgeModel.cpp.

{
    HEVertex<T> * heVertex = GetVertexList()->Head();
    //--------------------------------------------------------------------
    while ( heVertex ) {
        heVertex->SetPosition( 
            (     GetTransform().ReturnMatrixTransform() 
                * Vector4<T>( heVertex->GetPosition() )
            ).GetVector3()
        );
        heVertex = heVertex->Next();
    }
    //--------------------------------------------------------------------
    // Set Transformation to Identity Matrix
    GetTransform().MakeIdentity();
    //--------------------------------------------------------------------
    // Recalculate Bounding Volume(s)
    CalBoundingAABB();
    CalBoundingEllipsoid();
    CalBoundingSphere();

    // Update the bounding volume tree
    if ( GetBVHTree() ) {
        GetBVHTree()->Update();
    }
}

template<typename T>

void HalfEdgeModel< T >::BuildBVHTree

(

TAPs::Enum::CD

treeType

)

[inline, virtual]

Reimplemented in HalfEdgeTrigonalModel< T >.

Definition at line 301 of file TAPsHalfEdgeModel.cpp.

{
    //BVHTree<T>::
    // Call a static fn from BVHTree class
    // m_pBVHTree is inherited from ColDetSupport class

    //m_pBVHTree = BVHTree<T>::BuildBVHTree( GetTransform(), m_listFace, treeType, m_pBVHTree );

    m_pBVHTree = TAPs::CD::BuildBVHTree<T>( GetTransform(), m_listFace, treeType );

    //std::cout << "m_pVBHTree: " << m_pBVHTree << std::cout;
}

template<typename T>

void HalfEdgeModel< T >::CalAndSetFaceNormalsNotNormalized

(

)

[inline, protected, virtual]

Reimplemented in HalfEdgeTrigonalModel< T >.

Definition at line 138 of file TAPsHalfEdgeModel.cpp.

{
    // 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();
    }
}

template<typename T>

void HalfEdgeModel< T >::CalAndSetNormals

(

)

[inline, virtual]

Reimplemented in HalfEdgeTrigonalModel< T >.

Definition at line 128 of file TAPsHalfEdgeModel.cpp.

{
    CalAndSetFaceNormalsNotNormalized();
//  DetermineFaceRings();
    CalAndSetVertexNormals();
    NormalizeFaceNormals();
}

template<typename T>

void HalfEdgeModel< T >::CalAndSetVertexNormals

(

)

[inline, protected, virtual]

Reimplemented in HalfEdgeTrigonalModel< T >.

Definition at line 165 of file TAPsHalfEdgeModel.cpp.

{
    HEVertex<T> *vertex = m_listVertex->Head();
    HEHalfEdge<T> *halfEdge;

    #ifdef TAPs_DEBUG_MODE
    std::cout << "FIND VERTEX NORMAL" << std::endl;
    #endif//TAPs_DEBUG_MODE

    while ( vertex ) {
        Vector3<T> vNormal;
        halfEdge = vertex->IncidentHalfEdge();

        #ifdef TAPs_DEBUG_MODE
        std::cout << *halfEdge << std::endl;
        #endif//TAPs_DEBUG_MODE

        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();
    }
}

template<typename T>

void HalfEdgeModel< T >::CalBoundingAABB

(

)

[inline, protected, virtual]

Reimplemented from ColDetSupport< T >.

Definition at line 241 of file TAPsHalfEdgeModel.cpp.

{
    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 HalfEdgeModel< T >::CalBoundingEllipsoid

(

)

[inline, protected, virtual]

Reimplemented from ColDetSupport< T >.

Definition at line 270 of file TAPsHalfEdgeModel.cpp.

{
    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 HalfEdgeModel< T >::CalBoundingSphere

(

)

[inline, protected, virtual]

Reimplemented from ColDetSupport< T >.

Definition at line 284 of file TAPsHalfEdgeModel.cpp.

{
    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 );
}

template<typename T>

HEFaceList<T>* const HalfEdgeModel< T >::GetFaceList

(

)

const [inline]

Definition at line 190 of file TAPsHalfEdgeModel.hpp.

{ return m_listFace; }

template<typename T>

HEFaceList<T>* const HalfEdgeModel< T >::GetHoleFaceList

(

)

const [inline]

Definition at line 191 of file TAPsHalfEdgeModel.hpp.

{ return m_listHoleFace; }

template<typename T>

T HalfEdgeModel< T >::GetMaxHalfLength

(

)

const [inline, virtual]

Implements Model< T >.

Definition at line 110 of file TAPsHalfEdgeModel.cpp.

{
    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;
}

template<typename T>

HEVertexList<T>* const HalfEdgeModel< T >::GetVertexList

(

)

const [inline]

Definition at line 189 of file TAPsHalfEdgeModel.hpp.

{ return m_listVertex; }

template<typename T>

void HalfEdgeModel< T >::Initialize

(

)

[inline, virtual]

Implements Model< T >.

Reimplemented in HalfEdgeTrigonalModel< T >, HETriMeshOneModelMultiParts< T >, and SpringHalfEdgeModel< T >.

Definition at line 62 of file TAPsHalfEdgeModel.cpp.

{
    // Model Initialization
    CalAndSetNormals();
    ApplyMaterial();
    CalBoundingAABB();
    CalBoundingEllipsoid();
    CalBoundingSphere();

    // For Fast Access
    //SetListOfVertexPositionsAndNormals();

    /*
    std::cout << *this << std::endl;
    //*/
}

template<typename T>

void HalfEdgeModel< T >::InsertVertexSplitEdge

(

)

[inline]

Definition at line 223 of file TAPsHalfEdgeModel.hpp.

{};

template<typename T>

void HalfEdgeModel< T >::IVSE	(	HEHalfEdge< T > *	he,
		Vector3< T > const *const	pos = NULL
	)			[inline]

Definition at line 352 of file TAPsHalfEdgeModel.cpp.

{
    //---------------------------------------------------------------
    // Crete New Vertex
    HEVertex<T> * newVertex;
    if ( pos != NULL ) {
        newVertex = new HEVertex<T>( *pos, he->Vertex()->GetNormal() );
    }
    else {
        newVertex = new HEVertex<T>( he->Vertex()->GetPosition(), 
                                     he->Vertex()->GetNormal() );
    }
    //---------------------------------------------------------------
    // Update Vertex List and Number of Vertices
    //GetVertexList()->Append( newVertex ); // or Append or Prepend
    GetVertexList()->InsertAfter( newVertex );  // or Append or Prepend
    SetNoVertices( GetVertexList()->Size() );
    //SetNoVertices( GetNoVertices() + 1 );
    //---------------------------------------------------------------
    // Crete New HalfEdges
    HEHalfEdge<T> * newHalfEdge = new HEHalfEdge<T>( 
                        newVertex,      // original vertex
                        he->Face(),     // incident face
                        he,             // previous halfedge
                        he->Next(),     // next halfedge
                        he->Pair() );   // pair halfedge
    HEHalfEdge<T> * newPairHalfEdge = new HEHalfEdge<T>( 
                    newVertex,          // original vertex
                    he->Pair()->Face(), // incident face
                    he->Pair(),         // previous halfedge
                    he->Pair()->Next(), // next halfedge
                    he );               // pair halfedge
    //---------------------------------------------------------------
    // Rearrange Pointers
    newHalfEdge->Pair()->Pair( newHalfEdge );
    newHalfEdge->Prev()->Next( newHalfEdge );
    newHalfEdge->Next()->Prev( newHalfEdge );
    newPairHalfEdge->Pair()->Pair( newPairHalfEdge );
    newPairHalfEdge->Prev()->Next( newPairHalfEdge );
    newPairHalfEdge->Next()->Prev( newPairHalfEdge );
    newVertex->IncidentHalfEdge( newHalfEdge );
}

template<typename T>

void HalfEdgeModel< T >::JFKE

(

HEHalfEdge< T > *

he

)

[inline]

Definition at line 594 of file TAPsHalfEdgeModel.cpp.

{
    //------------------------------------------------------------------
    HEFace<T> * f1 = he->Face();
    HEFace<T> * f2 = he->Pair()->Face();
    //------------------------------------------------------------------
    f1->IncidentHalfEdge( he->Prev() );
    //------------------------------------------------------------------
    // Rearrange all halfedges in f2 to have incident face f1
    int i = 0;
    HEHalfEdge<T> * pHalfEdge = he->Pair()->Next();
    while ( pHalfEdge != he->Pair() ) {
        std::cout << ++i << std::endl;
        pHalfEdge->Face( f1 );
        pHalfEdge = pHalfEdge->Next();
    }

    std::cout << "Start Rearranging Pointers" << std::endl;

    //------------------------------------------------------------------
    // Rearrange Pointers
    he->Vertex()->IncidentHalfEdge( he->Pair()->Next() );
    he->Pair()->Vertex()->IncidentHalfEdge( he->Next() );
    he->Prev()->Next( he->Pair()->Next() );
    he->Next()->Prev( he->Pair()->Prev() );
    he->Pair()->Prev()->Next( he->Next() );
    he->Pair()->Next()->Prev( he->Prev() );

    std::cout << "Start Deleting Pointers" << std::endl;

    //------------------------------------------------------------------
    // Delete Pointers
    int count = 0;
    std::cout << ++count << std::endl;
    GetFaceList()->Delete( f2 );    // delete the face (f2)
    std::cout << ++count << std::endl;
    delete he->Pair();              // delete the halfedge's pair
    std::cout << ++count << std::endl;
    delete he;                      // delete the halfedge
    std::cout << ++count << std::endl;
    //-----------------------------------------------------
    std::cout << "SetNoFaces" << std::endl;
    SetNoFaces( GetFaceList()->Size() );
    //------------------------------------------------------------------
    std::cout << "Finish" << std::endl;
}

template<typename T>

void HalfEdgeModel< T >::JoinFaceKillEdge

(

)

[inline]

Definition at line 227 of file TAPsHalfEdgeModel.hpp.

{};

template<typename T>

void HalfEdgeModel< T >::JoinVertexKillEdge

(

)

[inline]

Definition at line 225 of file TAPsHalfEdgeModel.hpp.

{};

template<typename T>

void HalfEdgeModel< T >::JVKE	(	HEHalfEdge< T > *	he,
		Vector3< T > const *const	pos = NULL
	)			[inline]

Definition at line 488 of file TAPsHalfEdgeModel.cpp.

{
    if ( pos != NULL )  he->Vertex()->SetPosition( *pos );
    //-----------------------------------------------------
    // Change all halfedges that eminate from delete vertex to vertex of he
    // Except the starting halfedge, which is he->Pair(),
    // since we need to delete he->Pair()->Vertex().
    HEHalfEdge<T> * pStartHalfEdge = he->Pair();
    HEHalfEdge<T> * pCurrentHalfEdge = he->Next();
    while ( pCurrentHalfEdge != pStartHalfEdge ) {
        pCurrentHalfEdge->Vertex( he->Vertex() );
        pCurrentHalfEdge = pCurrentHalfEdge->Pair()->Next();
    }
    //-----------------------------------------------------
    // Rearrange and Delete Pointers
    he->Vertex()->IncidentHalfEdge( he->Next() );
    GetVertexList()->Delete( he->Pair()->Vertex() );    // delete the vertex
    he->Pair()->Face()->IncidentHalfEdge( he->Pair()->Next() );
    he->Face()->IncidentHalfEdge( he->Next() );
    he->Prev()->Next( he->Next() );
    he->Next()->Prev( he->Prev() );
    he->Pair()->Prev()->Next( he->Pair()->Next() );
    he->Pair()->Next()->Prev( he->Pair()->Prev() );
    delete he->Pair();          // delete the halfedge's pair
    delete he;                  // delete the halfedge
    //-----------------------------------------------------
    SetNoVertices( GetVertexList()->Size() );
    //std::cout << "NoVertices: " << GetNoVertices() << "\n";
}

template<typename T>

void HalfEdgeModel< T >::NormalizeFaceNormals

(

)

[inline, protected, virtual]

Reimplemented in HalfEdgeTrigonalModel< T >.

Definition at line 153 of file TAPsHalfEdgeModel.cpp.

{
    // 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();
    }
}

template<typename T>

void HalfEdgeModel< T >::SFME	(	HEHalfEdge< T > *	he1,
		HEHalfEdge< T > *	he2
	)			[inline]

Definition at line 533 of file TAPsHalfEdgeModel.cpp.

{
    //------------------------------------------------------------------
    // Cancel if he1 and he2 are pointing to the same halfedge
    if ( he1 == he2 )   return;
    //------------------------------------------------------------------
    // Cancel if he1 and he2 have different incident face
    if ( he1->Face() != he2->Face() )   return;
    //------------------------------------------------------------------
    // Create a new face f2
    HEFace<T> * f1 = he1->Face();
    HEFace<T> * f2 = new HEFace<T>( f1->GetNormal() );
    //GetFaceList()->Append( f2 );          // append f2 to the face list
    GetFaceList()->InsertAfter( f2 );       // append f2 to the face list
    SetNoFaces( GetFaceList()->Size() );    // update face size
    //------------------------------------------------------------------
    // Create new halfedges spliting f1 into f1 and f2
    HEHalfEdge<T> * h = new HEHalfEdge<T>( 
                        he1->Next()->Vertex(),  // original vertex
                        f1,                     // incident face
                        he1,                    // previous halfedge
                        he2->Next(),            // next halfedge
                        NULL );                 // pair halfedge
    HEHalfEdge<T> * g = new HEHalfEdge<T>( 
                        he2->Next()->Vertex(),  // original vertex
                        f2,                     // incident face
                        he2,                    // previous halfedge
                        he1->Next(),            // next halfedge
                        h );                    // pair halfedge
    h->Pair( g );
    //------------------------------------------------------------------
    // Rearrange all halfedges between h to g to have incident face f2
    HEHalfEdge<T> * pHalfEdge = he1->Next();
    while ( pHalfEdge != he2 ) {
        pHalfEdge->Face( f2 );
        pHalfEdge = pHalfEdge->Next();
    }
    //------------------------------------------------------------------
    // Rearrange pointers
    h->Prev()->Next( h );
    h->Next()->Prev( h );
    g->Prev()->Next( g );
    g->Next()->Prev( g );
    f2->IncidentHalfEdge( g );
}

template<typename T>

void HalfEdgeModel< T >::SplitFaceMakeEdge

(

)

[inline]

Definition at line 226 of file TAPsHalfEdgeModel.hpp.

{};

template<typename T>

void HalfEdgeModel< T >::SplitVertexMakeEdge

(

)

[inline]

Definition at line 224 of file TAPsHalfEdgeModel.hpp.

{};

template<typename T>

void HalfEdgeModel< T >::SVME	(	HEHalfEdge< T > *	he1,
		HEHalfEdge< T > *	he2,
		Vector3< T > const *const	pos1 = NULL,
		Vector3< T > const *const	pos2 = NULL
	)			[inline]

Definition at line 409 of file TAPsHalfEdgeModel.cpp.

{
    //---------------------------------------------------------------
    // Case the same halfedge, call Insert Vertex Split Edge
    if ( he1 == he2 ) {
        if ( pos2 != NULL ) {
            he1->Pair()->Vertex()->SetPosition( *pos2 );
        }
        IVSE( he1, pos1 );
        return;
    }
    //---------------------------------------------------------------
    // Case two different vertices, cancel spliting
    if ( he1->Pair()->Vertex() != he2->Pair()->Vertex() ) {
        return;
    }
    //---------------------------------------------------------------
    // Case one vertex, do spliting
    HEVertex<T> * vertex1, * newVertex;
    vertex1 = he1->Pair()->Vertex();
    //-----------------------------------------------------
    // Create a New Vertex and set the old vertex
    if ( pos1 != NULL ) {
        vertex1->SetPosition( *pos1 );
    }
    if ( pos2 != NULL ) {
        newVertex = new HEVertex<T>( *pos2, vertex1->GetNormal() );
    }
    else {
        newVertex = new HEVertex<T>( vertex1->GetPosition(), 
                                   vertex1->GetNormal() );
    }
    //-----------------------------------------------------
    // Update Vertex List and Number of Vertices
    //GetVertexList()->Append( newVertex );
    GetVertexList()->InsertAfter( newVertex );
    SetNoVertices( GetVertexList()->Size() );
    //SetNoVertices( GetNoVertices() + 1 );
    //-----------------------------------------------------
    // Crete New HalfEdges
    HEHalfEdge<T> * newHalfEdge = new HEHalfEdge<T>( 
                        vertex1,        // original vertex
                        he1->Face(),    // incident face
                        he1,            // previous halfedge
                        he1->Next(),    // next halfedge
                        NULL );         // pair halfedge
    HEHalfEdge<T> * newPairHalfEdge = new HEHalfEdge<T>( 
                        newVertex,      // original vertex
                        he2->Face(),    // incident face
                        he2,            // previous halfedge
                        he2->Next(),    // next halfedge
                        newHalfEdge );  // pair halfedge
    newHalfEdge->Pair( newPairHalfEdge );
    //-----------------------------------------------------
    // Rearrange Pointers
    newHalfEdge->Prev()->Next( newHalfEdge );
    newHalfEdge->Next()->Prev( newHalfEdge );
    newPairHalfEdge->Prev()->Next( newPairHalfEdge );
    newPairHalfEdge->Next()->Prev( newPairHalfEdge );
    newHalfEdge->Next()->Vertex( newVertex );
    newVertex->IncidentHalfEdge( newPairHalfEdge );
    //-----------------------------------------------------
}

---

Friends And Related Function Documentation

template<typename T>

std::ostream& operator<<	(	std::ostream &	output,
		HalfEdgeModel< T > const &	o
	)			[friend]

Definition at line 77 of file TAPsHalfEdgeModel.hpp.

    {
        output  << "\n======================\n"
                <<   "TAPs::HalfEdgeModel<"
                << typeid(T).name() << "> Class:\n"
                <<   "======================\n";
        //----------------------------------------------------------------
        output << "Name: " << o.GetName() << "\n";
        // Vertex Nodes
        output  << "\n\nVertices " << o.m_listVertex->Size();
        /*
        int i;
        i = 0;
        HEVertex<T> *vertex = o.m_listVertex->Head();
        output << "\n{";
        while ( vertex ) {
            output << "\n  #" << ++i << "\t" << *vertex;
            vertex = vertex->Next();
        }
        output  << "\n}";
        //*/
        //----------------------------------------------------------------
        // Face Nodes
        output  << "\n\nFaces " << o.m_listFace->Size();
        /*
        i = 0;
        HEFace<T> *face = o.m_listFace->Head();
        output << "\n{";
        while ( face ) {
            output << "\n  #" << ++i << "\t" << *face;
            face = face->Next();
        }
        output  << "\n}";
        //*/
        //----------------------------------------------------------------
        // Hole Face Nodes
        output  << "\n\nHole Faces " << o.m_listHoleFace->Size();
        /*
        i = 0;
        face = o.m_listHoleFace->Head();
        output << "\n{";
        while ( face ) {
            output << "\n  #" << ++i << "\t" << *face;
            face = face->Next();
        }
        output  << "\n}";
        //*/
        //----------------------------------------------------------------
        return output;
    }

---

Member Data Documentation

template<typename T>

HEFaceList<T>* HalfEdgeModel< T >::m_listFace [protected]

Definition at line 248 of file TAPsHalfEdgeModel.hpp.

template<typename T>

HEFaceList<T>* HalfEdgeModel< T >::m_listHoleFace [protected]

Definition at line 249 of file TAPsHalfEdgeModel.hpp.

template<typename T>

HEVertexList<T>* HalfEdgeModel< T >::m_listVertex [protected]

Definition at line 247 of file TAPsHalfEdgeModel.hpp.

---

The documentation for this class was generated from the following files:

• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModel/TAPsHalfEdgeModel.hpp
• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModel/TAPsHalfEdgeModel.cpp