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

---

FuncInOut.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_FuncInOut_h
#define Impala_Core_Array_Pattern_FuncInOut_h

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

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


/**********************************************************************/
template <class ArrayT, class PixOpT>
inline void
FuncInOut_Row_InTi(ArrayT* a, PixOpT& pixOp, int y)
{
    typedef typename ArrayT::StorType StorT;

    StorT* ptr = ArrayCPB(a, 0, y);
    int width = ArrayCW(a);
    while (--width >= 0)
    {
        PtrWrite(ptr, pixOp.DoIt());
        ptr += ArrayT::ElemSize();
    }
}

template <class ArrayT, class PixOpT>
inline void
FuncInOut_Row_OutTi(ArrayT* a, PixOpT& pixOp, int y)
{
    typedef typename ArrayT::StorType StorT;
    typedef typename ArrayT::ArithType ArithT;

    StorT* ptr = ArrayCPB(a, 0, y);
    int width = ArrayCW(a);
    while (--width >= 0)
    {
        pixOp.DoIt(PtrRead(ptr, ArithT()));
        ptr += ArrayT::ElemSize();
    }
}

template <class ArrayT, class PixOpT>
inline void
FuncInOut_Row_InTv(ArrayT* a, PixOpT& pixOp, int y)
{
    typedef typename ArrayT::StorType StorT;

    StorT* ptr = ArrayCPB(a, 0, y);
    int width = ArrayCW(a);
    for (int x=0 ; x<width ; x++)
    {
        PtrWrite(ptr, pixOp.DoIt(x, y));
        ptr += ArrayT::ElemSize();
    }
}

template <class ArrayT, class PixOpT>
inline void
FuncInOut_Row_OutTv(ArrayT* a, PixOpT& pixOp, int y)
{
    typedef typename ArrayT::StorType StorT;
    typedef typename ArrayT::ArithType ArithT;

    StorT* ptr = ArrayCPB(a, 0, y);
    int width = ArrayCW(a);
    for (int x=0 ; x<width ; x++)
    {
        pixOp.DoIt(PtrRead(ptr, ArithT()), x, y);
        ptr += ArrayT::ElemSize();
    }
}

//End of Row_variations.



template <class ArrayT, class PixOpT>
void
FuncInOut(ArrayT* a, PixOpT& pixOp,
          TagPixOpIn dummy1, TagTransInVar dummy2, Tag1Phase dummy3)
{
    int height = ArrayCH(a);
    for (int y=0 ; y<height ; y++)
        FuncInOut_Row_InTi(a, pixOp, y);
}

template <class ArrayT, class PixOpT>
void
FuncInOut(ArrayT* a, PixOpT& pixOp,
          TagPixOpOut dummy1, TagTransInVar dummy2, Tag1Phase dummy3)
{
    int height = ArrayCH(a);
    for (int y=0 ; y<height ; y++)
        FuncInOut_Row_OutTi(a, pixOp, y);
}

template <class ArrayT, class PixOpT>
void
FuncInOut(ArrayT* a, PixOpT& pixOp,
          TagPixOpIn dummy1, TagTransVar dummy2, Tag1Phase dummy3)
{
    int height = ArrayCH(a);
    for (int y=0 ; y<height ; y++)
        FuncInOut_Row_InTv(a, pixOp, y);
}

template <class ArrayT, class PixOpT>
void
FuncInOut(ArrayT* a, PixOpT& pixOp,
          TagPixOpOut dummy1, TagTransVar dummy2, Tag1Phase dummy3)
{
    int height = ArrayCH(a);
    for (int y=0 ; y<height ; y++)
        FuncInOut_Row_OutTv(a, pixOp, y);
}

template <class ArrayT, class PixOpT>
void
FuncInOut(ArrayT* a, PixOpT& pixOp,
          TagPixOpIn dummy1, TagTransInVar dummy2, TagNPhase dummy3)
{
    int height = ArrayCH(a);
    for (int phase=1 ; phase<=pixOp.NrPhases() ; phase++)
    {
        pixOp.Init(phase);
        for (int y=0 ; y<height ; y++)
            FuncInOut_Row_InTi(a, pixOp, y);
        pixOp.Done(phase);
    }
}

template <class ArrayT, class PixOpT>
void
FuncInOut(ArrayT* a, PixOpT& pixOp,
          TagPixOpOut dummy1, TagTransInVar dummy2, TagNPhase dummy3)
{
    int height = ArrayCH(a);
    for (int phase=1 ; phase<=pixOp.NrPhases() ; phase++)
    {
        pixOp.Init(phase);
        for (int y=0 ; y<height ; y++)
            FuncInOut_Row_OutTi(a, pixOp, y);
        pixOp.Done(phase);
    }
}

