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

---

FuncRecGenConv2dSep.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_FuncRecGenConv2dSep_h
#define Impala_Core_Array_Pattern_FuncRecGenConv2dSep_h

#include "Core/Array/Element/E1Cast.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 ValT, class PixOpT, class RedOpT>
static void
FuncRecGenConv2dSep_Line_XdirSim(ArrayT* a, KerArrayT* ker, PixOpT& pixOp,
                                 RedOpT& redOp, ValT rightNorm, int y)
{
    typedef typename ArrayT::StorType StorT;
    typedef typename ArrayT::ArithType ArithT;
    typedef typename KerArrayT::StorType KerStorT;
    typedef typename KerArrayT::ArithType KerArithT;

    int width = ArrayCW(a);
    int kerWidth = ArrayCW(ker);
    int kerBW = ArrayCW(ker) / 2;
    StorT* aPtr = ArrayCPB(a, -kerBW, y);
    KerArithT rNorm = Element::E1Cast(rightNorm, KerArithT());
    KerArithT result;
    int x;
    int scanSize = width + kerBW;
    //int scanSize = width;

    // scan order

    for (x=0 ; x<scanSize ; x++)
    {
        KerStorT* kPtr = ArrayCPB(ker, 0, 0);
        result = pixOp.DoIt(PtrRead(aPtr, KerArithT()),
                            PtrRead(kPtr, KerArithT()));
        aPtr += ArrayT::ElemSize();
        kPtr += KerArrayT::ElemSize();
        for (int n=1 ; n<=kerBW ; n++)
        {
            redOp.DoIt(result, pixOp.DoIt(PtrRead(aPtr, KerArithT()),
                                          PtrRead(kPtr, KerArithT())));
            aPtr += ArrayT::ElemSize();
            kPtr += KerArrayT::ElemSize();
        }
        aPtr -= ArrayT::ElemSize();
        PtrWrite(aPtr, result);
        aPtr -= (kerBW-1) * ArrayT::ElemSize();
    }

    // Propagate last pixel value into border

    aPtr += (kerBW-1) * ArrayT::ElemSize();  // now at last pixel on the line
    KerArithT borderVal = PtrRead(aPtr, KerArithT());
    aPtr += ArrayT::ElemSize();
    borderVal = borderVal * rNorm;
    for (x=0 ; x<kerBW ; x++)
    {
        PtrWrite(aPtr, borderVal);
        aPtr += ArrayT::ElemSize();
    }
    aPtr -= kerBW * ArrayT::ElemSize();

    // anti scan order

    aPtr -= ArrayT::ElemSize();

    for (x=0 ; x<scanSize ; x++)
    {
        KerStorT* kPtr = ArrayCPB(ker, kerBW, 0);
        result = pixOp.DoIt(PtrRead(aPtr, KerArithT()),
                            PtrRead(kPtr, KerArithT()));
        aPtr += ArrayT::ElemSize();
        kPtr += KerArrayT::ElemSize();
        for (int n=1 ; n<=kerBW ; n++)
        {
            redOp.DoIt(result, pixOp.DoIt(PtrRead(aPtr, KerArithT()),
                                          PtrRead(kPtr, KerArithT())));
            aPtr += ArrayT::ElemSize();
            kPtr += KerArrayT::ElemSize();
        }
        aPtr -= (kerBW+1) * ArrayT::ElemSize();
        PtrWrite(aPtr, result);
        aPtr -= ArrayT::ElemSize();
    }
}

template <class ArrayT, class KerArrayT, class ArithT,
          class PixOpT, class RedOpT>
