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

---

FuncGenConv2dSep.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_FuncGenConv2dSep_h
#define Impala_Core_Array_Pattern_FuncGenConv2dSep_h

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

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


/**********************************************************************/
template<class DstStorT, class SrcStorT, class KerStorT, class KerArithT,
         class PixOpT, class RedOpT>
static inline void
FuncGenConv2dSep_Pix_Xdir(DstStorT* dPtr, SrcStorT* sPtr, KerStorT* kPtr,
                          int kerWidth, int srcInc, int kerInc, PixOpT& pixOp,
                          RedOpT& redOp, KerArithT neutralElement,
                          TagCallValue dummy)
{
    KerArithT result(neutralElement);
    for (int k=0; k<kerWidth; k++)
    {
        redOp.DoIt(result, pixOp.DoIt(PtrRead(sPtr, KerArithT()),
                                      PtrRead(kPtr, KerArithT())));
        sPtr += srcInc;
        kPtr += kerInc;
    }
    PtrWrite(dPtr, result);
}

template<class DstStorT, class SrcStorT, class KerStorT, class KerArithT,
         class PixOpT, class RedOpT>
static inline void
FuncGenConv2dSep_Pix_Ydir(DstStorT* dPtr, SrcStorT* sPtr, KerStorT* kPtr,
                          int kerWidth, int srcInc, int kerInc, PixOpT& pixOp,
                          RedOpT& redOp, KerArithT neutralElement,
                          TagCallValue dummy)
{
    KerArithT result(neutralElement);
    for (int k=0; k<kerWidth; k++)
    {
        redOp.DoIt(result, pixOp.DoIt(PtrRead(sPtr, KerArithT()),
                                      PtrRead(kPtr, KerArithT())));
        sPtr += srcInc;
        kPtr += kerInc;
    }
    PtrWrite(dPtr, result);
}

//End of Pix_variations.



template<class DstArrayT, class SrcArrayT, class KerArrayT,
         class PixOpT, class RedOpT>
static void
FuncGenConv2dSep_Line_Xdir(DstArrayT* dst, SrcArrayT* src, KerArrayT* ker,
                           PixOpT& pixOp, RedOpT& redOp, int y,
                           TagCallValue tag)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;
    typedef typename KerArrayT::StorType KerStorT;
    typedef typename KerArrayT::ArithType KerArithT;

    int width = ArrayCW(dst);
    int kerWidth = ArrayCW(ker);
    int kerBW = ArrayCW(ker) / 2;
    KerArithT neutralElement = RedOpT::NeutralElement();
    DstStorT* dPtr = ArrayCPB(dst, 0, y);
    SrcStorT* sPtr = ArrayCPB(src, -kerBW, y);
    KerStorT* kPtr = ArrayCPB(ker, 0, 0);
    for (int x=0 ; x<width ; x++)
    {
        FuncGenConv2dSep_Pix_Xdir(dPtr, sPtr, kPtr, kerWidth,
                                  SrcArrayT::ElemSize(), KerArrayT::ElemSize(),
                                  pixOp, redOp, neutralElement, tag);
        dPtr += DstArrayT::ElemSize();
        sPtr += SrcArrayT::ElemSize();
    }
}

template<class DstArrayT, class SrcArrayT, class KerArrayT,
         class PixOpT, class RedOpT>
static void
FuncGenConv2dSep_Line_XdirInc(DstArrayT* dst, SrcArrayT* src, KerArrayT* ker,
                              PixOpT& pixOp, RedOpT& redOp, int y,
                              TagCallPointer dummy)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename KerArrayT::StorType KerStorT;

    int width = ArrayCW(dst);
    int kerWidth = ArrayCW(ker);
    int kerBW = ArrayCW(ker) / 2;
    KerStorT buf[KerArrayT::ElemSize()];
    for (int x=0 ; x<width ; x++)
    {
        DstStorT* dPtr = ArrayCPB(dst, x, y);
        SrcStorT* sPtr = ArrayCPB(src, -kerBW + x, y);
        KerStorT* kPtr = ArrayCPB(ker, 0, 0);
        redOp.setNeutral(dPtr);
        for (int k=0; k<kerWidth; k++)
        {
            pixOp.DoIt(buf, sPtr, kPtr);
            sPtr += SrcArrayT::ElemSize();
            kPtr += KerArrayT::ElemSize();
            redOp.DoIt(dPtr, buf);
        }
    }
}

template<class DstArrayT, class SrcArrayT, class KerArrayT,
         class PixOpT, class RedOpT>
