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

---

FuncBpo.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_FuncBpo_h
#define Impala_Core_Array_Pattern_FuncBpo_h

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

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


template <class DstArrayT, class Src1ArrayT, class Src2ArrayT, class BpoT>
void
FuncBpo(DstArrayT* dst, Src1ArrayT* src1, Src2ArrayT* src2, BpoT& bpo,
        TagTransInVar dummy, TagCallPointer dummy2)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename Src1ArrayT::StorType Src1StorT;
    typedef typename Src2ArrayT::StorType Src2StorT;

    int width = ArrayCW(dst);
    int height = ArrayCH(dst);
    for (int y=0 ; y<height ; y++)
    {
        Src1StorT* s1Ptr = ArrayCPB(src1, 0, y);
        Src2StorT* s2Ptr = ArrayCPB(src2, 0, y);
        DstStorT* dPtr = ArrayCPB(dst, 0, y);
        for (int x=0 ; x<width ; x++)
        {
            bpo.DoIt(dPtr, s1Ptr, s2Ptr);
            dPtr += DstArrayT::ElemSize();
            s1Ptr += Src1ArrayT::ElemSize();
            s2Ptr += Src2ArrayT::ElemSize();
        }
    }
}

template <class DstArrayT, class Src1ArrayT, class Src2ArrayT, class BpoT>
void
FuncBpo(DstArrayT* dst, Src1ArrayT* src1, Src2ArrayT* src2, BpoT& bpo,
        TagTransVar dummy, TagCallPointer dummy2)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename Src1ArrayT::StorType Src1StorT;
    typedef typename Src2ArrayT::StorType Src2StorT;

    int width = ArrayCW(dst);
    int height = ArrayCH(dst);
    for (int y=0 ; y<height ; y++)
    {
        Src1StorT* s1Ptr = ArrayCPB(src1, 0, y);
        Src2StorT* s2Ptr = ArrayCPB(src2, 0, y);
        DstStorT* dPtr = ArrayCPB(dst, 0, y);
        for (int x=0 ; x<width ; x++) 
        {
            bpo.DoIt(dPtr, s1Ptr, s2Ptr, x, y);
            dPtr += DstArrayT::ElemSize();
            s1Ptr += Src1ArrayT::ElemSize();
            s2Ptr += Src2ArrayT::ElemSize();
        }
    }
}

template <class DstArrayT, class Src1ArrayT, class Src2ArrayT, class BpoT>
void
FuncBpo(DstArrayT* dst, Src1ArrayT* src1, Src2ArrayT* src2, BpoT& bpo,
        TagTransInVar dummy, TagCallValue dummy2)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename Src1ArrayT::StorType Src1StorT;
    typedef typename Src1ArrayT::ArithType Src1ArithT;
    typedef typename Src2ArrayT::StorType Src2StorT;
    typedef typename Src2ArrayT::ArithType Src2ArithT;

    int width = ArrayCW(dst);
    int height = ArrayCH(dst);
    for (int y=0 ; y<height ; y++)
    {
        Src1StorT* s1Ptr = ArrayCPB(src1, 0, y);
        Src2StorT* s2Ptr = ArrayCPB(src2, 0, y);
        DstStorT* dPtr = ArrayCPB(dst, 0, y);
        for (int x=0 ; x<width ; x++)
        {
            PtrWrite(dPtr, bpo.DoIt(PtrRead(s1Ptr, Src1ArithT()),
                                      PtrRead(s2Ptr, Src2ArithT())));
            dPtr += DstArrayT::ElemSize();
            s1Ptr += Src1ArrayT::ElemSize();
            s2Ptr += Src2ArrayT::ElemSize();
        }
    }
}

template <class DstArrayT, class Src1ArrayT, class Src2ArrayT, class BpoT>
void
FuncBpo(DstArrayT* dst, Src1ArrayT* src1, Src2ArrayT* src2, BpoT& bpo,
        TagTransVar dummy, TagCallValue dummy2)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename Src1ArrayT::StorType Src1StorT;
    typedef typename Src1ArrayT::ArithType Src1ArithT;
    typedef typename Src2ArrayT::StorType Src2StorT;
    typedef typename Src2ArrayT::ArithType Src2ArithT;

    int width = ArrayCW(dst);
    int height = ArrayCH(dst);
    for (int y=0 ; y<height ; y++)
    {
        Src1StorT* s1Ptr = ArrayCPB(src1, 0, y);
        Src2StorT* s2Ptr = ArrayCPB(src2, 0, y);
        DstStorT* dPtr = ArrayCPB(dst, 0, y);
        for (int x=0 ; x<width ; x++)
        {
            PtrWrite(dPtr, bpo.DoIt(PtrRead(s1Ptr, Src1ArithT()),
                                      PtrRead(s2Ptr, Src2ArithT()),x,y));
            dPtr += DstArrayT::ElemSize();
            s1Ptr += Src1ArrayT::ElemSize();
            s2Ptr += Src2ArrayT::ElemSize();
        }
    }
/* old:
    for (int z=0 ; z<dstSize.z() ; z++) {
        for (int y=0 ; y<dstSize.y() ; y++) {
            for (int x=0 ; x<dstSize.x() ; x++) {
                dstPtr.writeIncX(
                    bpo.DoIt(src1Ptr.readIncX(), src2Ptr.readIncX(), x, y, z));
            }
        }
    }
*/
}

template <class DstArrayT, class Src1ArrayT, class Src2ArrayT, class BpoT>
void
FuncBpoDispatch(DstArrayT* dst, Src1ArrayT* src1, Src2ArrayT* src2, BpoT& bpo)
{
    FuncBpo(dst, src1, src2, bpo, typename BpoT::TransVarianceCategory(),
            typename BpoT::CallCategory());
}

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

#endif

---