iterators.h

Go to the documentation of this file.

#ifndef  _ITERATORS_H_
#define  _ITERATORS_H_

#include "BaseMesh.h"

namespace MeshLib{


//v->out halfedge
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class VertexOutHalfedgeIterator
{
public:
        VertexOutHalfedgeIterator( CBaseMesh<CVertex, CEdge, CFace, CHalfEdge> *  pMesh, CVertex *  v )
        { m_pMesh = pMesh; m_vertex = v; m_halfedge = m_pMesh->vertexMostClwOutHalfEdge(v); };

        ~VertexOutHalfedgeIterator(){};
        void operator++() //prefix
        {assert( m_halfedge != NULL ); 
         if( m_halfedge == m_pMesh->vertexMostCcwOutHalfEdge(m_vertex) ) 
                 m_halfedge = NULL;
         else
                 m_halfedge = m_pMesh->vertexNextCcwOutHalfEdge(m_halfedge); };

        void operator++(int) //postfix
        {assert( m_halfedge != NULL ); 
         if( m_halfedge == m_pMesh->vertexMostCcwOutHalfEdge(m_vertex) ) 
                 m_halfedge = NULL;
         else
                 m_halfedge = m_pMesh->vertexNextCcwOutHalfEdge(m_halfedge); };

         CHalfEdge * value() { return m_halfedge; };
         bool end(){ return m_halfedge == NULL; };
         CHalfEdge * operator*() { return value(); };

private:
        CBaseMesh<CVertex,CEdge,CFace,CHalfEdge> *        m_pMesh;
        CVertex *      m_vertex;
        CHalfEdge * m_halfedge;
};

//v->in halfedge
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class VertexInHalfedgeIterator
{
public:
        VertexInHalfedgeIterator(CBaseMesh<CVertex, CEdge, CFace, CHalfEdge> *  pMesh, CVertex * v )
        { m_pMesh = pMesh; m_vertex = v; m_halfedge = m_pMesh->vertexMostClwInHalfEdge(v); };
        ~VertexInHalfedgeIterator(){};

                void operator++()       //prefix
        {
         assert( m_halfedge != NULL ); 
         if( m_halfedge == m_pMesh->vertexMostCcwInHalfEdge(m_vertex) ) 
                 m_halfedge = NULL; 
         else
                m_halfedge = m_pMesh->vertexNextCcwInHalfEdge(m_halfedge); 
        };
        void operator++(int)    //postfix
        {
         assert( m_halfedge != NULL ); 
         if( m_halfedge == m_pMesh->vertexMostCcwInHalfEdge(m_vertex) ) 
                 m_halfedge = NULL; 
         else
                m_halfedge = m_pMesh->vertexNextCcwInHalfEdge(m_halfedge); 
        };
        CHalfEdge * value() { return m_halfedge; };
         bool end(){ return m_halfedge == NULL; };
         CHalfEdge * operator*() { return value(); };

private:
        CBaseMesh<CVertex, CEdge, CFace, CHalfEdge> *        m_pMesh;
        CVertex *      m_vertex;
        CHalfEdge * m_halfedge;
};


//v -> v

template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class VertexVertexIterator
{
public:
        VertexVertexIterator( CVertex *  v )
        { 
                m_vertex = v; 
                m_halfedge = (CHalfEdge*)m_vertex->most_clw_out_halfedge();
        };

        ~VertexVertexIterator(){};

        void operator++() //prefix
        {
                assert( m_halfedge != NULL ); 
                
                if( !m_vertex->boundary() )
                {
                        if( m_halfedge != m_vertex->most_ccw_out_halfedge() )
                        {
                                m_halfedge = (CHalfEdge*)m_halfedge->ccw_rotate_about_source();
                        }
                        else
                        {
                                m_halfedge = NULL;
                        }
                        return;
                }

                if( m_vertex->boundary() )
                {
                        if( m_halfedge == (CHalfEdge*)m_vertex->most_ccw_in_halfedge() )
                        {
                                m_halfedge = NULL;
                                return;
                        }

                        CHalfEdge * he = (CHalfEdge*)m_halfedge->ccw_rotate_about_source();

                        if( he == NULL )
                        {
                                m_halfedge = (CHalfEdge*)m_vertex->most_ccw_in_halfedge();
                        }
                        else
                        {
                                m_halfedge = he;
                        }
                }

                return;
        };


        void operator++(int) //postfix
        {
                assert( m_halfedge != NULL ); 
                
                if( !m_vertex->boundary() )
                {
                        if( m_halfedge != (CHalfEdge*)m_vertex->most_ccw_out_halfedge() )
                        {
                                m_halfedge = (CHalfEdge*)m_halfedge->ccw_rotate_about_source();
                        }
                        else
                        {
                                m_halfedge = NULL;
                        }
                        return;
                }

                if( m_vertex->boundary() )
                {
                        if( m_halfedge == (CHalfEdge*)m_vertex->most_ccw_in_halfedge() )
                        {
                                m_halfedge = NULL;
                                return;
                        }

                        CHalfEdge * he = (CHalfEdge*)m_halfedge->ccw_rotate_about_source();

                        if( he == NULL )
                        {
                                m_halfedge = (CHalfEdge*)m_vertex->most_ccw_in_halfedge();
                        }
                        else
                        {
                                m_halfedge = he;
                        }
                }

                return;
        };

         CVertex * value() 
         { 
                 if( !m_vertex->boundary() )
                 {
                         return (CVertex*)m_halfedge->target(); 
                 }

                 if( m_halfedge != (CHalfEdge*)m_vertex->most_ccw_in_halfedge() )
                 {
                         return (CVertex*)m_halfedge->target();
                 }

                 if( m_halfedge == (CHalfEdge*)m_vertex->most_ccw_in_halfedge() )
                 {
                         return (CVertex*)m_halfedge->source();
                 }
                 return NULL;
         };

         CVertex * operator*() { return value(); };

         bool end(){ return m_halfedge == NULL; };

         void reset()   { m_halfedge = (CHalfEdge*)m_vertex->most_clw_out_halfedge(); };

private:
        CVertex *   m_vertex;
        CHalfEdge * m_halfedge;
};


//v -> edge
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class VertexEdgeIterator
{
public:
        VertexEdgeIterator( CVertex *  v )
        { 
                m_vertex = v; 
                m_halfedge = (CHalfEdge*)m_vertex->most_clw_out_halfedge();
        };

        ~VertexEdgeIterator(){};
        void operator++() //prefix
        {
                assert( m_halfedge != NULL ); 
                
                if( !m_vertex->boundary() )
                {
                        if( m_halfedge != (CHalfEdge*)m_vertex->most_ccw_out_halfedge() )
                        {
                                m_halfedge = (CHalfEdge*)m_halfedge->ccw_rotate_about_source();
                        }
                        else
                        {
                                m_halfedge = NULL;
                        }
                        return;
                }

                if( m_vertex->boundary() )
                {
                        if( m_halfedge == (CHalfEdge*)m_vertex->most_ccw_in_halfedge() )
                        {
                                m_halfedge = NULL;
                                return;
                        }

                        CHalfEdge * he = (CHalfEdge*)m_halfedge->ccw_rotate_about_source();

                        if( he == NULL )
                        {
                                m_halfedge = (CHalfEdge*)m_vertex->most_ccw_in_halfedge();
                        }
                        else
                        {
                                m_halfedge = he;
                        }
                }

                return;
        };
        void operator++(int) //postfix
        {
                assert( m_halfedge != NULL ); 
                
                if( !m_vertex->boundary() )
                {
                        if( m_halfedge != (CHalfEdge*)m_vertex->most_ccw_out_halfedge() )
                        {
                                m_halfedge = (CHalfEdge*)m_halfedge->ccw_rotate_about_source();
                        }
                        else
                        {
                                m_halfedge = NULL;
                        }
                        return;
                }

                if( m_vertex->boundary() )
                {
                        if( m_halfedge == (CHalfEdge*)m_vertex->most_ccw_in_halfedge() )
                        {
                                m_halfedge = NULL;
                                return;
                        }

                        CHalfEdge * he = (CHalfEdge*)m_halfedge->ccw_rotate_about_source();

                        if( he == NULL )
                        {
                                m_halfedge = (CHalfEdge*)m_vertex->most_ccw_in_halfedge();
                        }
                        else
                        {
                                m_halfedge = he;
                        }
                }

                return;
        };
         CEdge * value() 
         { 
                 assert( m_halfedge != NULL );
                 return (CEdge*)m_halfedge->edge();
         };

         CEdge * operator*() { return value(); };
         bool end(){ return m_halfedge == NULL; };
         void reset()   { m_halfedge = (CHalfEdge*)m_vertex->most_clw_out_halfedge(); };

private:
        CVertex *   m_vertex;
        CHalfEdge * m_halfedge;
};



// v->face
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class VertexFaceIterator
{
public:
        VertexFaceIterator( CVertex * & v )
        { 
                m_vertex = v; 
                m_halfedge = (CHalfEdge*)m_vertex->most_clw_out_halfedge(); 
        };
        ~VertexFaceIterator(){};
        void operator++() //prefix
        {
                assert( m_halfedge != NULL );  

                if( m_halfedge == (CHalfEdge*)m_vertex->most_ccw_out_halfedge() ) 
                {
                        m_halfedge = NULL;
                        return;
                }
                m_halfedge = (CHalfEdge*)m_halfedge->ccw_rotate_about_source();
        };
        void operator++(int) //postfix
        {
                assert( m_halfedge != NULL );  

                if( m_halfedge == (CHalfEdge*)m_vertex->most_ccw_out_halfedge() ) 
                {
                        m_halfedge = NULL;
                        return;
                }
                m_halfedge = (CHalfEdge*)m_halfedge->ccw_rotate_about_source();
        };
        CFace * value() { return (CFace*) m_halfedge->face(); };
         CFace * operator*() { return value(); };
         bool end(){ return m_halfedge == NULL; };
         void reset()   { m_halfedge = (CHalfEdge*)m_vertex->most_clw_out_halfedge(); };

private:
        CVertex *   m_vertex;
        CHalfEdge * m_halfedge;
};

// f -> halfedge
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class FaceHalfedgeIterator
{
public:
        FaceHalfedgeIterator( CFace * f )
        { 
                m_face = f; 
                m_halfedge = (CHalfEdge*)f->halfedge(); 
        };
        ~FaceHalfedgeIterator(){};
        void operator++() //prefix
        {
                assert( m_halfedge != NULL );
                m_halfedge = (CHalfEdge*)m_halfedge->he_next();

                if( m_halfedge == m_face->halfedge() )
                {
                         m_halfedge = NULL;
                        return;
                };
        }

        void operator++(int) //postfix
        {
                assert( m_halfedge != NULL );
                m_halfedge = (CHalfEdge*)m_halfedge->he_next();

                if( m_halfedge == m_face->halfedge() )
                {
                         m_halfedge = NULL;
                        return;
                };
        }

        CHalfEdge * value() { return m_halfedge; };
        CHalfEdge * operator*() { return value(); };

        bool end(){ return m_halfedge == NULL; };

private:
        CFace *        m_face;
        CHalfEdge * m_halfedge;
};


// f -> edge
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class FaceEdgeIterator
{
public:
        FaceEdgeIterator( CFace * f )
        { 
                m_face = f; 
                m_halfedge = (CHalfEdge*)f->halfedge(); 
        };

        ~FaceEdgeIterator(){};
        void operator++()       //prefix
        {
                assert( m_halfedge != NULL );
                m_halfedge = (CHalfEdge*)m_halfedge->he_next();

                if( m_halfedge == (CHalfEdge*)m_face->halfedge() )
                {
                         m_halfedge = NULL;
                        return;
                };
        }

        void operator++(int)    //postfix
        {
                assert( m_halfedge != NULL );
                m_halfedge = (CHalfEdge*)m_halfedge->he_next();

                if( m_halfedge == m_face->halfedge() )
                {
                         m_halfedge = NULL;
                        return;
                };
        }
        CEdge * value() { return (CEdge*) m_halfedge->edge(); };
        CEdge * operator*() { return value(); };
        bool end(){ return m_halfedge == NULL; };

private:
        CFace  *       m_face;
        CHalfEdge * m_halfedge;
};


// f -> vertex
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class FaceVertexIterator
{
public:
        FaceVertexIterator( CFace * f )
        { 
                m_face = f; 
                m_halfedge = (CHalfEdge*)f->halfedge(); 
        };
        ~FaceVertexIterator(){};
        void operator++() //prefix
        {
                assert( m_halfedge != NULL );
                m_halfedge = (CHalfEdge*)m_halfedge->he_next();

                if( m_halfedge == (CHalfEdge*)m_face->halfedge() )
                {
                         m_halfedge = NULL;
                        return;
                };
        }

        void operator++(int) //postfix
        {
                assert( m_halfedge != NULL );
                m_halfedge = (CHalfEdge*)m_halfedge->he_next();

                if( m_halfedge == (CHalfEdge*)m_face->halfedge() )
                {
                         m_halfedge = NULL;
                        return;
                };
        }
        CVertex * value() { return (CVertex*) m_halfedge->target(); };
        CVertex * operator*() { return value(); };
        bool end(){ return m_halfedge == NULL; };

private:
        CFace         * m_face;
        CHalfEdge * m_halfedge;
};


// mesh->v
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class MeshVertexIterator
{
public:
        MeshVertexIterator( CBaseMesh<CVertex,CEdge,CFace,CHalfEdge> * pMesh )
        {
                m_pMesh = pMesh;
                m_iter = m_pMesh->vertices().begin();
        }
        CVertex * value() { return *m_iter; };
        CVertex * operator*(){ return value(); };
        void operator++()        { ++ m_iter; }; //prefix
        void operator++(int) { ++ m_iter; }; //postfix
        bool end() { return m_iter == m_pMesh->vertices().end(); }
        
private:
        CBaseMesh<CVertex,CEdge,CFace,CHalfEdge> * m_pMesh;
        typename std::list<CVertex*>::iterator m_iter;
};

// mesh->f
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class MeshFaceIterator
{
public:
        MeshFaceIterator( CBaseMesh<CVertex,CEdge,CFace,CHalfEdge> * pMesh )
        {
      m_pMesh = pMesh;
      m_iter = pMesh->faces().begin();
        }
        CFace * value() { return *m_iter; };
        CFace * operator*(){ return value(); };

        void operator++() { ++ m_iter; }; //prefix
        void operator++(int) { ++ m_iter; }; //postfix
        bool end() { return m_iter == m_pMesh->faces().end(); }

private:
        CBaseMesh<CVertex,CEdge,CFace,CHalfEdge> * m_pMesh;
        typename std::list<CFace*>::iterator  m_iter;
};

//Mesh->e
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class MeshEdgeIterator
{
public:
        MeshEdgeIterator( CBaseMesh<CVertex,CEdge,CFace,CHalfEdge> * pMesh )
        {
                m_pMesh = pMesh;
                m_iter = m_pMesh->edges().begin();
        }
        CEdge * value() { return *m_iter; };
        CEdge * operator*(){ return value(); };
        void operator++() { ++ m_iter; }; //prefix
        void operator++(int) {m_iter++; }; //postfix
        bool end() { return m_iter == m_pMesh->edges().end(); }


private:
        CBaseMesh<CVertex,CEdge,CFace,CHalfEdge> * m_pMesh;
        typename std::list<CEdge*>::iterator m_iter;
};

// Mesh->he
template<typename CVertex, typename CEdge, typename CFace, typename CHalfEdge>
class MeshHalfEdgeIterator
{
public:
        MeshHalfEdgeIterator( CBaseMesh<CVertex,CEdge,CFace,CHalfEdge> * pMesh )
        {
     m_pMesh = pMesh;
     m_iter = m_pMesh->edges().begin();
     m_id = 0;
        }
        CHalfEdge * value() { CEdge * e = *m_iter; return (CHalfEdge*)e->halfedge(m_id); };
        CHalfEdge * operator*(){ return value(); };
        void operator++() //prefix
        { 
                ++m_id;

                switch( m_id )
                {
                case 1:
                        {
                                CEdge * e = *m_iter;
                                if( e->halfedge(m_id) == NULL )
                                {
                                        m_id = 0;
                                        ++ m_iter;
                                }
                        }
                        break;
                case 2:
                        m_id = 0;
                        ++m_iter;
                        break;
                }
        };
        void operator++(int) //postfix
        { 
                ++m_id;

                switch( m_id )
                {
                case 1:
                        {
                                CEdge * e = *m_iter;
                                if( e->halfedge(m_id) == NULL )
                                {
                                        m_id = 0;
                                        ++ m_iter;
                                }
                        }
                        break;
                case 2:
                        m_id = 0;
                        ++m_iter;
                        break;
                }
        };
        bool end() { return m_iter == m_pMesh->edges().end(); }
        

private:
        CHalfEdge * m_he;
        CBaseMesh<CVertex,CEdge,CFace,CHalfEdge> *       m_pMesh;
        typename std::list<CEdge*>::iterator m_iter;
        int  m_id;
};


} //Iterators

#endif