static void
FuncRecGenConv2dSep_Line_YdirSim(ArrayT* a, KerArrayT* ker, ArithT* ngbBuf,
                                 PixOpT& pixOp, RedOpT& redOp,
                                 ArithT bottomNorm, int x)
{
    typedef typename ArrayT::StorType StorT;
    typedef typename KerArrayT::StorType KerStorT;

    int height = ArrayCH(a);
    int kerWidth = ArrayCW(ker);
    int kerBW = ArrayCW(ker) / 2;
    StorT* aPtr = ArrayCPB(a, x, -kerBW);
    int incY = ArrayInc(a, 0, 1);
    ArithT result;
    ArithT* ngbPtr = ngbBuf;
    int y, n;
    int scanSize = height+kerBW;
    //int scanSize = height;

    // scan order

    for (n=0 ; n<kerBW ; n++)
    {
        ngbBuf[n] =  PtrRead(aPtr, ArithT());
        aPtr += incY;
    }

    for (y=0 ; y<scanSize ; y++)
    {
        ngbPtr[kerBW] =  PtrRead(aPtr, ArithT());
        aPtr += incY;
        KerStorT* kPtr = ArrayCPB(ker, 0, 0);
        result = pixOp.DoIt(ngbPtr[0], PtrRead(kPtr, ArithT()));
        kPtr += KerArrayT::ElemSize();
        for (n=1 ; n<=kerBW ; n++)
        {
            redOp.DoIt(result, pixOp.DoIt(ngbPtr[n], PtrRead(kPtr, ArithT())));
            kPtr += KerArrayT::ElemSize();
        }
        ngbPtr[kerBW] = result;
        ngbPtr++;
    }

    // Propagate last pixel value into border

    ngbPtr += kerBW-1; // now at last pixel
    ArithT borderVal = ngbPtr[0];
    borderVal = borderVal * bottomNorm;
    ngbPtr++;
    for (y=0 ; y<kerBW ; y++)
        ngbPtr[y] = borderVal;
    aPtr += incY * kerBW;

    // anti scan order

    aPtr -= incY * (kerBW+1);
    ngbPtr -= 1;

    for (y=0 ; y<scanSize ; y++)
    {
        KerStorT* kPtr = ArrayCPB(ker, kerBW, 0);
        result = pixOp.DoIt(ngbPtr[0], PtrRead(kPtr, ArithT()));
        kPtr += KerArrayT::ElemSize();
        for (n=1 ; n<=kerBW ; n++)
        {
            redOp.DoIt(result, pixOp.DoIt(ngbPtr[n], PtrRead(kPtr, ArithT())));
            kPtr += KerArrayT::ElemSize();
        }
        *ngbPtr-- = result;
        PtrWrite(aPtr, result);
        aPtr -= incY;
    }
}

/*
template <class DataPtrT, class ArithT, class PixOpT, class RedOpT>
static void
FuncRecGenConv2dSep_Line_YdirBufAnti(
    DataPtrT imgPtr, int imgWidth, ArithT* kernel, int kerSize,
    PixOpT& pixOp, RedOpT& redOp)
{
    const int ngbSize = kerSize/2;
    int x, n;
    ArithT result;
    DataPtrT linePtr(imgPtr);

    // anti scan order
    kernel += ngbSize;

    for (x=0; x<imgWidth; x++)
        imgPtr.writeIncX(pixOp.DoIt(imgPtr.read(), kernel[0]));

    imgPtr.decX(imgWidth);

    // previous lines
    for (n=1; n<=ngbSize; n++)
    {
        linePtr.incY();
        for (x=0; x<imgWidth; x++) {
            result = imgPtr.read();
            redOp.DoIt(result, pixOp.DoIt(linePtr.readIncX(), kernel[n]));
            imgPtr.writeIncX(result);
        }
        imgPtr.decX(imgWidth);
        linePtr.decX(imgWidth);
    }
}
*/

//End of Line_variations.



template <class ArrayT, class KerArrayT, class ValT, class PixOpT, class RedOpT>
void
FuncRecGenConv2dSep_XirSim(ArrayT* a, KerArrayT* ker, PixOpT& pixOp,
                           RedOpT& redOp, ValT rightNorm)
{
    int height = ArrayCH(a);
    for (int y=0 ; y<height ; y++)
        FuncRecGenConv2dSep_Line_XdirSim(a, ker, pixOp, redOp, rightNorm, y);
}

template <class ArrayT, class KerArrayT, class ValT, class PixOpT, class RedOpT>
void
FuncRecGenConv2dSep_YdirSim(ArrayT* a, KerArrayT* ker, PixOpT& pixOp,
                            RedOpT& redOp, ValT bottomNorm)
{
    typedef typename KerArrayT::ArithType KerArithT;
    KerArithT* ngbBuf = new KerArithT[ArrayH(a)];
    KerArithT bN = Element::E1Cast(bottomNorm, KerArithT());

    int width = ArrayCW(a);
    for (int x=0 ; x<width ; x++)
        FuncRecGenConv2dSep_Line_YdirSim(a, ker, ngbBuf, pixOp, redOp, bN, x);

    delete ngbBuf;
}


//End of RecGenConv2dSep_variations.


template <class ArrayT, class KerArrayT, class ValT, class PixOpT, class RedOpT>
void
FuncRecGenConv2dSepDispatch_H(ArrayT* a, KerArrayT* ker, PixOpT& pixOp,
                              RedOpT& redOp, ValT rightNorm)
{
    FuncRecGenConv2dSep_XirSim(a, ker, pixOp, redOp, rightNorm);
}

template <class ArrayT, class KerArrayT, class ValT, class PixOpT, class RedOpT>
void
FuncRecGenConv2dSepDispatch_V(ArrayT* a, KerArrayT* ker,PixOpT& pixOp,
                              RedOpT& redOp, ValT bottomNorm, bool buffered)
{
    /*
    if (buffered)
        FuncRecGenConv2dSep_YdirBuf(imgPtr, kerPtr, dummy, imgSize, borderSize,
                                      kerSize, pixOp, redOp);
    else
    */
    FuncRecGenConv2dSep_YdirSim(a, ker, pixOp, redOp, bottomNorm);
}

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

#endif

---