图像的正交变换---沃尔什——哈达马变换

/*************************************************************************

*

* 函数名称：

*   WALSH()

*

* 参数:

*   double* f			- 输入的时域序列

*   double* F			- 输出的频域序列

*   int r				- 2的幂数		

*

* 返回值:

*   BOOL               - 成功返回TRUE，否则返回FALSE。

*

* 说明:

*   该函数进行一维快速沃尔什——哈达马变换。

*

************************************************************************/

void WALSH(double*f,double*F,int r);

/*************************************************************************

*

* 函数名称：

*   IWALSH()

*

* 参数:

*   double* f			- 输入的时域序列

*   double* F			- 输出的频域序列

*   int r				- 2的幂数		

*

* 返回值:

*   BOOL               - 成功返回TRUE，否则返回FALSE。

*

* 说明:

*   该函数进行一维快速沃尔什——哈达马逆变换。

*

************************************************************************/

void IWALSH(double*F,double*f,int r);

/*************************************************************************

*

* 函数名称：

*   FreqWALSH()

*

* 参数:

*   double* f			- 输入的时域序列

*   double* F			- 输出的频域序列

*	 LONG width			- 图象宽度

*	 LONG height		- 图象高度

*

* 返回值:

*   BOOL               - 成功返回TRUE，否则返回FALSE。

*

* 说明:

*   该函数进行二维快速沃尔什——哈达玛变换。

*

************************************************************************/

BOOL FreqWALSH(double*f,double*F, LONG width, LONG height);

/*************************************************************************

*

* 函数名称：

*   IFreqWALSH()

*

* 参数:

*   double* f			- 输入的时域序列

*   double* F			- 输出的频域序列

*	 LONG width		- 图象宽度

*	 LONG height		- 图象高度

*

* 返回值:

*   BOOL               - 成功返回TRUE，否则返回FALSE。

*

* 说明:

*   该函数进行二维快速沃尔什——哈达玛逆变换。

*

************************************************************************/

BOOL IFreqWALSH(double*f,double*F, LONG width, LONG height);

/*************************************************************************

*

* 函数名称：

*   BmpWalsh()

*

* 参数:

*   BYTE* bmp,LONG width,LONG height

*

* 返回值:

*   BOOL               - 成功返回TRUE，否则返回FALSE。

*

* 说明:

*   该函数对图象进行二维快速沃尔什——哈达马变换。

*

************************************************************************/

BOOL BmpWalsh(BYTE* bmp,LONG width,LONG height);

voidMyProcess::WALSH(double*f,double*F,int r)

{

// 循环变量

LONG	i;

LONG	j;

LONG	k;

// 中间变量

int		p;

double* X;

// 计算快速沃尔什变换点数

LONG N =1<< r;

// 分配运算所需的数组

double* X1 =newdouble[N];

double* X2 =newdouble[N];

// 将时域点写入数组X1

memcpy(X1, f,sizeof(double)* N);

// 蝶形运算

for(k =0; k < r; k++)

{

for(j =0; j <1<<k; j++)

{

for(i =0; i <1<<(r - k -1); i++)

{

p = j *(1<<(r - k));

X2[i + p]= X1[i + p]+ X1[i + p +(int)(1<<(r - k -1))];

X2[i + p +(int)(1<<(r - k -1))]= X1[i + p]- X1[i + p +(int)(1<<(r - k -1))];

}

}

// 互换X1和X2

X = X1;

X1 = X2;

X2 = X;

}

// 调整系数

for(j =0; j < N; j++)

{

p =0;

for(i =0; i < r; i++)

{

if(j &(1<<i))

{

p +=1<<(r - i -1);

}

}

F[j]= X1[p]/ N;

}

// 释放内存

delete X1;

delete X2;

}

voidMyProcess::IWALSH(double*F,double*f,int r)

{

// 循环变量

int		i;

// 计算变换点数

LONG N =1<< r;

// 调用快速沃尔什－哈达玛变换进行反变换

WALSH(F, f, r);

// 调整系数

for(i =0; i < N; i++)

f[i]*= N;

}

BOOL MyProcess::FreqWALSH(double*f,double*F, LONG width, LONG height)