static void
FuncGenConv2dSep_Line_XdirInc(DstArrayT* dst, SrcArrayT* src, KerArrayT* ker,
                              PixOpT& pixOp, RedOpT& redOp, int y,
                              TagCallValue dummy)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;
    typedef typename KerArrayT::StorType KerStorT;
    typedef typename KerArrayT::ArithType KerArithT;

    int width = ArrayCW(dst);
    int kerWidth = ArrayCW(ker);
    int kerBW = ArrayCW(ker) / 2;
    KerArithT neutralElement = RedOpT::NeutralElement();
    DstStorT* dPtr = ArrayCPB(dst, 0, y);
    for (int x=0 ; x<width ; x++)
    {
        SrcStorT* sPtr = ArrayCPB(src, -kerBW + x, y);
        KerStorT* kPtr = ArrayCPB(ker, 0, 0);
        KerArithT result(neutralElement);
        for (int k=0; k<kerWidth; k++)
        {
            redOp.DoIt(result, pixOp.DoIt(PtrRead(sPtr, KerArithT()),
                                          PtrRead(kPtr, KerArithT())));
            sPtr += SrcArrayT::ElemSize();
            kPtr += KerArrayT::ElemSize();
        }
        PtrWrite(dPtr, result);
        dPtr += DstArrayT::ElemSize();
    }
}

template<class DstArrayT, class SrcArrayT, class KerArrayT,
         class PixOpT, class RedOpT>
static void
FuncGenConv2dSep_Line_YdirNaiInc(DstArrayT* dst, SrcArrayT* src, KerArrayT* ker,
                                 PixOpT& pixOp, RedOpT& redOp, int x,
                                 TagCallPointer dummy)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename KerArrayT::StorType KerStorT;

    int height = ArrayCH(dst);
    int kerWidth = ArrayCW(ker);
    int kerBW = ArrayCW(ker) / 2;
    int srcInc = ArrayInc(src, 0, 1);
    KerStorT buf[KerArrayT::ElemSize()];
    for (int y=0 ; y<height ; y++)
    {
        DstStorT* dPtr = ArrayCPB(dst, x, y);
        SrcStorT* sPtr = ArrayCPB(src, x, -kerBW + y);
        KerStorT* kPtr = ArrayCPB(ker, 0, 0);
        redOp.setNeutral(dPtr);
        for (int k=0; k<kerWidth; k++)
        {
            pixOp.DoIt(buf, sPtr, kPtr);
            sPtr += srcInc;
            kPtr += KerArrayT::ElemSize();
            redOp.DoIt(dPtr, buf);
        }
    }
}

template<class DstArrayT, class SrcArrayT, class KerArrayT,
         class PixOpT, class RedOpT>
static void
FuncGenConv2dSep_Line_YdirNaiInc(DstArrayT* dst, SrcArrayT* src, KerArrayT* ker,
                                 PixOpT& pixOp, RedOpT& redOp, int x,
                                 TagCallValue dummy)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;
    typedef typename KerArrayT::StorType KerStorT;
    typedef typename KerArrayT::ArithType KerArithT;

    int height = ArrayCH(dst);
    int kerWidth = ArrayCW(ker);
    int kerBW = ArrayCW(ker) / 2;
    int srcInc = ArrayInc(src, 0, 1);
    KerArithT neutralElement = RedOpT::NeutralElement();
    for (int y=0 ; y<height ; y++)
    {
        DstStorT* dPtr = ArrayCPB(dst, x, y);
        SrcStorT* sPtr = ArrayCPB(src, x, -kerBW + y);
        KerStorT* kPtr = ArrayCPB(ker, 0, 0);
        KerArithT result(neutralElement);
        for (int k=0; k<kerWidth; k++)
        {
            redOp.DoIt(result, pixOp.DoIt(PtrRead(sPtr, KerArithT()),
                                          PtrRead(kPtr, KerArithT())));
            sPtr += srcInc;
            kPtr += KerArrayT::ElemSize();
        }
        PtrWrite(dPtr, result);
    }
}

template<class DstArrayT, class SrcArrayT, class KerArrayT,
         class PixOpT, class RedOpT>
static void
FuncGenConv2dSep_Line_YdirSim(DstArrayT* dst, SrcArrayT* src, KerArrayT* ker,
                              PixOpT& pixOp, RedOpT& redOp, int y,
                              TagCallValue tag)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;
    typedef typename KerArrayT::StorType KerStorT;
    typedef typename KerArrayT::ArithType KerArithT;

    int width = ArrayCW(dst);
    int kerWidth = ArrayCW(ker);
    int kerBW = ArrayCW(ker) / 2;
    int srcInc = ArrayInc(src, 0, 1);
    KerArithT neutralElement = RedOpT::NeutralElement();
    DstStorT* dPtr = ArrayCPB(dst, 0, y);
    SrcStorT* sPtr = ArrayCPB(src, 0, -kerBW + y);
    KerStorT* kPtr = ArrayCPB(ker, 0, 0);
    for (int x=0 ; x<width ; x++)
    {
        FuncGenConv2dSep_Pix_Ydir(dPtr, sPtr, kPtr, kerWidth, srcInc,
                                  KerArrayT::ElemSize(), pixOp, redOp,
                                  neutralElement, tag);
        sPtr += SrcArrayT::ElemSize();
        dPtr += DstArrayT::ElemSize();
    }
}

template<class DstArrayT, class SrcArrayT, class KerArrayT,
         class PixOpT, class RedOpT>
