|| || || || || ||

---

CoordinateEnumerators.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Trait_CoordinateEnumerators_h
#define Impala_Core_Array_Trait_CoordinateEnumerators_h

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Trait
{


/* the default Coordinate Enumerator Enums all Coords in an image
Coordinate Enumerators are responsible for the looping through images
*/
/*
template<ArrayT>
class CoordinateEnumeratorAll
{
public:
    CoordinateEnumeratorAll(ArrayT* array)
    {
        mWidth = array->CW();
        mHeight = array->CH();
        mX = 0;
        mY = 0;
        mDone = false;
    }

    inline Array::StorType* AccessPointer(ArrayT* array)
    {
        return array->CPB(mX, mY);
    }

    inline void NextCoordinate()
    {
        mX++;
        if (mX >= mWidth)
        {
            mX = 0;
            mY++;
            if (mY >= mHeight)
            {  
                mDone = true;
                mY = 0;
            }
        }
    }

    inline bool Array::Done()
    {
        return mDone;
    }

private:
    int mHeight, mWidth;
    int mX, mY;
    bool mDone;
};
*/
template<class DstArrayT, class SrcArrayT>
class CoordinateEnumeratorAll2
{
public:
    CoordinateEnumeratorAll2(DstArrayT* dst, SrcArrayT* src)
    {
        mWidth = dst->CW();
        mHeight = dst->CH();
        mX = 0;
        mY = 0;
        mDone = false;
        mSrcPointer = dst->CPB(mX, mY);
        mDstPointer = src->CPB(mX, mY);
    }

    typename DstArrayT::StorType*
    DstPointer(DstArrayT* dst)
    {
        return mDstPointer;
    }

    typename SrcArrayT::ArithType*
    SrcPointer(SrcArrayT* src)
    {
        return mSrcPointer;
    }

    void
    NextCoordinate(DstArrayT* dst, SrcArrayT* src)
    {
        mX++;
        mDstPointer += DstArrayT::ElemSize();
        mSrcPointer += SrcArrayT::ElemSize();
        if (mX >= mWidth)
        {
            mX = 0;
            mY++;
            mDstPointer = dst->CPB(mX, mY);
            mSrcPointer = src->CPB(mX, mY);
            if (mY >= mHeight)
            {  
                mDone = true;
                mY = 0;
            }
        }
    }

    bool
    Done() const
    {
        return mDone;
    }

    int
    X() const
    {
        return mX;
    }

    int
    Y() const
    {
        return mY;
    }

private:
    int mHeight, mWidth;
    int mX, mY;
    bool mDone;
    typename DstArrayT::StorType* mDstPointer;
    typename SrcArrayT::ArithType* mSrcPointer;
};

/********
 * rect *
 ********/

#include "Core/Geometry/Rectangle.h"

template<class DstArrayT, class SrcArrayT>
class CoordinateEnumeratorRect
{
public:
    CoordinateEnumeratorRect(DstArrayT* dst, SrcArrayT* src,
                             const Geometry::Rectangle& rect)
        :mRect(rect)
    {
        mX = rect.mLeft;
        mY = rect.mTop;
        mDone = false;
        mDstPointer = dst->CPB(mX, mY);
        mSrcPointer = src->CPB(mX, mY);
    }

    typename DstArrayT::StorType*
    DstPointer(DstArrayT* dst)
    {
        return mDstPointer;
    }

    typename SrcArrayT::StorType*
    SrcPointer(SrcArrayT* src)
    {
        return mSrcPointer;
    }

    void
    NextCoordinate(DstArrayT* dst, SrcArrayT* src)
    {
        mX++;
        mDstPointer += DstArrayT::ElemSize();
        mSrcPointer += SrcArrayT::ElemSize();
        if (mX >= mRect.Right())
        {
            mX = mRect.Left();
            mY++;
            mDstPointer = dst->CPB(mX, mY);
            mSrcPointer = src->CPB(mX, mY);
            if (mY >= mRect.Bottom())
            {  
                mDone = true;
                mY = mRect.Top();
            }
        }
    }

    bool
    Done() const
    {
        return mDone;
    }

    int
    X() const
    {
        return mX;
    }

    int
    Y() const
    {
        return mY;
    }

private:
    const Geometry::Rectangle& mRect;
    int mX, mY;
    bool mDone;
    typename DstArrayT::StorType* mDstPointer;
    typename SrcArrayT::StorType* mSrcPointer;
};

} // namespace Trait
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---