template <class ArrayT, class PixOpT>
void
FuncInOut(ArrayT* a, PixOpT& pixOp,
          TagPixOpIn dummy1, TagTransVar dummy2, TagNPhase dummy3)
{
    int height = ArrayCH(a);
    for (int phase=1 ; phase<=pixOp.NrPhases() ; phase++)
    {
        pixOp.Init(phase);
        for (int y=0 ; y<height ; y++)
            FuncInOut_Row_InTv(a, pixOp, y);
        pixOp.Done(phase);
    }
}

template <class ArrayT, class PixOpT>
void
FuncInOut(ArrayT* a, PixOpT& pixOp,
          TagPixOpOut dummy1, TagTransVar dummy2, TagNPhase dummy3)
{
    int height = ArrayCH(a);
    for (int phase=1 ; phase<=pixOp.NrPhases() ; phase++)
    {
        pixOp.Init(phase);
        for (int y=0 ; y<height ; y++)
            FuncInOut_Row_OutTv(a, pixOp, y);
        pixOp.Done(phase);
    }
}

//End of InOut_variations.


template <class ArrayT, class PixOpT>
void
FuncInOutDispatch(ArrayT* a, PixOpT& pixOp)
{
    FuncInOut(a, pixOp, typename PixOpT::DirectionCategory(),
              typename PixOpT::TransVarianceCategory(),
              typename PixOpT::PhaseCategory());
}

/***************************************************
 * functions for im/exporting from multiple images *
 * only implemented for translation invariant      *
 * and 1 phase                                     *
 ***************************************************/

template <class ArrayT, class PixOpT>
void
FuncM2InOutDispatch(ArrayT* a, ArrayT* b, PixOpT& pixOp)
{
    typedef typename ArrayT::StorType StorT;

    int width = ArrayCW(a);
    int height = ArrayCH(a);
    for (int y=0 ; y<height ; y++)
    {
        StorT* aPtr = ArrayCPB(a, 0, y);
        StorT* bPtr = ArrayCPB(b, 0, y);
        for (int x=0 ; x<width ; x++)
        {
            pixOp.DoIt(aPtr, bPtr);
            aPtr += ArrayT::ElemSize();
            bPtr += ArrayT::ElemSize();
        }
    }
}

template <class ArrayT, class PixOpT>
void
FuncM3InOutDispatch(ArrayT* a, ArrayT* b, ArrayT* c, PixOpT& pixOp)
{
    typedef typename ArrayT::StorType StorT;

    int width = ArrayCW(a);
    int height = ArrayCH(a);
    for (int y=0 ; y<height ; y++)
    {
        StorT* aPtr = ArrayCPB(a, 0, y);
        StorT* bPtr = ArrayCPB(b, 0, y);
        StorT* cPtr = ArrayCPB(c, 0, y);
        for (int x=0 ; x<width ; x++)
        {
            pixOp.DoIt(aPtr, bPtr, cPtr);
            aPtr += ArrayT::ElemSize();
            bPtr += ArrayT::ElemSize();
            cPtr += ArrayT::ElemSize();
        }
    }
}


// michiel: for 2d histogram only the variation we need


template <class ArrayT, class PixOpT>
inline void
FuncInOut_Row_OutTi(ArrayT* a, ArrayT* b, PixOpT& pixOp, int y)
{
    typedef typename ArrayT::StorType StorT;
    typedef typename ArrayT::ArithType ArithT;

    StorT* ptrA = ArrayCPB(a, 0, y);
    StorT* ptrB = ArrayCPB(b, 0, y);
    int width = ArrayCW(a);
    while (--width >= 0)
    {
        pixOp.DoIt(PtrRead(ptrA, ArithT()), PtrRead(ptrB, ArithT()));
        ptrA += ArrayT::ElemSize();
        ptrB += ArrayT::ElemSize();
    }
}

template <class ArrayT, class PixOpT>
void
FuncInOut(ArrayT* a, ArrayT* b, PixOpT& pixOp,
          TagPixOpOut dummy1, TagTransInVar dummy2, Tag1Phase dummy3)
{
    int height = ArrayCH(a);
    for (int y=0 ; y<height ; y++)
        FuncInOut_Row_OutTi(a, b, pixOp, y);
}

// note: actually doesn't dispatch since only export, translation invariant,
// 1 phase is implemented
template <class ArrayT, class PixOpT>
void
FuncInOutDispatch(ArrayT* a, ArrayT* b, PixOpT& pixOp)
{
    FuncInOut(a, b, pixOp,
              typename PixOpT::DirectionCategory(),
              typename PixOpT::TransVarianceCategory(),
              typename PixOpT::PhaseCategory());
}

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

#endif

---