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

---

FuncQueueBased.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Pattern_FuncQueueBased_h
#define Impala_Core_Array_Pattern_FuncQueueBased_h

#include <iostream>
#include "Core/Array/Pattern/Categories.h"
#include "Core/Array/Pattern/ArrayFunc.h"
#include "Core/Array/Pattern/PtrFunc.h"
#include "Core/Geometry/PointZ.h"
#include "Core/Array/Pattern/FcvArray.h"
#include "Core/Array/Pattern/QAction.h"

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


// version with mask
template <class DstArrayT, class SrcArrayT, class MaskArrayT, class VecPointT,
          class VecNeighborT, class NeighborsT>
inline void
FuncQueueBased_FillNeighborValues(DstArrayT* dst, SrcArrayT* src,
                                  MaskArrayT* mask, Geometry::PointZ centralPoint,
                                  const VecPointT& neighborCoordinates, 
                                  VecNeighborT& vecneighbors, NeighborsT)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;
    typedef typename MaskArrayT::StorType MaskStorT;
    typedef typename MaskArrayT::ArithType MaskArithT;

    vecneighbors.clear();
    int imgsizex = ArrayCW(dst);
    int imgsizey = ArrayCW(dst);
    for (int i=0; i<neighborCoordinates.size(); i++)
    {
        Geometry::PointZ p = neighborCoordinates[i]+centralPoint;
        int tempx=p.mX, tempy=p.mY;
        if (tempx>=0 && tempy>=0 && tempx<imgsizex && tempy<imgsizey)
        {
            DstStorT* dPtr = ArrayCPB(dst, tempx, tempy);
            SrcStorT* sPtr = ArrayCPB(src, tempx, tempy);
            SrcStorT* mPtr = ArrayCPB(mask, tempx, tempy);
            NeighborsT neighbors;
            neighbors.point=p; 
            neighbors.arith=PtrRead(dPtr, DstArithT()); 
            neighbors.img=PtrRead(sPtr, SrcArithT()); 
            neighbors.mask=PtrRead(mPtr, MaskArithT());
            vecneighbors.push_back(neighbors);
        }
    }
}

// version without mask
template <class DstArrayT, class SrcArrayT, class VecPointT,
          class VecNeighborT, class NeighborsT>
inline void
FuncQueueBased_FillNeighborValues(DstArrayT* dst, SrcArrayT* src,
                                  Geometry::PointZ centralPoint,
                                  const VecPointT& neighborCoordinates, 
                                  VecNeighborT& vecneighbors, NeighborsT)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;

    vecneighbors.clear();
    int imgsizex = ArrayCW(dst);
    int imgsizey = ArrayCW(dst);
    for (int i=0; i<neighborCoordinates.size(); i++)
    {
        Geometry::PointZ p = neighborCoordinates[i]+centralPoint;
        int tempx=p.mX, tempy=p.mY;
        if (tempx>=0 && tempy>=0 && tempx<imgsizex && tempy<imgsizey)
        {
            DstStorT* dPtr = ArrayCPB(dst, tempx, tempy);
            SrcStorT* sPtr = ArrayCPB(src, tempx, tempy);
            NeighborsT neighbors;
            neighbors.point=p; 
            neighbors.arith=PtrRead(dPtr, DstArithT()); 
            neighbors.img=PtrRead(sPtr, SrcArithT()); 
            vecneighbors.push_back(neighbors);
        }
    }
}

template <class VecPointT>
void
FuncQueueBased_ComputeNeighbors(VecPointT& neighborCoordinates,
                                int connectivity, int radiusSqr)
{
    neighborCoordinates.clear();
    if (radiusSqr<0 && connectivity==4)
        radiusSqr = 1;
    if (radiusSqr<0 && connectivity==8)
        radiusSqr = 2;

    int radius;
    for (radius=0 ; radius*radius <= radiusSqr ; radius++)
        ;
    for (int y=-radius ; y<=radius ; y++)
    {
        for (int x=-radius ; x<=radius ; x++)
        {
            if (x||y)
            { //skip (0,0,0)
                if (x*x+y*y <= radiusSqr)
                    neighborCoordinates.push_back(Geometry::PointZ(x,y));
            }
        }
    }
}

