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

---

PxFuncBorderOp.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2003-2004, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *  Author(s):
 *  Frank Seinstra <fjseins@wins.uva.nl>
 */

#ifndef __PxFuncBorderOp_h_
#define __PxFuncBorderOp_h_

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


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

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

    if (numX > 0) {

        PxBorderExchange(a, YZ_PLANE, numX);

        // mirror left part NOT including upper and lower "corners"

        if (PxIsLeftCPU(PxMyCPU())) {
            for (y=0; y<ch; y++) {
                StorT* srcPtr = ArrayCPB(a,  0, y);
                StorT* dstPtr = ArrayCPB(a, -1, y);
                for (x=0; x<numX; x++) {
                    for (int e=0; e<ArrayT::ElemSize(); e++) {
                        dstPtr[e] = srcPtr[e];
                    }
                    dstPtr -= ArrayT::ElemSize();
                    srcPtr += ArrayT::ElemSize();
                }
            }
        }

        // mirror right part NOT including upper and lower "corners"

        if (PxIsRightCPU(PxMyCPU())) {
            for (y=0; y<ch; y++) {
                StorT* srcPtr = ArrayCPB(a, cw - 1, y);
                StorT* dstPtr = ArrayCPB(a, cw, y);
                for (x=0 ; x<numX ; x++) {
                    for (int e=0; e<ArrayT::ElemSize(); e++) {
                        dstPtr[e] = srcPtr[e];
                    }
                    dstPtr += ArrayT::ElemSize();
                    srcPtr -= ArrayT::ElemSize();
                }
            }
        }
    }

    if (numY > 0) {

        PxBorderExchange(a, XZ_PLANE, numY);

        // mirror top part including left and right "corners"

        if (PxIsTopCPU(PxMyCPU())) {
            for (y=0; y<numY; y++) {
                StorT* srcPtr = ArrayCPB(a, -numX, y);
                StorT* dstPtr = ArrayCPB(a, -numX, -1 - y);
                int nElem = (cw + 2*numX) * ArrayT::ElemSize();
                for (x=0; x<nElem; x++) {
                    *dstPtr++ = *srcPtr++;
                }
            }
        }

        // mirror bottom part including left and right "corners"

        if (PxIsBottomCPU(PxMyCPU())) {
            for (y=0; y<numY; y++) {
                StorT* srcPtr = ArrayCPB(a, -numX, ch - 1 - y);
                StorT* dstPtr = ArrayCPB(a, -numX, ch + y);
                int nElem = (cw + 2 * numX) * ArrayT::ElemSize();
                for (x=0; x<nElem; x++) {
                    *dstPtr++ = *srcPtr++;
                }
            }
        }
    }
}


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

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

    if (numX > 0) {

        PxBorderExchange(a, YZ_PLANE, numX);

        // Set left part NOT including upper and lower "corners"

        if (PxIsLeftCPU(PxMyCPU())) {
            for (y=0 ; y<ch ; y++) {
                StorT* dstPtr = ArrayCPB(a, -numX, y);
                for (x=0 ; x<numX ; x++) {
                    PtrWrite(dstPtr, v);
                    dstPtr += ArrayT::ElemSize();
                }
            }
        }

        // Set right part NOT including upper and lower "corners"

        if (PxIsRightCPU(PxMyCPU())) {
            for (y=0 ; y<ch ; y++) {
                StorT* dstPtr = ArrayCPB(a, cw, y);
                for (x=0 ; x<numX ; x++) {
                    PtrWrite(dstPtr, v);
                    dstPtr += ArrayT::ElemSize();
                }
            }
        }
    }

    if (numY > 0) {

        PxBorderExchange(a, XZ_PLANE, numY);

        // Set top part including left and right "corners"

        int totalWidth = cw + 2*numX;

        if (PxIsTopCPU(PxMyCPU())) {
            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();
                }
            }
        }

        // Set bottom part including left and right "corners"

        if (PxIsBottomCPU(PxMyCPU())) {
            for (y=0 ; y<numY ; y++) {
                StorT* dstPtr = ArrayCPB(a, -numX, ch + y);
                for (x=0 ; x<totalWidth ; x++) {
                    PtrWrite(dstPtr, v);
                    dstPtr += ArrayT::ElemSize();
                }
            }
        }
    }
}


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

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

    if (numX > 0) {

        PxBorderExchange(a, YZ_PLANE, numX);

        // Propagate and normalize left part

        if (PxIsLeftCPU(PxMyCPU())) {
            for (y=0 ; y<ch ; y++) {
                StorT* srcPtr = ArrayCPB(a, 0, y);
                StorT* dstPtr = ArrayCPB(a, -numX, y);
                ArithT v = PtrRead(srcPtr, ArithT()) *
                           Element::E1Cast(normLeft, ArithT());
                for (x=0 ; x<numX ; x++) {
                    PtrWrite(dstPtr, v);
                    dstPtr += ArrayT::ElemSize();
                }
            }
        }

        // Propagate right part (normalization in recursive operation)

        if (PxIsRightCPU(PxMyCPU())) {
            for (y=0 ; y<ch ; y++) {
                StorT* srcPtr = ArrayCPB(a, cw - 1, y);
                StorT* dstPtr = ArrayCPB(a, cw, y);
                ArithT v = PtrRead(srcPtr, ArithT());
                for (x=0 ; x<numX ; x++) {
                    PtrWrite(dstPtr, v);
                    dstPtr += ArrayT::ElemSize();
                }
            }
        }
    }

    if (numY > 0) {

        PxBorderExchange(a, XZ_PLANE, numY);

        // Propagate & normalize top part incl. left and right "corners"

        int totalWidth = cw + 2*numX;

        if (PxIsTopCPU(PxMyCPU())) {
            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();
                }
            }
        }

        // Propagate bottom part incl. left and right "corners"

        if (PxIsBottomCPU(PxMyCPU())) {
            for (y=0 ; y<numY ; y++) {
                StorT* srcPtr = ArrayCPB(a, -numX, ch - 1);
                StorT* dstPtr = ArrayCPB(a, -numX, ch + y);
                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 /* __PxFuncBorderOp_h_ */

---