static void
FuncGenConv2dSep_Line_YdirSimInc(DstArrayT* dst, SrcArrayT* src, KerArrayT* ker,
                                 PixOpT& pixOp, RedOpT& redOp, int y,
                                 TagCallValue dummy)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;
    typedef typename KerArrayT::StorType KerStorT;
    typedef typename KerArrayT::ArithType KerArithT;

    int width = ArrayCW(dst);
    int kerWidth = ArrayCW(ker);
    int kerBW = ArrayCW(ker) / 2;
    int srcInc = ArrayInc(src, 0, 1);
    KerArithT neutralElement = RedOpT::NeutralElement();
    DstStorT* dPtr = ArrayCPB(dst, 0, y);
    SrcStorT* srcPtr = ArrayCPB(src, 0, -kerBW + y);
    for (int x=0 ; x<width ; x++)
    {
        SrcStorT* sPtr = srcPtr;
        KerStorT* kPtr = ArrayCPB(ker, 0, 0);
        KerArithT result(neutralElement);
        for (int k=0; k<kerWidth; k++)
        {
            redOp.DoIt(result, pixOp.DoIt(PtrRead(sPtr, KerArithT()),
                                          PtrRead(kPtr, KerArithT())));
            sPtr += srcInc;
            kPtr += KerArrayT::ElemSize();
        }
        PtrWrite(dPtr, result);
        srcPtr += SrcArrayT::ElemSize();
        dPtr += DstArrayT::ElemSize();
    }
}

// version of FuncGenConv2dSep_Line_XYdirVerCycInc with split X and Y
// doesn't seem to be better, but maybe if split into two functions...
/*{
    ArithT  neutralElement = RedOpT::NeutralElement();
    int     lastKerElt = ker2Width-1;
    int     bufCycSize = dstWidth * ker2Width;
    ArithT* bufOverflow = buf + bufCycSize;

    // first do the X direction (from src to buf) for the last element
    // needed for the kernel in the Y direction (all other elements
    // needed for the Y direction are already computed and stored in buf)

    ArithT* bPtr = bufPtr;
    int width = dstWidth;
    while (--width >= 0) {
        SrcDataPtrT sPtr(srcPtr);
        ArithT result1(neutralElement);
        for (int k1=0 ; k1<ker1Width ; k1++)
            redOp.DoIt(result1, pixOp.DoIt(sPtr.readIncX(), kernel1[k1]));
        bPtr[lastKerElt] = result1;
        srcPtr.incX();
        bPtr += ker2Width;
        if (bPtr >= bufOverflow)
            bPtr -= bufCycSize;
    }

    // now the Y direction from buf to dst

    while (--dstWidth >= 0) {
        ArithT result2(neutralElement);
        for (int k2=0 ; k2<ker2Width ; k2++)
            redOp.DoIt(result2, pixOp.DoIt(bufPtr[k2], kernel2[k2]));
        dstPtr.writeIncX(result2);
        bufPtr += ker2Width;
        if (bufPtr >= bufOverflow)
            bufPtr -= bufCycSize;
    }
}*/

//End of Line_variations.



//End of GenConv2dSep_variations.


template<class DstArrayT, class SrcArrayT, class KerArrayT,
         class PixOpT, class RedOpT>
void
FuncGenConv2dSepDispatch_H(DstArrayT* dst, SrcArrayT* src, KerArrayT* ker,
                           PixOpT& pixOp, RedOpT& redOp, int vType)
{
    int height = ArrayCH(dst);
    for (int y=0 ; y<height ; y++)
    {
        if (vType == 1)
            FuncGenConv2dSep_Line_Xdir(dst, src, ker, pixOp, redOp, y,
                                       typename PixOpT::CallCategory());
        if ((vType == 0) || (vType == 2))
            FuncGenConv2dSep_Line_XdirInc(dst, src, ker, pixOp, redOp, y,
                                          typename PixOpT::CallCategory());
    }
}

template<class DstArrayT, class SrcArrayT, class KerArrayT,
         class PixOpT, class RedOpT>
void
FuncGenConv2dSepDispatch_V(DstArrayT* dst, SrcArrayT* src, KerArrayT* ker,
                           PixOpT& pixOp, RedOpT& redOp, int vType)
{
    int width = ArrayCW(dst);
    if (vType == 0)
    {
        for (int x=0 ; x<width ; x++)
        {
            FuncGenConv2dSep_Line_YdirNaiInc(dst, src, ker, pixOp, redOp, x,
                                             typename PixOpT::CallCategory());
        }
    }
    else
    { // vType == 1 or 2
        int height = ArrayCH(dst);
        for (int y=0 ; y<height ; y++)
        {
            if (vType == 1)
                FuncGenConv2dSep_Line_YdirSim(dst, src, ker, pixOp, redOp, y,
                                              typename PixOpT::CallCategory());
            if (vType == 2)
                FuncGenConv2dSep_Line_YdirSimInc(dst, src, ker, pixOp, redOp, y,
                                                 typename PixOpT::CallCategory());
        }
    }
}

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

#endif

---