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

---

QbWatershedMarkers2.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Trait_QbWatershedMarkers2_h
#define Impala_Core_Array_Trait_QbWatershedMarkers2_h

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

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


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

    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;// 3D int
        int cost;

        bool
        less(const struct structPointValue& rhs) const
        { 
            if (cost<rhs.cost)
                return true;
            if (cost>rhs.cost)
                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;

    QbWatershedMarkers2(int width, int height, bool doLabelMask, int costMethod) 
        : flagImage(width, height, false), costImage(width, height, INT_MAX)
    {
        labelcode=0;
        doLabel = doLabelMask;
        costmethod=costMethod;
        globalOrderCounter=0;
    }

    ~QbWatershedMarkers2()
    {
    }

    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
            costImage(vp.point.mX, vp.point.mY)=0; // line 3
            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
            vp.cost=costImage(vp.point.mX, vp.point.mY);
        }
        arith=vp.arith;
        return q;
    }

    void
    First(const PointValueT& val, DstArithT, Src1ArithT, Src2ArithT)
    { 
        center=val; 
        flagImage(val.point.mX, val.point.mY)=true; // line 6
    }

    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;
    }

    void 
    Calculate(VecNeighborsT& vecneighbors)
    {
        index=0; // for result()
        neighboursout.clear();
        actionsout.clear();
        for (int i=0; i<vecneighbors.size(); i++) {
            NeighborsT val=vecneighbors[i];
            PointValueT neighbor;
            neighbor.point=val.point;
            neighbor.arith=val.arith;
            neighbor.img=val.img;
            neighbor.mask=val.mask;
            if (flagImage(neighbor.point.mX, neighbor.point.mY)==false) {
                int c=costImage(center.point.mX, center.point.mY);
                int f=costImage(neighbor.point.mX, neighbor.point.mY);
                int w;
                if (costmethod==0) {
                    w=neighbor.img;
                } else if (costmethod==1) {
                    w=Element::E1Norm1(center.img-neighbor.img); 
                } //else throw std::string ("Error! We only deal with cost method 0 and 1. You have to define others, if you want!");
                //if (w<0) // debug only
                //  throw std::string("error w<0");
                int maxval=(c>w?c:w);
                if (maxval<f) { // line 8
                    // YES: remove current one and then write+queue new one
                    // remove this neighbour with quick retrieve info
                    neighbor.cost=costImage(neighbor.point.mX, neighbor.point.mY);
                    neighbor.localOrderCounter=0;
                    neighboursout.push_back(neighbor);
                    actionsout.push_back(Pattern::REMOVE);

                    // new one, do remove and write in 'arith' and queue line 10
                    // line 11
                    neighbor.arith=center.arith; // line 9
                    costImage(neighbor.point.mX, neighbor.point.mY)=maxval; // line 9
                    neighbor.localOrderCounter=globalOrderCounter++; // for equal
                    // values be a FIFO=QUEUE
                    neighbor.cost=maxval;
                    neighboursout.push_back(neighbor);
                    actionsout.push_back(Pattern::WRITE);
                    neighboursout.push_back(neighbor);
                    actionsout.push_back(Pattern::QUEUE);
                }
            }
        }
    }

private:
    PointValueT center;
    Pattern::FcvArray<PointValueT> neighboursout;
    Pattern::FcvArray<Pattern::QAction> actionsout;
    int index;
    int labelcode;
    bool doLabel;
    int costmethod;
    PointValueT resultVP;
    unsigned globalOrderCounter;
    Pattern::Array2D<bool> flagImage;
    Pattern::Array2D<int> costImage;

};

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

#endif

---