hgaussianfilter.h

#ifndef __HGAUSSIANFILTER_H
#define __HGAUSSIANFILTER_H
 
#include "hfilter.h"
#include "hwriter.h"
#include "hwriterconsumer.h"
#include "hreader.h"
#include "hprobe.h"
 
#include <complex>
 
template <class T>
class HGaussianFilter : public HFilter<T>
{
    private:
 
        size_t _blocksize;
        int _strength;
        int _n;
        int _blocks;
        HRectangularWindow<T>* _win;
 
        std::complex<double>* _response;
        HFft<T>* _fft;
 
        void Init() {
            if( _blocksize % _n != 0 ) {
                HError("%d is not dividable into %d chunks", _blocksize, _n);
                throw new HInitializationException("Blocksize can not be divided equally by the fft size");
            }
 
            _response = new std::complex<double>[_n];
 
            _win = new HRectangularWindow<T>();
            _fft =  new HFft<T>(_n, _win);
 
            _blocks = _blocksize / _n;
        }
 
    public:
 
        HGaussianFilter(HWriter<T>* writer, size_t blocksize, int strength, int n, HProbe<T>* probe = NULL):
            HFilter<T>(writer, blocksize, probe),
            _blocksize(blocksize),
            _strength(strength),
            _n(n) {
            Init();
        }
 
        HGaussianFilter(HWriterConsumer<T>* consumer, size_t blocksize, int strength, int n, HProbe<T>* probe = NULL):
            HFilter<T>(consumer, blocksize, probe),
            _blocksize(blocksize),
            _strength(strength),
            _n(n) {
            Init();
        }
 
        HGaussianFilter(HReader<T>* reader, size_t blocksize, int strength, int n, HProbe<T>* probe = NULL):
            HFilter<T>(reader, blocksize, probe),
            _blocksize(blocksize),
            _strength(strength),
            _n(n) {
            Init();
        }
 
        ~HGaussianFilter() {
            delete _response;
            delete _fft;
            delete _win;
        }
 
        void Filter(T* src, T* dest, size_t blocksize);
};
 
#endif