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

---

QbWatershedMarkers.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Trait_QbWatershedMarkers_h
#define Impala_Core_Array_Trait_QbWatershedMarkers_h

#include "Core/Geometry/PointZ.h"
#include "Core/Array/Pattern/FcvArray.h"
#include "Core/Array/Pattern/QCollection.h"
#include "Core/Array/Arrays.h"

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Trait
{


template<class DstArrayT, class Src1ArrayT, class Src2ArrayT>
class QbWatershedMarkers {

    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename Src1ArrayT::ArithType Src1ArithT;
    typedef typename Src2ArrayT::ArithType Src2ArithT;

public:

    typedef struct structPointValue {
        DstArithT arith; 
        Src1ArithT img; 
        Src2ArithT mask; 
        Geometry::PointZ point;
        int cost;

        bool
        less(const struct structPointValue& rhs) const
        { 
            if (img<rhs.img)
                return true;
            if (img>rhs.img)
                return false;
            // for equal values be a FIFO=QUEUE
            return localOrderCounter<rhs.localOrderCounter; 
        }

        bool
        operator < (const struct structPointValue& rhs) const
        { 
            //return !less(rhs); // for priority_queue returning highest value
            return less(rhs); // for set/multiset returning lowest value
        } 

        unsigned localOrderCounter;
    } PointValueT;

    //typedef std::set<PointValueT> QT; 
    typedef Pattern::Qset<PointValueT> QT; 

    typedef struct { 
        Geometry::PointZ point;
        DstArithT arith;
        Src1ArithT img;
        Src2ArithT mask;
    } NeighborsT;
 
    typedef Pattern::FcvArray<NeighborsT> VecNeighborsT;

    QbWatershedMarkers(bool doLabelMask)
    {
        labelcode=0;
        doLabel = doLabelMask;
        globalOrderCounter=0;
    }

    ~QbWatershedMarkers()
    {
    }

    bool
    WantAnotherLoop()
    {
        return false;
    }

    bool
    WantFreshStartLocalPixelInit()
    {
        return true;
    }

    bool
    LocalPixelInit(PointValueT& vp, DstArithT&, Src1ArithT, Src2ArithT, bool& continueloop)
    { 
        continueloop=false;
        return false;
    }

    bool
    GlobalPixelInit(PointValueT& vp, DstArithT& arith, Src1ArithT img, Src2ArithT mask)
    { 
        vp.arith=arith;
        vp.img=img;
        vp.mask=mask;
        bool q;
        if (vp.mask!=0) { // = marker node
            q=true; // do queue
            if (doLabel) {
                labelcode++; // new labelcode
                vp.arith=labelcode; // output = labelcode
            } else {
                vp.arith=vp.mask; 
            }
        } else { // line 2
            vp.arith=0;
            q=false;
        }
        if (q) { 
            vp.localOrderCounter=globalOrderCounter++; // for equal values be
                                                       // a FIFO=QUEUE
        }
        arith=vp.arith;
        return q;
    }

    void
    First(const PointValueT& val, DstArithT, Src1ArithT, Src2ArithT)
    { 
        center=val; 
    }

    void
    Calculate(VecNeighborsT& vecneighbors)
    {
        index=0; // for result()
        neighboursout.clear();
        actionsout.clear();
        for (int i=0; i<vecneighbors.size(); i++) {
            NeighborsT neighbor=vecneighbors[i];
            PointValueT val;
            val.point=neighbor.point;
            val.arith=neighbor.arith;
            val.img=neighbor.img;
            val.mask=neighbor.mask;
            if (val.arith==0) { // non-labeled neighbor
                // new one, do remove and write in 'arith' and queue line 10 line 11
                val.arith=center.arith; // line 9
                val.localOrderCounter=globalOrderCounter++; // for equal values
                                                            // be a FIFO=QUEUE
                neighboursout.push_back(val);
                actionsout.push_back(Pattern::WRITE);
                neighboursout.push_back(val);
                actionsout.push_back(Pattern::QUEUE);
            }
        }
    }

    Pattern::QAction
    Result()
    {
        if (index>=neighboursout.size())
            return Pattern::STOP; // quit asking 
        resultVP=neighboursout[index];
        Pattern::QAction action=actionsout[index];
        index++;
        return action;
    }

    void
    GetItemToQueue(PointValueT &vp)
    {
        vp=resultVP;
    }

    // speed up searching in set<less..>, provide low/up bound where resultVP
    // is never out
    void
    GetItemToRemove(PointValueT& lower, PointValueT& upper)
    {
        lower.cost=upper.cost=resultVP.cost;
        lower.localOrderCounter=0; // unsigned int
        upper.localOrderCounter=4000000000;
    }

    bool
    KillThisOne(const PointValueT& vp)
    {
        if (resultVP.cost==vp.cost && resultVP.point==vp.point) 
            return true;
        return false; 
    }

    void
    GetItemToWrite(Geometry::PointZ& point, DstArithT& arith)
    {
        point=resultVP.point;
        arith=resultVP.arith;
    }

private:

    PointValueT center;
    Pattern::FcvArray<PointValueT> neighboursout;
    Pattern::FcvArray<Pattern::QAction> actionsout;
    int index;
    int labelcode;
    bool doLabel;
    PointValueT resultVP;
    unsigned globalOrderCounter;
};

} // namespace Trait
} // namespace Array
} // namespace Core
} // namespace Impala

#endif

---