Multidimensional Discrete Wavelet Transform

• Download WaveletLib.zip - 2.2 KB
 

Introduction 

I give a class of multidimensional discrete wavelet transform.  This class can analyze the multidimensional input signal and synthesize it after process.  The input signal can be one dimensional signal(like a wave), two dimensional signal(like a image) or multidimensional signal. 

Background  

You should know the discrete wavelet transform(DWT) before using this class. The following figure shows the basic idea of the DWT. 

After DWT, the input signal is analyzed into wavelet coefficients. The wavelet coefficients can be processed and synthesize  into the output signal. There are four filters in this whole process: high pass filters, H and H'; low pass filters, L and L'; 

After DWT, the input signal is analyzed into wavelet coefficients. The wavelet coefficients can be processed and synthesize  into the output signal. There are four filters in this whole process: high pass filters, H and H'; low pass filters, L and L'; 

Using the code 

The class is shown below. 

//
// The wavelet transform class
//
class WaveletAnalysis{
public:
// the construction
	WaveletAnalysis(vector<double> input,vector<unsigned int> dim,unsigned int level,
		vector<double> h0,vector<double> h1,vector<double> h2,vector<double> h3);
	~WaveletAnalysis(void);

private:
// The four filters: L(H0),H(H1),L'(H2),H'(H3)
	CFilterFunc funcH0,funcH1,funcH2,funcH3;

// The decomposition levels
	unsigned int level;
// The buffer which save the signal and the wavelet coefficients
	vector<double> scalevalues;
	vector<double> waveletvalues;

	vector<double> *inputvalues;
	vector<double> *outputvalues;
	vector<unsigned int> offsets;
	vector<unsigned int> lens;

// The multidimensional lengths
	vector<unsigned int> dimensions;

public:
	void resetlevel(unsigned int level);
	void resetinput(vector<double> input,vector<unsigned int> ds);

//DWT
	void transform();
//iDWT
	void itransform();

	double getOutputValue(vector<unsigned int> ord){
		offsets = ord;
		unsigned int offset = getOffset();
		return (*outputvalues)[offset];}
//The process between the DWT and iDWT
	void process();
private:
	typedef void (WaveletAnalysis::*FuncInWhile)(void *);
	void whileProcess(FuncInWhile func,void* parameter);

	void initOffsetsAndLens(unsigned int level);
	void initOutput(void *v);

	void reconstructOneDimension(void * d);
	void analyzeOneDimension(void * d);

	inline void copyInput2Output(void *);
	inline void copyInput2OuputOnDim(void *dim);

	inline void swapVectorPointer();
	unsigned int getOffset();
};
  

// The main process of the DWT and iDWT

void WaveletAnalysis::transform(){
	inputvalues = &scalevalues;
	outputvalues = &waveletvalues;

	for(unsigned int l = 0; l < level; ++l){
		for(unsigned int d = 0; d < dimensions.size(); d++){
			initOffsetsAndLens(l);
			lens[d] = lens[d] >> 1;
			whileProcess(&WaveletAnalysis::analyzeOneDimension,&d);
			swapVectorPointer();
		}

		initOffsetsAndLens(l);
		whileProcess(&WaveletAnalysis::copyInput2Output,NULL);
		swapVectorPointer();

		initOffsetsAndLens(l+1);
		whileProcess(&WaveletAnalysis::copyInput2Output,NULL);
		swapVectorPointer();
	}
}

void WaveletAnalysis::itransform(){
	swapVectorPointer();

	for(unsigned int l = level; l > 0; --l){
		for(int d = dimensions.size() - 1; d >=0 ; d--){
			initOffsetsAndLens(l-1);
			whileProcess(&WaveletAnalysis::initOutput,0);

			initOffsetsAndLens(l-1);
			lens[d] = lens[d] >> 1;

			whileProcess(&WaveletAnalysis::reconstructOneDimension,&d);
			swapVectorPointer();

			initOffsetsAndLens(l-1);
			whileProcess(&WaveletAnalysis::copyInput2Output,NULL);
			swapVectorPointer();
		}
	}
}   

The inputs of the class are four kinds of parameters:

1.The input signal. 

2.The dimensional length of this multidimensional signals. 

3.The decomposition level. 

4.The four filters. 

Take a two dimensional image for example:

The input signal is:  

The dimensional length is dimensions: 

// the multidimensional lengths
vector<unsigned int> dimensions; 
dimensions.push_back(512);
dimensions.push_bask(512);  

The decomposition level is 5.

The four filters are Haar filters:

// Haar wavelet
vector<double> h0, h1,h2,h3;
double sqr = sqrtf(2.0);
h0.push_back(0.5*sqr);
h0.push_back(0.5*sqr);
h1.push_back(-0.5*sqr );
h1.push_back(0.5*sqr );
h2.push_back(0.5*sqr);
h2.push_back(0.5*sqr);
h3.push_back(-0.5*sqr );
h3.push_back(0.5*sqr ); 

The result of DWT is:

I erase the high frequency coefficients and iDWT the signal the output is shown below:

Points of Interest

This class can analyze the signal of any dimensions. The second parameter defines the length of each dimension. The input signal(input signal) should be as long as the second parameter defined.

History

Version 1.0