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

---

QbLabel.h

Go to the documentation of this file.

#ifndef Impala_Core_Array_Trait_QbLabel_h
#define Impala_Core_Array_Trait_QbLabel_h

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

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


template<class DstArrayT, class SrcArrayT>
class QbLabel {

    typedef typename DstArrayT::ArithType DstArithT;
    typedef typename SrcArrayT::ArithType SrcArithT;

private:

    typedef struct {
        Geometry::PointZ point; 
        DstArithT arith; 
        SrcArithT img;
    } Temp;

public:

    // just put everything in it, sorting might be functor dependent
    typedef struct structPointValue {
        Geometry::PointZ point; // mandatory !!!!!!!!!
    } PointValueT;

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

    // combine parameters of next() :
    typedef struct { 
        Geometry::PointZ point;
        DstArithT arith;
        SrcArithT img;
    } NeighborsT; 

    // combine sequence of calls to next() :
    typedef FcvArray<NeighborsT> VecNeighborsT;

    QbLabel()
    {
        labelcode=0;
    }

    ~QbLabel()
    {
    }

    // pattern writes ALWAYS vp.arith but queues ONLY if pixelinit() returns true
    bool
    GlobalPixelInit(PointValueT&, DstArithT& arith, SrcArithT)
    { 
        arith = Element::E0LargeVal<DstArithT>(DstArithT()); // = unlabeled
        return false; // dont Q
    }

    // algo can continue from last point
    bool
    WantFreshStartLocalPixelInit()
    {
        return false; // default true
    }

    // need only 1 unlabeled pixel as seed, take first and quit in init()
    bool
    LocalPixelInit(PointValueT &vp, DstArithT &arith, SrcArithT img,
                   bool &continueloop)
    { 
        if (arith==Element::E0LargeVal<DstArithT>(DstArithT())) { 
            labelcode=labelcode+1;
            arith=labelcode;
            continueloop=false; // this is last
            OhYesIReallyWouldLikeToHaveAnotherLoop=true;
            return true; // do Q
        } else {
            continueloop=true; // try next
            OhYesIReallyWouldLikeToHaveAnotherLoop=false;
            return false; // dont Q
        }
    }

    // first from queue, NOTE: arith at (val.point) may have been altered
    void
    First(const PointValueT& val, DstArithT arith, SrcArithT img)
    { 
        // clear 
        index=0; // for result()
        neighborsout.clear();
        actionsout.clear();
        // store center pixel top() pop() from queue
        centrum.point=val.point; 
        centrum.img=img;
        centrum.arith=arith; // pattern doesnt put it in VP anymore
    }

    void
    Calculate(VecNeighborsT& vecneighbors)
    {
        for (int i=0; i<vecneighbors.size(); i++) {
            NeighborsT n=vecneighbors[i];
            if (n.arith==Element::E0LargeVal<DstArithT>(DstArithT()) &&
                n.img == centrum.img) {
                //roughlyEqual(n.img, centrum.img, tolerance)) {
                Temp val;
                val.arith=centrum.arith;
                val.point=n.point;
                val.img=n.img;
                neighborsout.push_back(val);
                actionsout.push_back(Pattern::WRITE);
                neighborsout.push_back(val);
                actionsout.push_back(Pattern::QUEUE);
            }
        }
    }

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

    void
    GetItemToQueue(PointValueT& vp)
    {
        vp.point=output.point;
    }

    // this algo doesnt remove anything from the queue
    void
    GetItemToRemove(PointValueT&, PointValueT&)
    {
    }

    // this algo doesnt remove anything from the queue
    bool
    KillThisOne(PointValueT&)
    {
        return false; 
    }

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

    bool
    WantAnotherLoop()
    {
        return OhYesIReallyWouldLikeToHaveAnotherLoop;
    }

private:

    FcvArray<Temp> neighborsout; 
    Temp centrum, output;
    FcvArray<Pattern::QAction> actionsout;
    int index;
    DstArithT labelcode;
    bool OhYesIReallyWouldLikeToHaveAnotherLoop;
};

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

#endif

---