|| ||           || Doxygen's  

---

HxImgFtorQueueBased.h

/*
 *  Copyright (c) 2000, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *  Author(s):
 *  Frans Verster (verster@science.uva.nl)
 */

#ifndef HxImgFtorQueueBased_h
#define HxImgFtorQueueBased_h

#include "HxImgFtorI3Cast.h"



/* 
resp. INOUT, IN, IN
for Q based watershed resp. 
*/

//typedef HxVec2Int PointT; // 2D
class PointT {
public:
    int x, y;
    PointT(int x_, int y_) : x(x_), y(y_) {}
    PointT() {}
    bool operator == (const PointT & rhs) { return x==rhs.x && y==rhs.y; }
    PointT operator + (const PointT & rhs) const { return PointT(x+rhs.x, y+rhs.y); }
};


template <class T> class FcvArray {
private:
    T *ptr;
    int nr;
    int index;
    FcvArray(const FcvArray &);
    FcvArray& operator = (const FcvArray &);
public:
    FcvArray(int n=1000) : index(0), nr(n) { ptr=new T[nr]; }
    ~FcvArray() { delete []ptr; }
    void clear() { index=0; }
    void push_back(const T &val) { ptr[index++]=val; }
    int size() const { return index; }
    T & operator [] (int i) { return ptr[i]; }
    const T & operator [] (int i) const { return ptr[i]; }
    bool empty() const { return index==0; }
    //leon added this
    bool isThere(const T &val)
    {for(int i=0;i<index;i++) if(ptr[i]==val) return true; return false;}
    void setSize(int s) { nr=s; ptr=new T[nr]; }
    
};


template <class ImgSigT, class ExtraSigT, class AnotherSigT, class FunctorT>
class HxImgFtorQueueBased : public HxImgFtorI3Cast<ImgSigT, ExtraSigT, AnotherSigT> {
public:
    //typedef std::set<FunctorT::PointValueT> QueueT; // because of localOrderCounter a normal set might work as well ???
    typedef typename FunctorT::QT QueueT; 
    typedef FcvArray<PointT> VecPointT;
    typedef typename FunctorT::VecNeighbors VecNeighborT;
    QueueT queuet;
    HxImgFtorQueueBased();
    ~HxImgFtorQueueBased();
    virtual void doIt(
        Img1DataPtrType imgPtr, 
        Img2DataPtrType extraPtr,
        Img3DataPtrType anotherPtr,
        HxSizes imgSize, 
        HxSizes extraSize, 
        HxSizes anotherSize, 
        HxTagList &tags, 
        HxImgFtorDescription * =0);
    static HxString className() { return "QueueBased"; }
    static inline void fillNeighborValues( // couldnt store imgPtr as members (no default ctor), so pass everything -> static
        PointT centralPoint, 
        const VecPointT &neighborCoordinates, 
        VecNeighborT &vecneighbors,
        HxSizes imgSize,
        Img1DataPtrType imgPtr,
        Img2DataPtrType extraPtr,
        Img3DataPtrType anotherPtr);
    void fillNeighborValues( // couldnt store imgPtr as members (no default ctor), so pass everything -> static
        const PointT &centralPoint, 
        int connectivity, 
        VecNeighborT &vecneighbors,
        const HxSizes &imgSize,
        const Img1DataPtrType &imgPtr,
        const Img2DataPtrType &extraPtr,
        const Img3DataPtrType &anotherPtr);
    static void createNeighborCoordinates(
        VecPointT &neighborCoordinates, 
        HxTagList &tags); // no member vars used
};


template <class ImgSigT, class ExtraSigT, class AnotherSigT, class FunctorT>
//__forceinline void 
void
HxImgFtorQueueBased<ImgSigT, ExtraSigT, AnotherSigT, FunctorT>::fillNeighborValues( // couldnt store imgPtr as members (no default ctor), so pass everything -> static
        const PointT &centralPoint, 
        int connectivity, 
        VecNeighborT &vecneighbors,
        const HxSizes &imgSize,
        const Img1DataPtrType &imgPtr,
        const Img2DataPtrType &extraPtr,
        const Img3DataPtrType &anotherPtr) {
//#pragma message("compiling fillNeighborValues with ...int connectivity...")
    vecneighbors.clear();
    int imgsizex=imgSize.x(), imgsizey=imgSize.y();
    if (connectivity==8) {
        for (int y=-1; y<=1; y++) {
            for (int x=-1; x<=1; x++) {
                int tempx=centralPoint.x+x, tempy=centralPoint.y+y;
                if (tempx>=0 && tempx<imgsizex && // border
                    tempy>=0 && tempy<imgsizey && // border
                    !(x==0 && y==0)) { // not center
                    Img1DataPtrType d=imgPtr;
                    Img2DataPtrType s1=extraPtr;
                    Img3DataPtrType s2=anotherPtr;
                    d.incXYZ(tempx, tempy);
                    s1.incXYZ(tempx, tempy);
                    s2.incXYZ(tempx, tempy);
                    typename FunctorT::Neighbors neighbors;
                    neighbors.point=PointT(tempx, tempy);
                    neighbors.arith=d.read(); 
                    neighbors.img=s1.read(); 
                    neighbors.mask=s2.read();
                    vecneighbors.push_back(neighbors);
                }
            }
        }
    } else if (connectivity==4) {
        for (int y=-1; y<=1; y++) {
            for (int x=-1; x<=1; x++) {
                int tempx=centralPoint.x+x, tempy=centralPoint.y+y;
                if (tempx>=0 && tempx<imgsizex && // border
                    tempy>=0 && tempy<imgsizey && // border
                    !(x==0 && y==0) && // not center
                    (x==0 || y==0)) { // 4 conn
                    Img1DataPtrType d=imgPtr;
                    Img2DataPtrType s1=extraPtr;
                    Img3DataPtrType s2=anotherPtr;
                    d.incXYZ(tempx, tempy);
                    s1.incXYZ(tempx, tempy);
                    s2.incXYZ(tempx, tempy);
                    typename FunctorT::Neighbors neighbors;
                    neighbors.point=PointT(tempx, tempy);
                    neighbors.arith=d.read(); 
                    neighbors.img=s1.read(); 
                    neighbors.mask=s2.read();
                    vecneighbors.push_back(neighbors);
                }
            }
        }
    } //else throw HxString ("unsupported connectivity");
} 


#ifdef INC_TEMPLATE_SRC
#include "HxImgFtorQueueBased.c"
#endif

#endif // #ifndef HxImgFtorQueue_h

---