// version with mask
template <class DstArrayT, class SrcArrayT, class MaskArrayT, class FunctorT>
void
FuncQueueBasedDispatch(DstArrayT* dst, SrcArrayT* src, MaskArrayT* mask,
                       FunctorT& functor, int connectivity, int radiusSqr)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;
    typedef typename MaskArrayT::StorType MaskStorT;
    typedef typename MaskArrayT::ArithType MaskArithT;

    typedef typename FunctorT::PointValueT PointValueT;
    typedef typename FunctorT::QT QT; 
    typedef typename FunctorT::NeighborsT NeighborsT;
    typedef typename FunctorT::VecNeighborsT VecNeighborsT;

    typedef Pattern::FcvArray<Geometry::PointZ> VecPointT;

    QT theQueue;
    int imgsizex = ArrayCW(dst);
    int imgsizey = ArrayCH(dst);

    // GLOBAL INIT
    { // local scope
        for (int y=0 ; y<imgsizey ; y++)
        {
            DstStorT* dPtr = ArrayCPB(dst, 0, y);
            SrcStorT* sPtr = ArrayCPB(src, 0, y);
            SrcStorT* mPtr = ArrayCPB(mask, 0, y);
            for (int x=0 ; x<imgsizex ; x++)
            {
                PointValueT vp;
                Geometry::PointZ p(x, y);
                vp.point=p;
                DstArithT d = PtrRead(dPtr, DstArithT());
                SrcArithT s = PtrRead(sPtr, SrcArithT());
                MaskArithT m = PtrRead(mPtr, MaskArithT());
                bool q = functor.GlobalPixelInit(vp, d, s, m);
                if (q)
                    theQueue.push(vp); // NOTE: bool ok=queue.insert(vp).second is NEVER false
                PtrWrite(dPtr, d);
                dPtr += DstArrayT::ElemSize();
                sPtr += SrcArrayT::ElemSize();
                mPtr += MaskArrayT::ElemSize();
            }
        }
    } // end local scope

    // NEW: array of points to simplify loop 4/8/... connectivity, now skip (0,0,0)
    VecPointT neighborCoordinates;
    FuncQueueBased_ComputeNeighbors(neighborCoordinates, connectivity, radiusSqr);

    // clear speedup startpoint for localPixelInit() in large do while loop
    //__asm int 3
    Geometry::PointZ startpoint(0,0);
    VecNeighborsT vecneighbors;

    // LOOP until done with INIT local + PROPAGATE
    do
    {

        // INIT: FILL QUEUE
        { // local scope
            bool freshstart = functor.WantFreshStartLocalPixelInit();
            if (freshstart)
            {
                startpoint.mX=0;
                startpoint.mY=0;
            }
            bool continueloop=true;
            int x=startpoint.mX;
            int y=startpoint.mY;
            bool wenttonewpoint=false;
            if (wenttonewpoint)
                y=0;
            for (; y<imgsizey; y++)
            {
                if (wenttonewpoint)
                    x=0;
                DstStorT* dPtr = ArrayCPB(dst, x, y);
                SrcStorT* sPtr = ArrayCPB(src, x, y);
                SrcStorT* mPtr = ArrayCPB(mask, x, y);
                for (; x<imgsizex; x++)
                {
                    if (!wenttonewpoint)
                    {
                        wenttonewpoint=true;
                    }
                    PointValueT vp;
                    vp.point.mX = x;
                    vp.point.mY = y;
                    DstArithT d = PtrRead(dPtr, DstArithT());
                    SrcArithT s = PtrRead(sPtr, SrcArithT());
                    MaskArithT m = PtrRead(mPtr, MaskArithT());
                    bool q = functor.LocalPixelInit(vp, d, s, m, continueloop);
                    if (q)
                        theQueue.push(vp); // NOTE: bool ok=queue.insert(vp).second is NEVER false
                    PtrWrite(dPtr, d);
                    if (!continueloop)
                        break;
                    dPtr += DstArrayT::ElemSize();
                    sPtr += SrcArrayT::ElemSize();
                    mPtr += MaskArrayT::ElemSize();
                }
                if (!continueloop)
                    break;
            }
            // remember startpoint for next time
            startpoint.mX = x;
            startpoint.mY = y;

        } // end local scope

        // PROPAGATION
        { // local scope
            while (!theQueue.empty())
            { // line 4
                PointValueT vp(theQueue.top());
                theQueue.pop(); // line 5

                // give functor first=this=center data
                { // local scope
                    int tempx=vp.point.mX, tempy=vp.point.mY;
                    DstStorT* dPtr = ArrayCPB(dst, tempx, tempy);
                    SrcStorT* sPtr = ArrayCPB(src, tempx, tempy);
                    SrcStorT* mPtr = ArrayCPB(mask, tempx, tempy);
                    functor.First(vp, PtrRead(dPtr, DstArithT()),
                                  PtrRead(sPtr, SrcArithT()),
                                  PtrRead(mPtr, MaskArithT()));
                } // local scope

                // give functor the neighbour pixels
                // NOT yet optimized for iterator++ or LUT for coords
                // NEW: use vector to pass neighbors, here be compatible with sequential code
                { //local scope
                    FuncQueueBased_FillNeighborValues(dst, src, mask, vp.point,
                                                      neighborCoordinates,
                                                      vecneighbors,
                                                      NeighborsT());
                    // CALCULATE put functor to work, might be removed by first call to getdata()
                    functor.Calculate(vecneighbors);
                } //local scope



                // read out phase, might have many values of different types
                { // local scope
                    QAction action;
                    while ((action=functor.Result())!=STOP)
                    { 
                        switch (action)
                        {
                        case QUEUE:
                            { // local scope
                                PointValueT vp;
                                functor.GetItemToQueue(vp);
                                theQueue.push(vp); 
                            } // local scope
                            break;
                        case REMOVE:
                            { // local scope
                                PointValueT low, high;
                                functor.GetItemToRemove(low, high);
                                typename QT::iterator lowiter=theQueue.lower_bound(low);
                                typename QT::iterator highiter=theQueue.after_upper_bound(high);
                                for (typename QT::iterator iter=lowiter; iter!=highiter; iter++)
                                {
                                    bool k=functor.KillThisOne(*iter);
                                    if (k)
                                    {
                                        theQueue.erase(iter);
                                        break;
                                    } 
                                }
                            } // local scope
                            break;
                        case WRITE:
                            { // local scope
                                Geometry::PointZ point; 
                                DstArithT arith;
                                functor.GetItemToWrite(point, arith);
                                DstStorT* dPtr = ArrayCPB(dst, point.mX, point.mY);
                                PtrWrite(dPtr, arith);
                            } // local scope
                            break;
                        default:
                            std::cerr << "ERROR switch (action) default:" << std::endl;
                        }; // switch (action)
                    } // while ((action=functor.Result())!=STOP) 
                } // local scope
            } // while (!theQueue.empty()) 
        } // end local scope PROPAGATION
    }
    while (functor.WantAnotherLoop());
}

