halfedge_pos.h

Go to the documentation of this file.

#ifndef VCG_HEDGE_POS
#define VCG_HEDGE_POS

namespace vcg
{
    namespace hedge
    {
        template <class MeshType> class Pos
        {

        public:

            typedef typename MeshType::VertexPointer VertexPointer;
            typedef typename MeshType::EdgePointer EdgePointer;
            typedef typename MeshType::HEdgePointer HEdgePointer;
            typedef typename MeshType::FacePointer FacePointer;

            HEdgePointer he;

            bool direction;

            Pos(HEdgePointer hep, bool dir)
            {
                he = hep;
                direction = dir;
            }

            Pos(HEdgePointer hep)
            {
                he = hep;
                direction = 1;
            }

            void FlipV()
            {
                direction = !direction;
            }

            void FlipE()
            {
                if(!direction)
                    he = he->HNp();
                else
                    if(he->HasHPrevAdjacency())
                        he = he->HPp();
                    else
                    {
                        HEdgePointer aux = he;
                        while(aux->HNp() != he)
                            aux = aux->HNp();
                        he = aux;
                    }

                direction = !direction;
            }

            void FlipF()
            {
                direction = !direction;
                he = he->HOp();
            }

            VertexPointer V()
            {
                if(direction)
                    return he->HVp();
                else
                    return he->HOp()->HVp();
            }

            VertexPointer Vo()
            {
                if(!direction)
                    return he->HVp();
                else
                    return he->HOp()->HVp();
            }
                        
            HEdgePointer HE()
            {
                return he;
            }

            EdgePointer E()
            {
                return he->HEp();
            }

            FacePointer F()
            {
                return he->HFp();
            }

            inline bool operator == ( Pos const & p ) const
            {
                return (he == p.he && direction == p.direction);
            }

            inline bool operator != ( Pos const & p ) const
            {
                return (he != p.he || direction != p.direction);
            }

        };

    }
}

#endif // VCG_HEDGE_POS