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

---

FuncBorderOp.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_FuncBorderOp_h
#define Impala_Core_Array_Pattern_FuncBorderOp_h

#include "Core/Array/Pattern/ArrayFunc.h"
#include "Core/Array/Element/E1Cast.h"

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


template <class ArrayT>
void
FuncBorderMirror2d(ArrayT* a, Int64 numX, Int64 numY)
{
    typedef typename ArrayT::StorType StorT;

    Int64 cw = ArrayCW(a);
    Int64 ch = ArrayCH(a);
    Int64 x, y;

    if (numY > 0)
    {
        // mirror top part
        for (y=0 ; y<numY ; y++)
        {
            StorT* srcPtr = ArrayCPB(a, 0, y);
            StorT* dstPtr = ArrayCPB(a, 0, -1 - y);
            Int64 nElem = cw * ArrayT::ElemSize();
            for (x=0 ; x<nElem ; x++)
            {
                *dstPtr++ = *srcPtr++;
            }
        }

        // mirror bottom part
        for (y=0 ; y<numY ; y++)
        {
            StorT* srcPtr = ArrayCPB(a, 0, ch - 1 - y);
            StorT* dstPtr = ArrayCPB(a, 0, ch + y);
            Int64 nElem = cw * ArrayT::ElemSize();
            for (x=0 ; x<nElem ; x++)
            {
                *dstPtr++ = *srcPtr++;
            }
        }
    }

    if (numX > 0)
    {
        // mirror left part including upper and lower "corner"
        Int64 totalHeight = ch + 2*numY;
        for (y=0 ; y<totalHeight ; y++)
        {
            StorT* srcPtr = ArrayCPB(a, 0, -numY + y);
            StorT* dstPtr = ArrayCPB(a, -1, -numY + y);
            for (x=0 ; x<numX ; x++)
            {
                for (Int64 e=0 ; e<ArrayT::ElemSize() ; e++)
                    dstPtr[e] = srcPtr[e];
                dstPtr -= ArrayT::ElemSize();
                srcPtr += ArrayT::ElemSize();
            }
        }

        // mirror right part including upper and lower "corner"
        for (y=0 ; y<totalHeight ; y++)
        {
            StorT* srcPtr = ArrayCPB(a, cw - 1, -numY + y);
            StorT* dstPtr = ArrayCPB(a, cw, -numY + y);
            for (x=0 ; x<numX ; x++)
            {
                for (Int64 e=0 ; e<ArrayT::ElemSize() ; e++)
                    dstPtr[e] = srcPtr[e];
                dstPtr += ArrayT::ElemSize();
                srcPtr -= ArrayT::ElemSize();
            }
        }
    }
}

template <class ArrayT, class ValT>
void
FuncBorderConstant2d(ArrayT* a, Int64 numX, Int64 numY, ValT value)
{
    typedef typename ArrayT::StorType StorT;
    typedef typename ArrayT::ArithType ArithT;

    Int64 cw = ArrayCW(a);
    Int64 ch = ArrayCH(a);
    Int64 x, y;
    ArithT v = Element::E1Cast(value, ArithT());

    if (numX > 0)
    {
        // set left and right part
        for (y=0 ; y<ch ; y++)
        {
            StorT* dstPtr = ArrayCPB(a, -numX, y);
            for (x=0 ; x<numX ; x++)
            {
                PtrWrite(dstPtr, v);
                dstPtr += ArrayT::ElemSize();
            }
            dstPtr = ArrayCPB(a, cw, y);
            for (x=0 ; x<numX ; x++)
            {
                PtrWrite(dstPtr, v);
                dstPtr += ArrayT::ElemSize();
            }
        }
    }

    if (numY > 0)
    {
        // set top and bottom part including left and right "corners"
        Int64 totalWidth = cw + 2*numX;
        for (y=0 ; y<numY ; y++)
        {
            StorT* dstPtr = ArrayCPB(a, -numX, -numY + y);
            for (x=0 ; x<totalWidth ; x++)
            {
                PtrWrite(dstPtr, v);
                dstPtr += ArrayT::ElemSize();
            }
            dstPtr = ArrayCPB(a, -numX, ch + y);
            for (x=0 ; x<totalWidth ; x++)
            {
                PtrWrite(dstPtr, v);
                dstPtr += ArrayT::ElemSize();
            }
        }
    }
}

template <class ArrayT, class ValT>
void
FuncBorderPropagateNormalized2d(ArrayT* a, Int64 numX, Int64 numY, ValT normLeft,
                                ValT normRight, ValT normTop, ValT normBottom)
{
    typedef typename ArrayT::StorType StorT;
    typedef typename ArrayT::ArithType ArithT;

    Int64 cw = ArrayCW(a);
    Int64 ch = ArrayCH(a);
    Int64 x, y;

    if (numX > 0)
    {
        // propagate and normalize left and right part
        for (y=0 ; y<ch ; y++)
        {
            StorT* srcPtr = ArrayCPB(a, 0, y);
            ArithT v = PtrRead(srcPtr, ArithT()) * Element::E1Cast(normLeft, ArithT());
            StorT* dstPtr = ArrayCPB(a, -numX, y);
            for (x=0 ; x<numX ; x++)
            {
                PtrWrite(dstPtr, v);
                dstPtr += ArrayT::ElemSize();
            }

            srcPtr = ArrayCPB(a, cw - 1, y);
            //v = PtrRead(srcPtr, ArithT()) * E1Cast(normLeft, ArithT());
            // normalization right part is done by the recursive operation itself
            v = PtrRead(srcPtr, ArithT());
            dstPtr = ArrayCPB(a, cw, y);
            for (x=0 ; x<numX ; x++)
            {
                PtrWrite(dstPtr, v);
                dstPtr += ArrayT::ElemSize();
            }
        }
    }

    if (numY > 0)
    {
        // propagate and normalize top and bottom part including left and
        // right "corners"
        Int64 totalWidth = cw + 2*numX;
        for (y=0 ; y<numY ; y++)
        {
            StorT* srcPtr = ArrayCPB(a, -numX, 0);
            StorT* dstPtr = ArrayCPB(a, -numX, -numY + y);
            ArithT nT = Element::E1Cast(normTop, ArithT());
            for (x=0 ; x<totalWidth ; x++)
            {
                PtrWrite(dstPtr, PtrRead(srcPtr, ArithT()) * nT);
                srcPtr += ArrayT::ElemSize();
                dstPtr += ArrayT::ElemSize();
            }

            srcPtr = ArrayCPB(a, -numX, ch - 1);
            dstPtr = ArrayCPB(a, -numX, ch + y);
            //ArithT nB = E1Cast(normBottom, ArithT());
            // normalization bottom part is done by the recursive operation itself
            ArithT nB = Element::E1Cast(1, ArithT());
            for (x=0 ; x<totalWidth ; x++)
            {
                PtrWrite(dstPtr, PtrRead(srcPtr, ArithT()) * nB);
                srcPtr += ArrayT::ElemSize();
                dstPtr += ArrayT::ElemSize();
            }
        }
    }
}

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

#endif

---