|| ||           || Doxygen's  

---

HxNgbHilditch.h

/*
 *  Copyright (c) 2002, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *  Author(s):
 *  Leon Todoran            (todoran@science.uva.nl)
 */

#ifndef HxNgbHilditch_h
#define HxNgbHilditch_h

#include "HxClassName.h"
#include "HxSizes.h"
#include "HxCategories.h"
#include "HxTagList.h"

#include <algorithm>

template <class ArgType, class ResType>
class HxNgbHilditch 
{
public:

    typedef HxTagLoop        IteratorCategory;

    typedef HxTag1Phase      PhaseCategory;


//                          HxNgbHilditch();
                            HxNgbHilditch(HxTagList& tags);
                            ~HxNgbHilditch();

    HxSizes                 size();
    void                    init(int, int, ArgType);

    void                    next(int x, int y, ArgType value);
    ResType                  result();// const;

    static HxString         className();

private:
    int                     _pctIdx;
    int                     _size;  //this 
    bool                    _changed; 

    HxTagList&              _tags;

    ArgType*                 _values;
    int                     _i;


    int idxKernel[9];//={ 6, 7, 8,11,12,13,16,17,18};
    int idxAp1[9];//    ={ 7, 8,13,18,17,16,11, 6, 7};
    int idxAp2[9];//    ={ 2, 3, 8,13,12,11, 6, 1, 2};
    int idxAp4[9];//    ={ 8, 9,14,19,18,17,12, 7, 8};


};

template <class ArgType, class ResType>
ostream&
operator<<(ostream& os, const HxNgbHilditch<ArgType, ResType>& pct)
{
    return pct.put(os);
}

template <class ArgType, class ResType>
inline HxString
HxNgbHilditch<ArgType, ResType>::className()
{
    static HxString s("hilditch");
    return s;
}

template <class ArgType, class ResType>
inline void
HxNgbHilditch<ArgType, ResType>::init(int, int, ArgType)
{
    _i = 0;
}

template <class ArgType, class ResType>
inline void
HxNgbHilditch<ArgType, ResType>::next(int, int, ArgType value)
{
    _values[_i++] = value;
}

template <class ArgType, class ResType>
inline HxSizes
HxNgbHilditch<ArgType, ResType>::size()
{
    return HxSizes(_size, _size, 1);
}

template <class ArgType, class ResType>
inline ResType
HxNgbHilditch<ArgType, ResType>::result() //const
{
    //we are only interested in pixels that ore 0 (object)
    if(_values[_pctIdx].x() !=0 )
        return _values[_pctIdx];
    int j;
    int nrNZN=0; //number of non-zero neighbors
    int ap1=0,ap2=0,ap4=0; //in fact I'm interested to know only if this value is 1 or not
    bool p2p4p8, p2p4p6;
    p2p4p8 = (_values[7].x()==1) || (_values[13].x()==1) || (_values[11].x()==1);
    p2p4p6 = (_values[7].x()==1) || (_values[13].x()==1) || (_values[17].x()==1);
//  printf("p2p4p8=%d, p2p4p6=%d, ap2=%d, ap4=%d\n", p2p4p8, p2p4p6,ap2,  ap4);

    for(j=0;j<9;j++)
        if(_values[idxKernel[j]].x()!=0 && j!=4)
            nrNZN++;

    if( (nrNZN>=2) && (nrNZN<=6) )
    {

        //locate the first 0 pixel
        for(j=0;j<9;j++)
            if(_values[idxAp1[j]]==0)
                break;
        if(j<8) 
            for(j++;j<9;j++)
                if(_values[idxAp1[j]]!=0)
                {
                    ap1++;
                    break;
                }
        if(j<8) 
            for(j++ ;j<9;j++)
                if(_values[idxAp1[j]]==0)
                    break;
        if(j<8) 
            for(j++ ;j<9;j++)
                if(_values[idxAp1[j]]!=0)
                {
                    ap1++;
                    break;
                }

        if( ap1==1 ) 
        {
        
            //I compute ap2 only if I really need it
             if( !p2p4p8)
             {
             
            //locate the first 0 pixel
            for(j=0;j<9;j++)
                if(_values[idxAp2[j]]==0)
                    break;
            if(j<8) 
                for(j++ ;j<9;j++)
                    if(_values[idxAp2[j]]!=0)
                    {
                        ap2++;
                        break;
                    }
            if(j<8) 
                for(j++ ;j<9;j++)
                    if(_values[idxAp2[j]]==0)
                        break;
            if(j<8) 
                for(j++ ;j<9;j++)
                    if(_values[idxAp2[j]]!=0)
                    {
                        ap2++;
                        break;
                    }
             }

             if( !p2p4p6 )
             {   
                //locate the first 0 pixel
                for(j=0;j<9;j++)
                    if(_values[idxAp4[j]]==0)
                        break;
                if(j<8) 
                    for(j++ ;j<9;j++)
                        if(_values[idxAp4[j]]!=0)
                        {
                            ap4++;
                            break;
                        }
                if(j<8) 
                    for(j++ ;j<9;j++)
                        if(_values[idxAp4[j]]==0)
                            break;
                if(j<8) 
                    for(j++ ;j<9;j++)
                        if(_values[idxAp4[j]]!=0)
                        {
                            ap4++;
                            break;
                        }
             }

            //for optimization, I split up this condition
    //  if( (nrNZN>=2) && (nrNZN<=6) && 
    //      if( (ap1==1) &&
            if( ( p2p4p8 || ap2!=1) &&
                ( p2p4p6 || ap4!=1)
                )
            {
                //set the changed flag
                    _changed = true;
                    return 1;
            }
        }//end if a1==1
    }//end if nrNonZeroNeighbors >2 &<6
    return _values[_pctIdx];
}

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


#endif

---