|| ||           || Doxygen's  

---

HxExportExtraIdentMaskCentralMoments.h

/*
 *  Copyright (c) 2002, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *  Author(s):
 *  Dennis Koelma (koelma@wins.uva.nl)
 *
 */

#ifndef HxExportExtraIdentMaskCentralMoments_h
#define HxExportExtraIdentMaskCentralMoments_h

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


template<class ResultT, class ImValT, class ExtraValT>
class HxExportExtraIdentMaskCentralMoments
{
public:
    typedef HxTagTransVar       TransVarianceCategory;

    typedef HxTagNPhase         PhaseCategory;


                        HxExportExtraIdentMaskCentralMoments(HxTagList& tags);

                        ~HxExportExtraIdentMaskCentralMoments();

    int                 nrPhases() const;

    void                init(int phase);

    void                doIt(const ImValT& imV, const ExtraValT& extraV,
                             int x, int y, int z);

    void                done(int phase);

    static HxString     className();

private:
    HxTagList&          _tags;
    HxValueList*        _valList;
    ExtraValT           _maskVal;
    int                 _order;
    int                 _number;
    ResultT             _m00;
    ResultT             _m10;
    ResultT             _m01;
    ResultT             _xBar;
    ResultT             _yBar;
    ResultT*            _sums;
    int                 _curPhase;
};

template<class ResultT, class ImValT, class ExtraValT>

HxExportExtraIdentMaskCentralMoments<ResultT,ImValT,ExtraValT>::HxExportExtraIdentMaskCentralMoments(HxTagList& tags) : _tags(tags)
{
    _maskVal = HxGetTag<int>(tags, "maskVal");
    _order = HxGetTag<int>(tags, "order");
    _valList = HxGetTag<HxValueList*>(tags, "valList");
    _number = ((_order+1)*(_order+2))/2;
    _sums = new ResultT[_number];
    ResultT *ptr = _sums;
    for (int i=0 ; i<_number; i++)
        *ptr++ = HxScalarInt(0);
}

template<class ResultT, class ImValT, class ExtraValT>

HxExportExtraIdentMaskCentralMoments<ResultT,ImValT,ExtraValT>    ::~HxExportExtraIdentMaskCentralMoments()
{
    HxValueListBackInserter res = std::back_inserter(*_valList);
    for (int i=0 ; i<_number ; i++)
        *res++ = HxValue(_sums[i]);
    delete _sums;
}

template<class ResultT, class ImValT, class ExtraValT>
inline int
HxExportExtraIdentMaskCentralMoments<ResultT,ImValT,ExtraValT>::nrPhases() const
{
    return 2;
}

template<class ResultT, class ImValT, class ExtraValT>
inline void
HxExportExtraIdentMaskCentralMoments<ResultT,ImValT,ExtraValT>::init(int phase)
{
    _curPhase = phase;
    if (phase == 1) {
        _m00 = HxScalarInt(0);
        _m10 = HxScalarInt(0);
        _m01 = HxScalarInt(0);
    } else {
        _xBar = _m10 / _m00;
        _yBar = _m01 / _m00;
    }
}

template<class ResultT, class ImValT, class ExtraValT>
inline void

HxExportExtraIdentMaskCentralMoments<ResultT,ImValT,ExtraValT>    ::doIt(const ImValT& imV, const ExtraValT& extraV, int x, int y, int)
{
    if (extraV != _maskVal)
        return;
    if (_curPhase == 1) {
        _m00 += imV;
        _m10 += ResultT(HxScalarDouble(x)) * ResultT(imV);
        _m01 += ResultT(HxScalarDouble(y)) * ResultT(imV);
    } else {
        ResultT xx = ResultT(HxScalarDouble(x)) - _xBar;
        ResultT yy = ResultT(HxScalarDouble(y)) - _yBar;
        int i=0;
        for (int q=0 ; q<=_order ; q++) {
            for (int p=0 ; p<=_order ; p++) {
                if (p+q <= _order) {
                    _sums[i] += xx.pow(HxScalarInt(p)) * yy.pow(HxScalarInt(q)) * ResultT(imV);
                    i++;
                }
            }
        }
    }
}

template<class ResultT, class ImValT, class ExtraValT>
inline void
HxExportExtraIdentMaskCentralMoments<ResultT,ImValT,ExtraValT>::done(int phase)
{
}

template<class ResultT, class ImValT, class ExtraValT>
inline HxString
HxExportExtraIdentMaskCentralMoments<ResultT,ImValT,ExtraValT>::className()
{
    return HxString("identMaskCentralMoments");
}


#endif

---