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

---

FuncRecGenConv2d.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_FuncRecGenConv2d_h
#define Impala_Core_Array_Pattern_FuncRecGenConv2d_h

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

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


template <class ArrayT, class KerArrayT, class PixOpT, class RedOpT>
void
FuncRecGenConv2d_XYdirSim(ArrayT* array, KerArrayT* ker, PixOpT& pixOp,
                          RedOpT& redOp)
{
    typedef typename ArrayT::StorType StorT;
    typedef typename ArrayT::ArithType ArithT;
    typedef typename KerArrayT::StorType KerStorT;
    typedef typename KerArrayT::ArithType KerArithT;

    int aWidth = ArrayCW(array);
    int aHeight = ArrayCH(array);
    int kerWidth = ArrayCW(ker);
    int kerHeight = ArrayCH(ker);
    int kerBW = ArrayCW(ker) / 2;
    int kerBH = ArrayCH(ker) / 2;
    int decXincY = ArrayInc(array, -kerWidth, 1);
    KerArithT neutralElement(RedOpT::NeutralElement());
    int y;

    // scan order

    for (y=0 ; y<aHeight ; y++)
    {
        StorT* aPtr = ArrayCPB(array, -kerBW, -kerBH + y);
        for (int x=0 ; x<aWidth ; x++)
        {
            StorT* nPtr = aPtr;
            KerStorT* kPtr = ArrayCPB(ker, 0, 0);
            KerArithT result = neutralElement;
            for (int j=0 ; j<kerBH ; j++)
            {
                for (int i=0 ; i<kerWidth ; i++)
                {
                    redOp.DoIt(result, pixOp.DoIt(PtrRead(nPtr, KerArithT()),
                                                  PtrRead(kPtr, KerArithT())));
                    nPtr += ArrayT::ElemSize();
                    kPtr += KerArrayT::ElemSize();
                }
                nPtr += decXincY;
            }
            for (int i=0 ; i<=kerBW ; i++)
            {
                redOp.DoIt(result, pixOp.DoIt(PtrRead(nPtr, KerArithT()),
                                              PtrRead(kPtr, KerArithT())));
                nPtr += ArrayT::ElemSize();
                kPtr += KerArrayT::ElemSize();
            }
            nPtr -= ArrayT::ElemSize();
            PtrWrite(nPtr, result);
            aPtr += ArrayT::ElemSize();
        }
    }

    // anti scan order

    for (y=0 ; y<aHeight ; y++)
    {
        StorT* aPtr = ArrayCPE(array, kerBW, kerBH - y);
        for (int x=0 ; x<aWidth ; x++)
        {
            StorT* nPtr = aPtr;
            KerStorT* kPtr = ArrayCPE(ker, 0, 0);
            KerArithT result = neutralElement;
            for (int j=0 ; j<kerBH ; j++)
            {
                for (int i=0 ; i<kerWidth ; i++)
                {
                    redOp.DoIt(result, pixOp.DoIt(PtrRead(nPtr, KerArithT()),
                                                  PtrRead(kPtr, KerArithT())));
                    nPtr -= ArrayT::ElemSize();
                    kPtr -= KerArrayT::ElemSize();
                }
                nPtr -= decXincY;
            }
            for (int i=0 ; i<=kerBW ; i++)
            {
                redOp.DoIt(result, pixOp.DoIt(PtrRead(nPtr, KerArithT()),
                                              PtrRead(kPtr, KerArithT())));
                nPtr -= ArrayT::ElemSize();
                kPtr -= KerArrayT::ElemSize();
            }
            nPtr += ArrayT::ElemSize();
            PtrWrite(nPtr, result);
            aPtr -= ArrayT::ElemSize();
        }
    }
}


template <class ArrayT, class KerArrayT, class PixOpT, class RedOpT>
void
FuncRecGenConv2dDispatch(ArrayT* a, KerArrayT* ker, PixOpT& pixOp, RedOpT& redOp)
{
    FuncRecGenConv2d_XYdirSim(a, ker, pixOp, redOp);
}

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

#endif

---