// version without mask
template <class DstArrayT, class SrcArrayT, class FunctorT>
void
FuncQueueBasedDispatch(DstArrayT* dst, SrcArrayT* src,
                       FunctorT& functor, int connectivity, int radiusSqr)
{
    typedef typename DstArrayT::StorType DstStorT;
    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::StorType SrcStorT;
    typedef typename SrcArrayT::ArithType SrcArithT;

    typedef typename FunctorT::PointValueT PointValueT;
    typedef typename FunctorT::QT QT; 
    typedef typename FunctorT::NeighborsT NeighborsT;
    typedef typename FunctorT::VecNeighborsT VecNeighborsT;

    typedef Pattern::FcvArray<Geometry::PointZ> VecPointT;

    QT theQueue;
    int imgsizex = ArrayCW(dst);
    int imgsizey = ArrayCH(dst);

    // GLOBAL INIT
    { // local scope
        for (int y=0 ; y<imgsizey ; y++)
        {
            DstStorT* dPtr = ArrayCPB(dst, 0, y);
            SrcStorT* sPtr = ArrayCPB(src, 0, y);
            for (int x=0 ; x<imgsizex ; x++)
            {
                PointValueT vp;
                Geometry::PointZ p(x, y);
                vp.point=p;
                DstArithT d = PtrRead(dPtr, DstArithT());
                SrcArithT s = PtrRead(sPtr, SrcArithT());
                bool q = functor.GlobalPixelInit(vp, d, s);
                if (q)
                    theQueue.push(vp); // NOTE: bool ok=queue.insert(vp).second is NEVER false
                PtrWrite(dPtr, d);
                dPtr += DstArrayT::ElemSize();
                sPtr += SrcArrayT::ElemSize();
            }
        }
    } // end local scope

    // NEW: array of points to simplify loop 4/8/... connectivity, now skip (0,0,0)
    VecPointT neighborCoordinates;
    FuncQueueBased_ComputeNeighbors(neighborCoordinates, connectivity, radiusSqr);

    // clear speedup startpoint for localPixelInit() in large do while loop
    //__asm int 3
    Geometry::PointZ startpoint(0,0);
    VecNeighborsT vecneighbors;

    // LOOP until done with INIT local + PROPAGATE
    do
    {
        // INIT: FILL QUEUE
        { // local scope
            bool freshstart = functor.WantFreshStartLocalPixelInit();
            if (freshstart)
            {
                startpoint.mX=0;
                startpoint.mY=0;
            }
            bool continueloop=true;
            int x=startpoint.mX;
            int y=startpoint.mY;
            bool wenttonewpoint=false;
            if (wenttonewpoint)
                y=0;
            for (; y<imgsizey; y++)
            {
                if (wenttonewpoint)
                    x=0;
                DstStorT* dPtr = ArrayCPB(dst, x, y);
                SrcStorT* sPtr = ArrayCPB(src, x, y);
                for (; x<imgsizex; x++)
                {
                    if (!wenttonewpoint)
                    {
                        wenttonewpoint=true;
                    }
                    PointValueT vp;
                    vp.point.mX=x;
                    vp.point.mY=y;
                    DstArithT d = PtrRead(dPtr, DstArithT());
                    SrcArithT s = PtrRead(sPtr, SrcArithT());
                    bool q = functor.LocalPixelInit(vp, d, s, continueloop);
                    if (q)
                        theQueue.push(vp); // NOTE: bool ok=queue.insert(vp).second is NEVER false
                    PtrWrite(dPtr, d);
                    if (!continueloop)
                        break;
                    dPtr += DstArrayT::ElemSize();
                    sPtr += SrcArrayT::ElemSize();
                }
                if (!continueloop)
                    break;
            }
            // remember startpoint for next time
            startpoint.mX=x;
            startpoint.mY=y;

        } // end local scope

        // PROPAGATION
        { // local scope
            while (!theQueue.empty())
            { // line 4
                PointValueT vp(theQueue.top());
                theQueue.pop(); // line 5

                // give functor first=this=center data
                { // local scope
                    int tempx=vp.point.mX, tempy=vp.point.mY;
                    DstStorT* dPtr = ArrayCPB(dst, tempx, tempy);
                    SrcStorT* sPtr = ArrayCPB(src, tempx, tempy);
                    functor.First(vp, PtrRead(dPtr, DstArithT()),
                                  PtrRead(sPtr, SrcArithT()));
                } // local scope

                // give functor the neighbour pixels
                // NOT yet optimized for iterator++ or LUT for coords
                // NEW: use vector to pass neighbors, here be compatible with sequential code
                { //local scope
                    FuncQueueBased_FillNeighborValues(dst, src, vp.point,
                                                      neighborCoordinates,
                                                      vecneighbors,
                                                      NeighborsT());
                    // CALCULATE put functor to work, might be removed by first call to getdata()
                    functor.Calculate(vecneighbors);
                } //local scope



                // read out phase, might have many values of different types
                { // local scope
                    QAction action;
                    while ((action=functor.Result())!=STOP)
                    { 
                        switch (action)
                        {
                        case QUEUE:
                            { // local scope
                                PointValueT vp;
                                functor.GetItemToQueue(vp);
                                theQueue.push(vp); 
                            } // local scope
                            break;
                        case REMOVE:
                            { // local scope
                                PointValueT low, high;
                                functor.GetItemToRemove(low, high);
                                typename QT::iterator lowiter=theQueue.lower_bound(low);
                                typename QT::iterator highiter=theQueue.after_upper_bound(high);
                                for (typename QT::iterator iter=lowiter; iter!=highiter; iter++)
                                {
                                    bool k=functor.KillThisOne(*iter);
                                    if (k)
                                    {
                                        theQueue.erase(iter);
                                        break;
                                    } 
                                }
                            } // local scope
                            break;
                        case WRITE:
                            { // local scope
                                Geometry::PointZ point; 
                                DstArithT arith;
                                functor.GetItemToWrite(point, arith);
                                DstStorT* dPtr = ArrayCPB(dst, point.mX, point.mY);
                                PtrWrite(dPtr, arith);
                            } // local scope
                            break;
                        default:
                            std::cerr << "ERROR switch (action) default:" << std::endl;
                        }; // switch (action)
                    } // while ((action=functor.Result())!=STOP) 
                } // local scope
            } // while (!theQueue.empty()) 
        } // end local scope PROPAGATION
    }
    while (functor.WantAnotherLoop());
}

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

#endif

---