{

// 循环变量

LONG	i;

LONG	j;

LONG    k;

// 进行离散余弦变换的宽度和高度（2的整数次方）

LONG w =1;

LONG h =1;

int wp =0;

int hp =0;

// 计算进行离散余弦变换的宽度和高度（2的整数次方）

while(w < width/3)

{

w *=2;

wp++;

}

while(h < height)

{

h *=2;

hp++;

}

// 分配内存

double*TempIn=newdouble[h];

double*TempOut=newdouble[h];

// 对y方向进行离散余弦变换

for(i =0; i < w *3; i++)

{

// 抽取数据

for(j =0; j < h; j++)

TempIn[j]= f[j * w *3+ i];

// 一维快速离散余弦变换

WALSH(TempIn,TempOut, hp);

// 保存变换结果

for(j =0; j < h; j++)

f[j * w *3+ i]=TempOut[j];

}

// 释放内存

deleteTempIn;

deleteTempOut;

// 分配内存

TempIn=newdouble[w];

TempOut=newdouble[w];

// 对x方向进行快速离散余弦变换

for(i =0; i < h; i++)

{

for(k =0; k <3; k++)

{

// 抽取数据

for(j =0; j < w; j++)

TempIn[j]= f[i * w *3+ j *3+ k];

// 一维快速离散余弦变换

WALSH(TempIn,TempOut, wp);

// 保存变换结果

for(j =0; j < w; j++)

F[i * w *3+ j *3+ k]=TempOut[j];

}

}

// 释放内存

deleteTempIn;

deleteTempOut;

return TRUE;

}

BOOL MyProcess::IFreqWALSH(double*f,double*F, LONG width, LONG height)

{

// 循环变量

LONG	i;

LONG	j;

LONG    k;

// 赋初值

LONG w =1;

LONG h =1;

int wp =0;

int hp =0;

// 计算进行付立叶变换的宽度和高度（2的整数次方）

while(w < width/3)

{

w *=2;

wp++;

}

while(h < height)

{

h *=2;

hp++;

}

// 分配内存

double*TempIn=newdouble[w];

double*TempOut=newdouble[w];

// 对x方向进行快速付立叶变换

for(i =0; i < h; i++)

{

for(k =0; k <3; k++)

{

// 抽取数据

for(j =0; j < w; j++)

TempIn[j]= F[i * w *3+ j *3+ k];

// 一维快速傅立叶变换

IWALSH(TempIn,TempOut, wp);

// 保存变换结果

for(j =0; j < w; j++)

F[i * w *3+ j *3+ k]=TempOut[j];

}

}

// 释放内存

deleteTempIn;

deleteTempOut;

TempIn=newdouble[h];

TempOut=newdouble[h];

// 对y方向进行快速付立叶变换

for(i =0; i < w *3; i++)

{

// 抽取数据

for(j =0; j < h; j++)

TempIn[j]= F[j * w *3+ i];

// 一维快速傅立叶变换

IWALSH(TempIn,TempOut, hp);

// 保存变换结果

for(j =0; j < h; j++)

F[j * w *3+ i]=TempOut[j];

}

// 释放内存

deleteTempIn;

deleteTempOut;

for(i =0; i < h; i++)

{

for(j =0; j < w *3; j++)

{

if(i < height && j < width)

*(f + i * width + j)= F[i * w *3+ j];

}

}

return TRUE;

}

BOOL MyProcess::BmpWalsh(BYTE* bmp,LONG width,LONG height)

{

// 循环变量

LONG	i;

LONG	j;

// 进行沃尔什——哈达玛变换的宽度和高度（2的整数次方）

LONG w =1;

LONG h =1;

int wp =0;

int hp =0;

// 计算进行离散余弦变换的宽度和高度（2的整数次方）

while(w < width/3)

{

w *=2;

wp++;

}

while(h < height)

{

h *=2;

hp++;

}

// 分配内存

double*f =newdouble[w * h *3];

double*F =newdouble[w * h *3];

// 向时域赋值并补零

for(i =0; i < h; i++)

{

for(j =0; j < w *3; j++)

{

if(i < height && j < width)

f[i * w *3+ j]= bmp[width * i + j];

else

f[w * i *3+ j]=0.0f;

}

}

// 进行频谱分析

if(FreqWALSH(f, F,width, height)== FALSE)

return FALSE;

// 更新所有象素

for(i =0; i < height; i++)

{

for(j =0; j < width; j++)

{

// 判断是否超过255

if(fabs(F[i * w *3+ j]*1000)>255)

{

// 对于超过的，直接设置为255

bmp[width *(height -1- i)+ j]=255;

}

else

{

// 如果没有超过，则按实际计算结果赋值

bmp[width *(height -1- i)+ j]= fabs(F[i * w *3+ j]*1000);

}

}

}

//释放内存

delete[] f;

delete[] F;

// 返回

return TRUE;

}