boundary.h

Go to the documentation of this file.

#ifndef _BOUNDARY_H_
#define _BOUNDARY_H_

#include <algorithm>
#include <vector>
#include <list>
#include <set>

#include "../Mesh/BaseMesh.h"
#include "../Mesh/iterators.h"

namespace MeshLib
{
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class CLoop
{
public:
         CLoop( CBaseMesh<CVertex, CEdge,CFace, CHalfEdge> * pMesh, CHalfEdge * pH );
        ~CLoop();
        
        std::list<CHalfEdge*>  & halfedges() 
        {
                return m_halfedges;
        }
        
        double length() 
        { 
                return m_length; 
        }

protected:
        CBaseMesh<CVertex,CEdge,CFace,CHalfEdge>                * m_pMesh;
        double                                                                                    m_length;
        CHalfEdge                                                                               * m_pHalfedge;
        std::list<CHalfEdge*>                                                     m_halfedges;

};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class CBoundary
{
        typedef CLoop<CVertex,CEdge, CFace, CHalfEdge> TLoop;

public:
        CBoundary( CBaseMesh<CVertex,CEdge,CFace,CHalfEdge> * pMesh );
        ~CBoundary();
        std::vector<TLoop*> & loops() 
        { 
                return m_loops; 
        } 

protected:
        CBaseMesh<CVertex,CEdge,CFace,CHalfEdge> * m_pMesh;
        typename std::vector<TLoop*> m_loops;
        void _bubble_sort( std::vector<CLoop<CVertex, CEdge, CFace, CHalfEdge>*> & loops);
};

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CLoop<CVertex, CEdge, CFace, CHalfEdge>::CLoop( CBaseMesh<CVertex, CEdge, CFace, CHalfEdge> * pMesh, CHalfEdge * pH )
{
        m_pMesh     = pMesh;
        m_pHalfedge = pH;

        m_length = 0;
        CHalfEdge * he = pH;
        //trace the boundary loop
        do{
                CVertex * v = (CVertex*)he->target();
                he = m_pMesh->vertexMostClwOutHalfEdge( v );
                m_halfedges.push_back( he );
    m_length += m_pMesh->edgeLength( (CEdge*)he->edge() );
        }while( he != m_pHalfedge );
}

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CLoop<CVertex, CEdge, CFace, CHalfEdge>::~CLoop()
{
        m_halfedges.clear();
}


template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
void CBoundary<CVertex, CEdge, CFace, CHalfEdge>::_bubble_sort( std::vector<CLoop<CVertex, CEdge, CFace, CHalfEdge>*> & loops)
{
      int i, j, flag = 1;    // set flag to 1 to start first pass
      CLoop<CVertex,CEdge,CFace,CHalfEdge> * temp;             // holding variable
      int numLength = (int)loops.size( ); 
      for(i = 1; (i <= numLength) && flag; i++)
     {
          flag = 0;
          for (j=0; j < (numLength -1); j++)
         {
               if (loops[j+1]->length() > loops[j]->length() )      // ascending order simply changes to <
              { 
                    temp = loops[j];                                                            // swap elements
                    loops[j] = loops[j+1];
                    loops[j+1] = temp;
                    flag = 1;                                                                           // indicates that a swap occurred.
               }
          }
     }
}

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CBoundary<CVertex, CEdge, CFace, CHalfEdge>::CBoundary( CBaseMesh<CVertex, CEdge, CFace, CHalfEdge> * pMesh )
{
        m_pMesh = pMesh;
        //collect all boundary halfedges
        std::set<CHalfEdge*> boundary_hes;
        for( MeshEdgeIterator<CVertex, CEdge, CFace, CHalfEdge> eiter( m_pMesh); !eiter.end(); eiter ++ )
        {
                CEdge * e = *eiter;
                if( !m_pMesh->isBoundary(e) ) continue;

                CHalfEdge * he = m_pMesh->edgeHalfedge( e, 0);
                boundary_hes.insert( he );
        }
        //trace all the boundary loops
        while( !boundary_hes.empty() )
        {
                //get the first boundary halfedge
                std::set<CHalfEdge*>::iterator siter = boundary_hes.begin();
                CHalfEdge * he = *siter;
                //trace along this boundary halfedge
                CLoop<CVertex, CEdge, CFace, CHalfEdge> * pL = new CLoop<CVertex, CEdge, CFace, CHalfEdge>( m_pMesh, he );
                assert(pL);
                m_loops.push_back( pL );
                //remove all the boundary halfedges, which are in the same boundary loop as the head, from the halfedge list
                for( std::list<CHalfEdge*>::iterator hiter = pL->halfedges().begin(); 
                        hiter != pL->halfedges().end(); hiter ++ )
                {
                        CHalfEdge * he = *hiter;
                        siter = boundary_hes.find( he );
                        if( siter == boundary_hes.end() ) continue;
                        boundary_hes.erase( siter );
                }
        }
        
        //std::sort( vlps.begin(), vlps.end(), loop_compare<CVertex,CFace,CEdge,CHalfEdge> );
        _bubble_sort( m_loops );
}

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
CBoundary<CVertex, CEdge, CFace, CHalfEdge>::~CBoundary()
{
        for( int i = 0; i < (int)m_loops.size(); i ++ )
        {
                CLoop<CVertex, CEdge, CFace, CHalfEdge> * pL = m_loops[i];
                delete pL;
        }
}

}
#endif