Gaussian filter, or Gaussian blur source code

// gaussianblur.h - declaration of template class
// of 1D and 2D gaussian blur or filter
//
// The code is property of LIBROW
// You can use it on your own
// When utilizing credit LIBROW site
#ifndef _GAUSSIANBLUR_H_
#define _GAUSSIANBLUR_H_
template <class T = double> class TGaussianBlur
{
public:
 // 1D GAUSSIAN BLUR
 // pSignal - input signal;
 // pResult - output signal, NULL for inplace processing
 // N - length of the signal
 // W - window size, odd positive number
 bool Filter(T *pSignal, T *pResult, unsigned int N, unsigned int W) const;
 // 2D GAUSSIAN BLUR
 // pImage - input image
 // pResult - output image, NULL for inplace processing
 // N - width of the image
 // M - height of the image
 // W - window size, odd positive number
 bool Filter(T *pImage, T *pResult,
 unsigned int N, unsigned int M, unsigned int W) const;
protected:
 // Internal auxiliary structure - data array size descriptor
 struct CSize
 {
 unsigned int x; // Array width
 unsigned int y; // Array height
 // Default constructor
 CSize(): x(0), y(0) {}
 // Constructor with initialization
 CSize(unsigned int _x, unsigned int _y): x(_x), y(_y) {}
 // Initialization
 void Set(unsigned int _x, unsigned int _y) { x = _x; y = _y; }
 // Area
 unsigned int Area() const { return x * y; }
 };
 // Internal auxiliary structure - array descriptor
 struct CArray
 {
 CSize Size; // Array size
 T *Buffer; // Element buffer
 // Default constructor
 CArray(): Buffer(NULL) {}
 // Constructors with initialization
 CArray(T *_Buffer, const CSize &_Size): Buffer(_Buffer), Size(_Size) {}
 CArray(T *_Buffer, unsigned int _N): Buffer(_Buffer), Size(_N, 1) {}
 };
 // Internal auxiliary structure - filter window descriptor
 struct CWindow
 {
 T *Weights; // Window weights
 unsigned int Size; // Window size
 // Default constructor
 CWindow(): Weights(NULL), Size(0), Correction(.5 - double(T(.5))) {}
 // Destructor
 ~CWindow() { if (Weights) delete[] Weights; }
 // Filter window creation
 bool Create(unsigned int _Size);
 // FILTER WINDOW APPLICATION
 // _Element - start element in signal/image
 T Apply(const T *_Element) const
 {
 // Apply filter - calculate weighted mean
 double Sum = 0.;
 const double *WeightIter = Weights;
 const T *ElIter = _Element;
 const double *const End = Weights + Size;
 while (WeightIter < End) Sum += *(WeightIter++) * double(*(ElIter++));
 return T(Sum + Correction);
 }
 protected:
 const double Correction; // Result correction
 };
 // Internal auxiliary functions - check input data consistency
 bool Consistent(const T *_Image, const CSize &_Size, unsigned int _W) const
 {
 return _Image && _Size.x && _Size.y && _W &&
 _Size.x> (_W>> 1) && _Size.y> (_W>> 1) && _W & 1;
 }
 bool Consistent(const T *_Signal, unsigned int _N, unsigned int _W) const
 {
 return _Signal && _N && _W && _N> (_W>> 1) && _W & 1;
 }
};
// Include implementation file
#include "gaussianblur.cpp"
#endif