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

---

FuncNgbOp2d.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_FuncNgbOp2d_h
#define Impala_Core_Array_Pattern_FuncNgbOp2d_h

#include "Core/Array/Pattern/Categories.h"
#include "Core/Array/Pattern/ArrayFunc.h"

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Pattern
{


#undef Next

/**********************************************************************/
template <class SrcArrayT, class NgbT>
inline void
FuncNgbOp2d_Pix_P1Cnum(SrcArrayT* src, int x, int y, NgbT& ngb)
{
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;
    typedef typename NgbT::CnumType CnumType;

    for (CnumType cnum = ngb.Begin() ; cnum != ngb.End() ; cnum.Inc())
    {
        SrcStorT* nPtr = ArrayCPB(src, x + cnum.X(), y + cnum.Y());
        ngb.NextEl(cnum.X(), cnum.Y(), PtrRead(nPtr, SrcArithT()));
    }
}

template <class SrcStorT, class SrcArithT, class NgbT>
inline void
FuncNgbOp2d_Pix_P1Loop(SrcStorT* sPtr, NgbT& ngb, int ngbWidth, int ngbHeight,
                       int srcIncX, int srcIncY, SrcArithT)
{
    for (int j=0 ; j<ngbHeight ; j++)
    {
        for (int i=0 ; i<ngbWidth ; i++)
        {
            ngb.NextEl(i, j, PtrRead(sPtr, SrcArithT()));
            sPtr += srcIncX;
        }
        sPtr += srcIncY;
    }
}

template <class SrcStorT, class SrcArithT, class NgbT>
inline void
FuncNgbOp2d_Pix_P2Loop(SrcStorT* sPtr, NgbT& ngb, int ngbWidth, int ngbHeight,
                       int srcIncX, int srcIncY, SrcArithT)
{
    for (int j=0 ; j<ngbHeight ; j++)
    {
        for (int i=0 ; i<ngbWidth ; i++)
        {
            ngb.NextEl2(i, j, PtrRead(sPtr, SrcArithT()));
            sPtr += srcIncX;
        }
        sPtr += srcIncY;
    }
}


//End of Pix_variations.



template <class DstArrayT, class SrcArrayT, class NgbT>
inline void
FuncNgbOp2d_Row(DstArrayT* dst, SrcArrayT* src, NgbT& ngb, int y,
                Tag1Phase dummy1, TagCnum dummy2)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;

    int width = ArrayCW(dst);
    DstStorT* dPtr = ArrayCPB(dst, 0, y);
    SrcStorT* sPtr = ArrayCPB(src, 0, y);
    for (int x=0 ; x<width ; x++)
    {
        ngb.Init(x, y, PtrRead(sPtr, SrcArithT()));
        FuncNgbOp2d_Pix_P1Cnum(src, x, y, ngb);
        PtrWrite(dPtr, ngb.Result());
        dPtr += DstArrayT::ElemSize();
        sPtr += SrcArrayT::ElemSize();
    }
}

template <class DstArrayT, class SrcArrayT, class NgbT>
inline void
FuncNgbOp2d_Row(DstArrayT* dst, SrcArrayT* src, NgbT& ngb, int y,
                Tag1Phase dummy1, TagLoop dummy2)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;

    int ngbWidth = ngb.Width();
    int ngbHeight = ngb.Height();
    int width = ArrayCW(dst);
    DstStorT* dPtr = ArrayCPB(dst, 0, y);
    SrcStorT* sPtr = ArrayCPB(src, -ngbWidth/2, y-ngbHeight/2);
    SrcStorT* cenPtr = ArrayCPB(src, 0, y);
    int srcIncX = ArrayInc(src, 1, 0);
    int srcIncY = ArrayInc(src, -ngbWidth, 1);
    for (int x=0 ; x<width ; x++)
    {
        ngb.Init(x, y, PtrRead(cenPtr, SrcArithT()));
        FuncNgbOp2d_Pix_P1Loop(sPtr, ngb, ngbWidth, ngbHeight, srcIncX,
                               srcIncY, SrcArithT());
        PtrWrite(dPtr, ngb.Result());
        dPtr += DstArrayT::ElemSize();
        sPtr += SrcArrayT::ElemSize();
        cenPtr += SrcArrayT::ElemSize();
    }
}

