TriangleAroundVertexIterator.h

Go to the documentation of this file.

// (c) 2010 Geom e.U. Bernhard Kornberger, Graz/Austria. All rights reserved.
//
// This file is part of the Fade2D library. You can use it for your personal
// non-commercial research. Licensees holding a commercial license may use this
// file in accordance with the Commercial License Agreement provided
// with the Software.
//
// This software is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING
// THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Please contact the author if any conditions of this licensing are not clear
// to you.
//
// Author: Bernhard Kornberger, bkorn (at) geom.at
// http://www.geom.at
 
#pragma once
#include "common.h"
#include "Point2.h"
#include "Triangle2.h"
//#include "tools.h"
 
#include "common.h"
#if GEOM_PSEUDO3D==GEOM_TRUE
    namespace GEOM_FADE25D {
#elif GEOM_PSEUDO3D==GEOM_FALSE
    namespace GEOM_FADE2D {
#else
    #error GEOM_PSEUDO3D is not defined
#endif
 
inline
int incBy1( int num)
{
    ++num;
    if(num>2) return 0;
    return num;
}
 
inline
int incBy2( int num)
{
    --num;
    if(num<0) return 2;
    return num;
}
 
class CLASS_DECLSPEC  TriangleAroundVertexIterator
{
public:
    explicit TriangleAroundVertexIterator(const Point2* pPnt_):pPnt(pPnt_),pTr(pPnt_->getIncidentTriangle()),pSavedTr(NULL)
    {
        if(pTr==NULL)
        {
            //flog("TriangleAroundVertexIterator::TriangleAroundVertexIterator(), created from an invalid point");
            FadeException fadeEx;
            throw fadeEx;
        }
        assert(pTr!=NULL);
 
    }
    TriangleAroundVertexIterator(Point2* pPnt_, Triangle2* pTr_):pPnt(pPnt_),pTr(pTr_),pSavedTr(NULL)
    {
        assert(pTr!=NULL);
    }
    TriangleAroundVertexIterator(const TriangleAroundVertexIterator& it) : pPnt(it.pPnt),pTr(it.pTr),pSavedTr(NULL)
    {
        assert(pTr!=NULL);
    }
    TriangleAroundVertexIterator &operator=(const TriangleAroundVertexIterator& other)
    {
        pPnt=other.pPnt;
        pTr=other.pTr;
        pSavedTr=other.pSavedTr;
        return *this;
    }
 
    TriangleAroundVertexIterator& operator++()
    {
//GCOUT<<"tavi++"<<std::endl;
        if(pTr==NULL)
        {
//GCOUT<<"pTr==NULL, calling loop"<<std::endl;
            loop();
            return *this;
        }
 
        int ccwIdx=incBy1(pTr->getIntraTriangleIndex(pPnt));
//GCOUT<<"ccwIdx="<<ccwIdx<<"now swapping saved="<<pSavedTr<<", pTr="<<pTr<<std::endl;;
        std::swap(pSavedTr,pTr);
        pTr=pSavedTr->getOppositeTriangle(ccwIdx);
//GCOUT<<"and pTr is now the opposite triangle of pSavedTr="<<*pSavedTr<<", namely "<<pTr<<std::endl;
 
        return *this;
    }
 
    TriangleAroundVertexIterator& operator--()
    {
        if(pTr==NULL)
        {
            loop();
            return *this;
        }
        int cwIdx=incBy2(pTr->getIntraTriangleIndex(pPnt));
        std::swap(pSavedTr,pTr);
        pTr=pSavedTr->getOppositeTriangle(cwIdx);
        return *this;
    }
    bool operator==(const TriangleAroundVertexIterator& rhs)
    {
        return (pPnt==rhs.pPnt && pTr==rhs.pTr);
    }
    bool operator!=(const TriangleAroundVertexIterator& rhs)
    {
        return (pPnt!=rhs.pPnt || pTr!=rhs.pTr);
    }
    Triangle2* operator*()
    {
        return pTr;
    }
    Triangle2* previewNextTriangle()
    {
        TriangleAroundVertexIterator tmp(*this);
        ++tmp;
        return *tmp;
    }
    Triangle2* previewPrevTriangle()
    {
        TriangleAroundVertexIterator tmp(*this);
        --tmp;
        return *tmp;
    }
 
 
 
protected:
    const Point2* pPnt;
    Triangle2 *pTr,*pSavedTr;
    void loop()
    {
        assert(pTr==NULL && pSavedTr!=NULL);
 
        enum DIRECTION{DIRECTION_NONE,DIRECTION_BACK,DIRECTION_FWD};
        DIRECTION direction(DIRECTION_NONE);
 
        int axisIndex=pSavedTr->getIntraTriangleIndex(pPnt);
 
        if(pSavedTr->getOppositeTriangle(incBy2(axisIndex))!=NULL)
        {
            direction=DIRECTION_BACK;
        }
        if(pSavedTr->getOppositeTriangle(incBy1(axisIndex))!=NULL)
        {
            assert(direction==DIRECTION_NONE);
            direction=DIRECTION_FWD;
        }
        pTr=pSavedTr;
        if(direction==DIRECTION_FWD) while(*operator++()!=NULL); // fast forward
        if(direction==DIRECTION_BACK) while(*operator--()!=NULL); // rewind
        pTr=pSavedTr;
    }
};
 
 
} // (namespace)