|| ||           || Doxygen's  

---

HxNgbLocalMode.h

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

#ifndef HxNgbLocalMode_h
#define HxNgbLocalMode_h

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

inline double norm2sqr(HxScalarDouble val) { return val.x()*val.x(); }
inline double norm2sqr(HxVec2Double val) { return val.x()*val.x()+val.y()*val.y(); }
inline double norm2sqr(HxVec3Double val) { return val.x()*val.x()+val.y()*val.y()+val.z()*val.z(); }


template<class DstT, class SrcT>
class HxNgbLocalMode
{
public:

    typedef HxTagLoop           IteratorCategory;

    typedef HxTag1Phase         PhaseCategory;


                            HxNgbLocalMode(HxTagList& tags) 
                            {
                                _size = HxGetTag(tags, "ngbSize", HxSizes(11, 11, 1));
                                if (_size.x()<1&&_size.x()%2!=0&&_size.y()<1&&_size.y()%2!=0&&_size.z()!=1)
                                    throw HxString("Error: HxNgbLocalMode kernel must be 2D odd sized");
                                hsx = (_size.x()+0)/2; // e.g. s=11, half=5, xin=[0..11> xwork=[-5..+5]
                                hsy = (_size.y()+0)/2;
                                _tags=tags;
                                double sx = HxGetTag(tags, "sigmax", 2.0);
                                double sy = HxGetTag(tags, "sigmay", 2.0);
                                double sval = HxGetTag(tags, "sigmaval", 10.0);
                                _sigmax = -0.5/sx/sx;
                                _sigmay = -0.5/sy/sy;
                                _sigmaval = -0.5/sval/sval;
                            }

    HxSizes                 size()
                            {
                                return _size;
                            }

    void                    init(int /*x*/, int /*y*/, const SrcT& /*v1*/, const SrcT& v2)
                            {
                                _v2=v2;
                                teller = HxScalarDouble(0.0);
                                noemer=0.0;
                            }

    void                    check(int i, int j) 
                            {
                                if (i<-hsx||i>hsx||j<-hsy||j>hsy)
                                    std::cout << "error i=" << i << ", j" << j << std::endl;
                            }

    void                    next(int x, int y, const SrcT& v1, const SrcT& /*v2*/)
                            {
                                int i=x-hsx;
                                int j=y-hsy;
#ifdef _DEBUG
                                check(i,j);
#endif
                                double po=0;
                                po += i*i*_sigmax;
                                po += j*j*_sigmay;
                                po += norm2sqr(v1-_v2)*_sigmaval;
                                double w=exp(po);
                                teller += v1*DstT(HxScalarDouble(w));
                                noemer += w;
                            }

    DstT                    result() const
                            {
                                return teller/DstT(HxScalarDouble(noemer));
                            }

    static HxString         className()
                            {
                                return HxString("localMode");
                            }

private:
    HxSizes                 _size;
    HxTagList               _tags;
    int                     _x, _y;
    int                     hsx, hsy; // half kernel size x,y
    SrcT                    _v2;
    double                  _sigmax, _sigmay, _sigmaval; // calculated from taglist
    DstT                    teller;
    double                  noemer;

};

#endif

---