template <class DstArrayT, class SrcArrayT, class NgbT>
inline void
FuncNgbOp2d_Row(DstArrayT* dst, SrcArrayT* src, NgbT& ngb, int y,
                Tag2Phase dummy1, TagLoop dummy2)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;

    int ngbWidth = ngb.Width();
    int ngbHeight = ngb.Height();
    int width = ArrayCW(dst);
    DstStorT* dPtr = ArrayCPB(dst, 0, y);
    SrcStorT* sPtr = ArrayCPB(src, -ngbWidth/2, y-ngbHeight/2);
    SrcStorT* cenPtr = ArrayCPB(src, 0, y);
    int srcIncX = ArrayInc(src, 1, 0);
    int srcIncY = ArrayInc(src, -ngbWidth, 1);
    for (int x=0 ; x<width ; x++)
    {
        ngb.Init(x, y, PtrRead(cenPtr, SrcArithT()));
        FuncNgbOp2d_Pix_P1Loop(sPtr, ngb, ngbWidth, ngbHeight, srcIncX,
                               srcIncY, SrcArithT());
        ngb.Init2(x, y, PtrRead(cenPtr, SrcArithT()));
        FuncNgbOp2d_Pix_P2Loop(sPtr, ngb, ngbWidth, ngbHeight, srcIncX,
                               srcIncY, SrcArithT());
        PtrWrite(dPtr, ngb.Result());
        dPtr += DstArrayT::ElemSize();
        sPtr += SrcArrayT::ElemSize();
        cenPtr += SrcArrayT::ElemSize();
    }
}


template <class DstArrayT, class SrcArrayT, class NgbT>
inline void
FuncNgbOp2d_Row(DstArrayT* dst, SrcArrayT* src, NgbT& ngb, int y,
                TagNPhase dummy1, TagLoop dummy2)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;

    int ngbWidth = ngb.Width();
    int ngbHeight = ngb.Height();
    int width = ArrayCW(dst);
    DstStorT* dPtr = ArrayCPB(dst, 0, y);
    SrcStorT* sPtr = ArrayCPB(src, -ngbWidth/2, y-ngbHeight/2);
    SrcStorT* cenPtr = ArrayCPB(src, 0, y);
    int srcIncX = ArrayInc(src, 1, 0);
    int srcIncY = ArrayInc(src, -ngbWidth, 1);
    for (int x=0 ; x<width ; x++)
    {
        int phase = 1;
        do {
            ngb.Init(phase, x, y, PtrRead(cenPtr, SrcArithT()));
            FuncNgbOp2d_Pix_P1Loop(sPtr, ngb, ngbWidth, ngbHeight, srcIncX,
                                   srcIncY, SrcArithT());
            ngb.Done(phase);
        } while (ngb.HasNextPhase(phase++));
        PtrWrite(dPtr, ngb.Result());
        dPtr += DstArrayT::ElemSize();
        sPtr += SrcArrayT::ElemSize();
        cenPtr += SrcArrayT::ElemSize();
    }
}

//End of Row_variations.

template<class DstArrayT, class SrcArrayT, class NgbT>
void
FuncNgbOp2dDispatch(DstArrayT* dst, SrcArrayT* src, NgbT& ngb)
{
    int height = ArrayCH(dst);
    for (int y=0 ; y<height ; y++)
    {
        FuncNgbOp2d_Row(dst, src, ngb, y,
                        typename NgbT::PhaseCategory(),
                        typename NgbT::IteratorCategory());
    }
}

} // namespace Pattern
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---