|| ||           || Doxygen's  

---

HxGaussIIR.h

/*
 *  Copyright (c) 2000, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *  Author(s):
 *  Jan-Mark Geusebroek (mark@wins.uva.nl)
 *
 */

#ifndef HxGaussIIR_h
#define HxGaussIIR_h


#include "HxImageRep.h"
#include "HxImageGenerator.h"

#define MAXRECUR 5    /* maximum order of recursion */
#define MAXDERI  2    /* maximum derivative order */


class L_HXIMAGEREP GaussIIR: public HxImageGenerator
{
public:
                            GaussIIR(double sigma, int derivativeOrder = 0,
                                int filterOrder = 3);
    virtual HxSizes         domainSize() const
                                {
                                    return HxSizes(2*_filterOrder+1, 1, 1);
                                } 
    virtual HxVec3Double    get(int x, int y, int z)
                                {
                                    return _filter[x];
                                }
    double                  filterOrder() const
                                {
                                    return _filterOrder;
                                }

    double                  sigma() const
                                {
                                    return _sigma;
                                }

    double                  derivativeOrder() const
                                {
                                    return _derivativeOrder;
                                }

    STD_OSTREAM&            put(STD_OSTREAM&) const;


    template<class TypePtr> void   forward3(TypePtr ptr, int n)
        {
            double val, p1, p2, p3;
            double a0 = _filter[3].x();
            double a1 = _filter[2].x();
            double a2 = _filter[1].x();
            double a3 = _filter[0].x();

            p1 = *ptr++; p2 = p1; p3 = p2;
            n--;
            while (n--) {
                val = a0 * *ptr + a1 * p1 + a2 * p2 + a3 * p3;
                *ptr++ = val;
                p3 = p2; p2 = p1; p1 = val;
            }
        }

    template<class TypePtr> void   backward3(TypePtr ptr, int n)
        {
            double val, p1, p2, p3;
            double a0 = _filter[3].x();
            double a1 = _filter[4].x();
            double a2 = _filter[5].x();
            double a3 = _filter[6].x();

            p1 = *(--ptr); p2 = p1; p3 = p2;
            n--;
            while (n--) {
                val = a0 * *(--ptr) + a1 * p1 + a2 * p2 + a3 * p3;
                *ptr = val;
                p3 = p2; p2 = p1; p1 = val;
            }
        }

#ifdef NOMSDEVBUG
    template<class TypePtr> void   backward3(TypePtr ptr, int n, int deri)
        {
            double val, p1, p2, p3;
            double a0 = _filter[3].x();
            double a1 = _filter[4].x();
            double a2 = _filter[5].x();
            double a3 = _filter[6].x();

            p1 = *(--ptr); p2 = p1; p3 = p2;
            n--;
            switch(deri) {
            case 1:
                while (n--) {
                    val = a0 * *(--ptr) + a1 * p1 + a2 * p2 + a3 * p3;
                    *(ptr+1) = p2-val;
                    p3 = p2; p2 = p1; p1 = val;
                }
                break;
            case 2:
                while (n--) {
                    val = a0 * *(--ptr) + a1 * p1 + a2 * p2 + a3 * p3;
                    *(ptr+1) = val-p1-p1+p2;
                    p3 = p2; p2 = p1; p1 = val;
                }
                break;
            default: // order 0
                while (n--) {
                    val = a0 * *(--ptr) + a1 * p1 + a2 * p2 + a3 * p3;
                    *ptr = val;
                    p3 = p2; p2 = p1; p1 = val;
                }
                break;
            }
        }
#endif

    template<class InPtrT, class OutPtrT>
    void   forward3(InPtrT in, OutPtrT out, int n)
        {
            double val, p1, p2, p3;
            double a0 = _filter[3].x();
            double a1 = _filter[2].x();
            double a2 = _filter[1].x();
            double a3 = _filter[0].x();

            p1 = *in++; p2 = p1; p3 = p2;
            *out++ = p1;
            n--;
            while (n--) {
                val = a0 * *in++ + a1 * p1 + a2 * p2 + a3 * p3;
                *out++ = val;
                p3 = p2; p2 = p1; p1 = val;
            }
        }

    template<class TypePtr> void   lineFilter(TypePtr ptr, int n, int deri=0)
        {
            switch(_filterOrder) {
            case 3:
                forward3(ptr, n);
                backward3(ptr+n, n/*, deri*/);
                break;
            }
        }

    template<class InPtrT, class OutPtrT>
    void   lineFilter(InPtrT in, OutPtrT out, int n, int deri=0)
        {
            switch(_filterOrder) {
            case 3:
                forward3(in, out, n);
                backward3(out+n, n/*, deri*/);
                break;
            }
        }


private:
    HxVec3Double            _filter[2*MAXRECUR+1];

    double                  _sigma;
    int                     _derivativeOrder;
    int                     _filterOrder;
};


inline STD_OSTREAM&
operator<<(STD_OSTREAM& os, const GaussIIR& filter)
{ 
    return filter.put(os);
}

#endif

---