# Multidimensional Discrete Wavelet Transform

By , 16 May 2012

## 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);

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

 lxdfigo Student Institute of Software, Chinese Academy of Sciences China Member
No Biography provided

Votes of 3 or less require a comment

 Search this forum Profile popups    Spacing RelaxedCompactTight   Noise Very HighHighMediumLowVery Low   Layout Open AllThread ViewNo JavascriptPreview   Per page 102550
 First Prev Next
 the link doesn't work lqzhu 27 Mar '13 - 14:42
 Excellent stchalon 4 Dec '12 - 10:47
 Thanks for the excellent code and picture that present the algorithm. This would be really great to have an example of application with a main calling the different procedure with input signal. In my case I would like to apply it to a signal s(t) as a one dimension vector. But I don't really catch how I should call the different functions. Sign In·View Thread·Permalink
 My vote of 5 Jasmine2501 21 May '12 - 9:50
 All the links and photos are working fine for me. I would like to see this algorithm against a smaller signal, but excellent article. Also, even though you said "you should be familiar with this" I think a brief background would be nice. Sign In·View Thread·Permalink
 My vote of 4 Sergio Andrés Gutiérrez Rojas 16 May '12 - 6:58
 Missing images Amarnath S 16 May '12 - 1:13
 Re: Missing images ednrg 16 May '12 - 4:06
 Re: Missing images embrabbit 8 Sep '12 - 3:41