2019-08-01 09:24:12 baishuiniyaonulia 阅读数 698

沃尔什变换

沃尔什变换是由+1或-1的基本函数的级数展开而成的,满足完备正交特性,属于方波型正交变换。由于沃尔什函数是二值正交函数,与数字逻辑中的两个状态相对应,因此它更适用于计算机技术、数字信号处理

一维沃尔什变换

沃尔什变换要求空域矩阵阶数NN满足N=2nN=2^n,若满足,则有:F(μ)=x=0N1f(x)g(x,μ)F(\mu)=\sum_{x=0}^{N-1}f(x)g(x,\mu)g(x,μ)=1Ni=0n1(1)i=0n1bi(x)bn1(μ)g(x,\mu)=\frac{1}{N}\prod_{i=0}^{n-1}(-1)^{\sum_{i=0}^{n-1}b_i(x)b_{n-1}(\mu)}一维沃尔什反变换:f(x)=x=0N1F(μ)h(x,μ)f(x)=\sum_{x=0}^{N-1}F(\mu)h(x,\mu)h(x,μ)=i=0n1(1)i=0n1bi(x)bn1(μ)h(x,\mu)=\prod_{i=0}^{n-1}(-1)^{\sum_{i=0}^{n-1}b_i(x)b_{n-1}(\mu)}其中,bi(x)b_i(x)xx的二进制表达式中第ii位的意思
例如N=2nN=2^nn=3n=3x=6x=6,则有x=6=(110)2x=6=(110)_2,可得b0(x)=0b_0(x)=0b1(x)=1b_1(x)=1b2(x)=1b_2(x)=1

与傅立叶变换不同,沃尔什变换的变换核是由+1或-1构成的二值对称矩阵

例如:求N=22N=2^2的沃尔什变换F(0)=14x=03[f(x)i=01(1)bi(x)+b1i(0)]=14[f(0)+f(1)+f(2)+f(3)]F(0)=\frac{1}{4}\sum_{x=0}^{3}[f(x)\prod_{i=0}^{1}(-1)^{b_i(x)+b_{1-i}(0)}]=\frac{1}{4}[f(0)+f(1)+f(2)+f(3)]F(1)=14x=03[f(x)i=01(1)bi(x)+b1i(1)]=14[f(0)+f(1)f(2)f(3)]F(1)=\frac{1}{4}\sum_{x=0}^{3}[f(x)\prod_{i=0}^{1}(-1)^{b_i(x)+b_{1-i}(1)}]=\frac{1}{4}[f(0)+f(1)-f(2)-f(3)]F(2)=14x=03[f(x)i=01(1)bi(x)+b1i(2)]=14[f(0)f(1)+f(2)f(3)]F(2)=\frac{1}{4}\sum_{x=0}^{3}[f(x)\prod_{i=0}^{1}(-1)^{b_i(x)+b_{1-i}(2)}]=\frac{1}{4}[f(0)-f(1)+f(2)-f(3)]F(3)=14x=03[f(x)i=01(1)bi(x)+b1i(3)]=14[f(0)f(1)f(2)+f(3)]F(3)=\frac{1}{4}\sum_{x=0}^{3}[f(x)\prod_{i=0}^{1}(-1)^{b_i(x)+b_{1-i}(3)}]=\frac{1}{4}[f(0)-f(1)-f(2)+f(3)]其中方括号中各项的符号即位变换核的符号

可见沃尔什变换的本质是将离散序列f(x)f(x)中各项值的符号按规律改变进行加减运算

二维沃尔什变换

F(μ,ν)=1Nx=0N1x=0N1f(x,y)g(x,y,μ,ν)F(\mu,\nu)=\frac{1}{N}\sum_{x=0}^{N-1}\sum_{x=0}^{N-1}f(x,y)g(x,y,\mu,\nu)f(x,y)=1Nμ=0N1ν=0N1F(μ,ν)g(x,y,μ,ν)f(x,y)=\frac{1}{N}\sum_{\mu=0}^{N-1}\sum_{\nu=0}^{N-1}F(\mu,\nu)g(x,y,\mu,\nu)g(x,y,μ,ν)=G=1Ni=0n1(1)i=0n1[bi(x)bn1i(μ)+bi(y)bn1i(ν)]g(x,y,\mu,\nu)=G=\frac{1}{N}\prod_{i=0}^{n-1}(-1)^{\sum_{i=0}^{n-1}[b_i(x)b_{n-1-i}(\mu)+b_i(y)b_{n-1-i}(\nu)]}表达为矩阵形式为F=1N2GfGF=\frac{1}{N^2}GfGf=GFGf=GFG

与傅立叶变换一样,二维沃尔什变换是可分离的,可以通过两个一维沃尔什变换完成计算g(x,y,μ,ν)=g1(x,μ)g2(y,ν)g(x,y,\mu,\nu)=g_1(x,\mu)g_2(y,\nu)

实例:求离散沃尔什变换
f=[1331133113311331]f=\begin{bmatrix} 1 & 3 & 3 & 1 \\ 1 & 3 & 3 & 1 \\ 1 & 3 & 3 & 1 \\ 1 & 3 & 3 & 1 \\ \end{bmatrix}可知N=4N=4,其变换核为G=[1111111111111111]G=\begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 1 & -1 & -1 \\ 1 & -1 & 1 & -1 \\ 1 & -1 & -1 & 1 \\ \end{bmatrix}则有F=1N2GfG=142[1111111111111111][1331133113311331][1111111111111111]=[2001000000000000]F=\frac{1}{N^2}GfG=\frac{1}{4^2}\begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 1 & -1 & -1 \\ 1 & -1 & 1 & -1 \\ 1 & -1 & -1 & 1 \\ \end{bmatrix}\begin{bmatrix} 1 & 3 & 3 & 1 \\ 1 & 3 & 3 & 1 \\ 1 & 3 & 3 & 1 \\ 1 & 3 & 3 & 1 \\ \end{bmatrix}\begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 1 & -1 & -1 \\ 1 & -1 & 1 & -1 \\ 1 & -1 & -1 & 1 \\ \end{bmatrix}=\begin{bmatrix} 2 & 0 & 0 & -1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ \end{bmatrix}可以看出,沃尔什变换具有信息集中的作用,原始数据中数字越是均匀分布,变换后的数据越是集中于边角区域

哈达玛变换

与沃尔什变换类似,由哈达玛变换核组成的矩阵是一个正交对称矩阵,属于方波型正交变换,不同之处在于其行、列次序不一样。

一维哈达玛变换

哈达玛变换要求空域矩阵阶数NN满足N=2nN=2^n,若满足,则有:F(μ)=x=0N1f(x)g(x,μ)F(\mu)=\sum_{x=0}^{N-1}f(x)g(x,\mu)g(x,μ)=1N(1)i=0n1bi(x)bi(μ)g(x,\mu)=\frac{1}{N}(-1)^{\sum_{i=0}^{n-1}b_i(x)b_{i}(\mu)}一维哈达玛反变换:f(x)=x=0N1F(μ)h(x,μ)f(x)=\sum_{x=0}^{N-1}F(\mu)h(x,\mu)h(x,μ)=(1)i=0n1bi(x)bi(μ)h(x,\mu)=(-1)^{\sum_{i=0}^{n-1}b_i(x)b_{i}(\mu)}bi(x)b_i(x)xx的二进制表达式中第ii位的意思

二维哈达玛变换

F(μ,ν)=1Nx=0N1x=0N1f(x,y)g(x,y,μ,ν)F(\mu,\nu)=\frac{1}{N}\sum_{x=0}^{N-1}\sum_{x=0}^{N-1}f(x,y)g(x,y,\mu,\nu)f(x,y)=1Nμ=0N1ν=0N1F(μ,ν)g(x,y,μ,ν)f(x,y)=\frac{1}{N}\sum_{\mu=0}^{N-1}\sum_{\nu=0}^{N-1}F(\mu,\nu)g(x,y,\mu,\nu)g(x,y,μ,ν)=G=1N(1)i=0n1[bi(x)bi(μ)+bi(y)bi(ν)]g(x,y,\mu,\nu)=G=\frac{1}{N}(-1)^{\sum_{i=0}^{n-1}[b_i(x)b_{i}(\mu)+b_i(y)b_{i}(\nu)]}二维哈达玛变换是可分离的,可变换为两个一维哈达玛变换来进行计算。

列率
在哈达玛矩阵中,沿列方向上符号改变的次数称为列率,类似傅立叶变换中频率的概念。

例如有矩阵H=[1111111111111111]H=\begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & -1 & 1 & -1\\ 1 & 1 & -1 & -1 \\ 1 & -1 & -1 & 1\\ \end{bmatrix}
其第一列元素符号无变化,于是第一列的列率为0;
第二列a12a_{12}a22a_{22}符号由正变负、a22a_{22}a32a_{32}符号由负变正、a32a_{32}a42a_{42}符号由正变负,共改变3次,因此第二列的列率为3;以此类推,第三列的列率为1,第四列的列率为2

哈达玛变换在列率上是随机的,不利于实现逐次倍加法的快速运算,但是能导出一个简单的递推关系,构造其变换矩阵,而后进行哈达玛正向和反向变换

哈达玛变换核矩阵
在满足N=2nN=2^n的情况下
有最低阶N=2N=2时的哈达玛变换矩阵H2H_2为:H2=[1111]H_2=\begin{bmatrix} 1 & 1 \\ 1 & -1 \\ \end{bmatrix}有任意阶N=2NN=2N时的哈达玛矩阵为:H2N=[HNHNHNHN]H_{2N}=\begin{bmatrix} H_N & H_N \\ H_N & -H_N \\ \end{bmatrix}由此可推得:H4=[H2H2H2H2],H8=[H4H4H4H4],...H_{4}=\begin{bmatrix} H_2 & H_2 \\ H_2 & -H_2 \\ \end{bmatrix},H_{8}=\begin{bmatrix} H_4 & H_4 \\ H_4 & -H_4 \\ \end{bmatrix},...
将哈达玛矩阵按照列率顺序排列,得到定序的哈达玛变换对为:F(μ,ν)=1Nx=0N1x=0N1f(x,y)g(x,y,μ,ν)F(\mu,\nu)=\frac{1}{N}\sum_{x=0}^{N-1}\sum_{x=0}^{N-1}f(x,y)g(x,y,\mu,\nu)f(x,y)=1Nμ=0N1ν=0N1F(μ,ν)g(x,y,μ,ν)f(x,y)=\frac{1}{N}\sum_{\mu=0}^{N-1}\sum_{\nu=0}^{N-1}F(\mu,\nu)g(x,y,\mu,\nu)g(x,y,μ,ν)=G=1N(1)i=0n1[bi(x)pi(μ)+bi(y)pi(ν)]g(x,y,\mu,\nu)=G=\frac{1}{N}(-1)^{\sum_{i=0}^{n-1}[b_i(x)p_{i}(\mu)+b_i(y)p_{i}(\nu)]}其中p0(μ)=bn1(μ)pi(μ)=bni(μ)+bn1i(μ)\begin{aligned} p_0(\mu) & = b_{n-1}(\mu) \\ p_i(\mu) & = b_{n-i}(\mu)+b_{n-1-i}(\mu) \\ \end{aligned}表达为矩阵形式为F=1N2HfHF=\frac{1}{N^2}HfHf=HFHf=HFH

实例:求离散哈达玛变换f=[1331133113311331]f=\begin{bmatrix} 1 & 3 & 3 & 1 \\ 1 & 3 & 3 & 1 \\ 1 & 3 & 3 & 1 \\ 1 & 3 & 3 & 1 \\ \end{bmatrix}易知N=4N=4,其哈达玛变换核矩阵为:H4=[H2H2H2H2]=[1111111111111111]H_{4}=\begin{bmatrix} H_2 & H_2 \\ H_2 & -H_2 \\ \end{bmatrix}=\begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & -1 & 1 & -1\\ 1 & 1 & -1 & -1 \\ 1 & -1 & -1 & 1\\ \end{bmatrix}H4H_4按列率排序后得到H4=[1111111111111111]H_4=\begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 1 & -1 & -1\\ 1 & -1 & -1 & 1 \\ 1 & -1 & 1 & -1\\ \end{bmatrix}由此按照哈达玛变换的计算公式可得F=1N2H4fH4=[2010000000000000]F=\frac{1}{N^2}H_4fH_4=\begin{bmatrix} 2 & 0 & -1 & 0 \\ 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0\\ \end{bmatrix}

将沃尔什变换与哈达玛变换进行对比可以发现,两个变换的结果之间只是矩阵列的顺序不同,不会影响两者应用于压缩时的效率

2015-05-02 11:16:53 fztfztfzt 阅读数 3083
  1. /*************************************************************************
  2. *
  3. * 函数名称:
  4. * WALSH()
  5. *
  6. * 参数:
  7. * double* f - 输入的时域序列
  8. * double* F - 输出的频域序列
  9. * int r - 2的幂数
  10. *
  11. * 返回值:
  12. * BOOL - 成功返回TRUE,否则返回FALSE。
  13. *
  14. * 说明:
  15. * 该函数进行一维快速沃尔什——哈达马变换。
  16. *
  17. ************************************************************************/
  18. void WALSH(double*f,double*F,int r);
  19. /*************************************************************************
  20. *
  21. * 函数名称:
  22. * IWALSH()
  23. *
  24. * 参数:
  25. * double* f - 输入的时域序列
  26. * double* F - 输出的频域序列
  27. * int r - 2的幂数
  28. *
  29. * 返回值:
  30. * BOOL - 成功返回TRUE,否则返回FALSE。
  31. *
  32. * 说明:
  33. * 该函数进行一维快速沃尔什——哈达马逆变换。
  34. *
  35. ************************************************************************/
  36. void IWALSH(double*F,double*f,int r);
  37. /*************************************************************************
  38. *
  39. * 函数名称:
  40. * FreqWALSH()
  41. *
  42. * 参数:
  43. * double* f - 输入的时域序列
  44. * double* F - 输出的频域序列
  45. * LONG width - 图象宽度
  46. * LONG height - 图象高度
  47. *
  48. * 返回值:
  49. * BOOL - 成功返回TRUE,否则返回FALSE。
  50. *
  51. * 说明:
  52. * 该函数进行二维快速沃尔什——哈达玛变换。
  53. *
  54. ************************************************************************/
  55. BOOL FreqWALSH(double*f,double*F, LONG width, LONG height);
  56. /*************************************************************************
  57. *
  58. * 函数名称:
  59. * IFreqWALSH()
  60. *
  61. * 参数:
  62. * double* f - 输入的时域序列
  63. * double* F - 输出的频域序列
  64. * LONG width - 图象宽度
  65. * LONG height - 图象高度
  66. *
  67. * 返回值:
  68. * BOOL - 成功返回TRUE,否则返回FALSE。
  69. *
  70. * 说明:
  71. * 该函数进行二维快速沃尔什——哈达玛逆变换。
  72. *
  73. ************************************************************************/
  74. BOOL IFreqWALSH(double*f,double*F, LONG width, LONG height);
  75. /*************************************************************************
  76. *
  77. * 函数名称:
  78. * BmpWalsh()
  79. *
  80. * 参数:
  81. * BYTE* bmp,LONG width,LONG height
  82. *
  83. * 返回值:
  84. * BOOL - 成功返回TRUE,否则返回FALSE。
  85. *
  86. * 说明:
  87. * 该函数对图象进行二维快速沃尔什——哈达马变换。
  88. *
  89. ************************************************************************/
  90. BOOL BmpWalsh(BYTE* bmp,LONG width,LONG height);
  1. voidMyProcess::WALSH(double*f,double*F,int r)
  2. {
  3. // 循环变量
  4. LONG i;
  5. LONG j;
  6. LONG k;
  7. // 中间变量
  8. int p;
  9. double* X;
  10. // 计算快速沃尔什变换点数
  11. LONG N =1<< r;
  12. // 分配运算所需的数组
  13. double* X1 =newdouble[N];
  14. double* X2 =newdouble[N];
  15. // 将时域点写入数组X1
  16. memcpy(X1, f,sizeof(double)* N);
  17. // 蝶形运算
  18. for(k =0; k < r; k++)
  19. {
  20. for(j =0; j <1<<k; j++)
  21. {
  22. for(i =0; i <1<<(r - k -1); i++)
  23. {
  24. p = j *(1<<(r - k));
  25. X2[i + p]= X1[i + p]+ X1[i + p +(int)(1<<(r - k -1))];
  26. X2[i + p +(int)(1<<(r - k -1))]= X1[i + p]- X1[i + p +(int)(1<<(r - k -1))];
  27. }
  28. }
  29. // 互换X1和X2
  30. X = X1;
  31. X1 = X2;
  32. X2 = X;
  33. }
  34. // 调整系数
  35. for(j =0; j < N; j++)
  36. {
  37. p =0;
  38. for(i =0; i < r; i++)
  39. {
  40. if(j &(1<<i))
  41. {
  42. p +=1<<(r - i -1);
  43. }
  44. }
  45. F[j]= X1[p]/ N;
  46. }
  47. // 释放内存
  48. delete X1;
  49. delete X2;
  50. }
  51. voidMyProcess::IWALSH(double*F,double*f,int r)
  52. {
  53. // 循环变量
  54. int i;
  55. // 计算变换点数
  56. LONG N =1<< r;
  57. // 调用快速沃尔什-哈达玛变换进行反变换
  58. WALSH(F, f, r);
  59. // 调整系数
  60. for(i =0; i < N; i++)
  61. f[i]*= N;
  62. }
  63. BOOL MyProcess::FreqWALSH(double*f,double*F, LONG width, LONG height)
  64. {
  65. // 循环变量
  66. LONG i;
  67. LONG j;
  68. LONG k;
  69. // 进行离散余弦变换的宽度和高度(2的整数次方)
  70. LONG w =1;
  71. LONG h =1;
  72. int wp =0;
  73. int hp =0;
  74. // 计算进行离散余弦变换的宽度和高度(2的整数次方)
  75. while(w < width/3)
  76. {
  77. w *=2;
  78. wp++;
  79. }
  80. while(h < height)
  81. {
  82. h *=2;
  83. hp++;
  84. }
  85. // 分配内存
  86. double*TempIn=newdouble[h];
  87. double*TempOut=newdouble[h];
  88. // 对y方向进行离散余弦变换
  89. for(i =0; i < w *3; i++)
  90. {
  91. // 抽取数据
  92. for(j =0; j < h; j++)
  93. TempIn[j]= f[j * w *3+ i];
  94. // 一维快速离散余弦变换
  95. WALSH(TempIn,TempOut, hp);
  96. // 保存变换结果
  97. for(j =0; j < h; j++)
  98. f[j * w *3+ i]=TempOut[j];
  99. }
  100. // 释放内存
  101. deleteTempIn;
  102. deleteTempOut;
  103. // 分配内存
  104. TempIn=newdouble[w];
  105. TempOut=newdouble[w];
  106. // 对x方向进行快速离散余弦变换
  107. for(i =0; i < h; i++)
  108. {
  109. for(k =0; k <3; k++)
  110. {
  111. // 抽取数据
  112. for(j =0; j < w; j++)
  113. TempIn[j]= f[i * w *3+ j *3+ k];
  114. // 一维快速离散余弦变换
  115. WALSH(TempIn,TempOut, wp);
  116. // 保存变换结果
  117. for(j =0; j < w; j++)
  118. F[i * w *3+ j *3+ k]=TempOut[j];
  119. }
  120. }
  121. // 释放内存
  122. deleteTempIn;
  123. deleteTempOut;
  124. return TRUE;
  125. }
  126. BOOL MyProcess::IFreqWALSH(double*f,double*F, LONG width, LONG height)
  127. {
  128. // 循环变量
  129. LONG i;
  130. LONG j;
  131. LONG k;
  132. // 赋初值
  133. LONG w =1;
  134. LONG h =1;
  135. int wp =0;
  136. int hp =0;
  137. // 计算进行付立叶变换的宽度和高度(2的整数次方)
  138. while(w < width/3)
  139. {
  140. w *=2;
  141. wp++;
  142. }
  143. while(h < height)
  144. {
  145. h *=2;
  146. hp++;
  147. }
  148. // 分配内存
  149. double*TempIn=newdouble[w];
  150. double*TempOut=newdouble[w];
  151. // 对x方向进行快速付立叶变换
  152. for(i =0; i < h; i++)
  153. {
  154. for(k =0; k <3; k++)
  155. {
  156. // 抽取数据
  157. for(j =0; j < w; j++)
  158. TempIn[j]= F[i * w *3+ j *3+ k];
  159. // 一维快速傅立叶变换
  160. IWALSH(TempIn,TempOut, wp);
  161. // 保存变换结果
  162. for(j =0; j < w; j++)
  163. F[i * w *3+ j *3+ k]=TempOut[j];
  164. }
  165. }
  166. // 释放内存
  167. deleteTempIn;
  168. deleteTempOut;
  169. TempIn=newdouble[h];
  170. TempOut=newdouble[h];
  171. // 对y方向进行快速付立叶变换
  172. for(i =0; i < w *3; i++)
  173. {
  174. // 抽取数据
  175. for(j =0; j < h; j++)
  176. TempIn[j]= F[j * w *3+ i];
  177. // 一维快速傅立叶变换
  178. IWALSH(TempIn,TempOut, hp);
  179. // 保存变换结果
  180. for(j =0; j < h; j++)
  181. F[j * w *3+ i]=TempOut[j];
  182. }
  183. // 释放内存
  184. deleteTempIn;
  185. deleteTempOut;
  186. for(i =0; i < h; i++)
  187. {
  188. for(j =0; j < w *3; j++)
  189. {
  190. if(i < height && j < width)
  191. *(f + i * width + j)= F[i * w *3+ j];
  192. }
  193. }
  194. return TRUE;
  195. }
  196. BOOL MyProcess::BmpWalsh(BYTE* bmp,LONG width,LONG height)
  197. {
  198. // 循环变量
  199. LONG i;
  200. LONG j;
  201. // 进行沃尔什——哈达玛变换的宽度和高度(2的整数次方)
  202. LONG w =1;
  203. LONG h =1;
  204. int wp =0;
  205. int hp =0;
  206. // 计算进行离散余弦变换的宽度和高度(2的整数次方)
  207. while(w < width/3)
  208. {
  209. w *=2;
  210. wp++;
  211. }
  212. while(h < height)
  213. {
  214. h *=2;
  215. hp++;
  216. }
  217. // 分配内存
  218. double*f =newdouble[w * h *3];
  219. double*F =newdouble[w * h *3];
  220. // 向时域赋值并补零
  221. for(i =0; i < h; i++)
  222. {
  223. for(j =0; j < w *3; j++)
  224. {
  225. if(i < height && j < width)
  226. f[i * w *3+ j]= bmp[width * i + j];
  227. else
  228. f[w * i *3+ j]=0.0f;
  229. }
  230. }
  231. // 进行频谱分析
  232. if(FreqWALSH(f, F,width, height)== FALSE)
  233. return FALSE;
  234. // 更新所有象素
  235. for(i =0; i < height; i++)
  236. {
  237. for(j =0; j < width; j++)
  238. {
  239. // 判断是否超过255
  240. if(fabs(F[i * w *3+ j]*1000)>255)
  241. {
  242. // 对于超过的,直接设置为255
  243. bmp[width *(height -1- i)+ j]=255;
  244. }
  245. else
  246. {
  247. // 如果没有超过,则按实际计算结果赋值
  248. bmp[width *(height -1- i)+ j]= fabs(F[i * w *3+ j]*1000);
  249. }
  250. }
  251. }
  252. //释放内存
  253. delete[] f;
  254. delete[] F;
  255. // 返回
  256. return TRUE;
  257. }

2019-09-06 00:46:34 zhuhaodonglei 阅读数 125

图像处理
    图像分类
        单通道图像
            二值图像
            灰度图像
        多通道图像
            索引图像
            彩色图像
    常用方法
        图像变换
            傅立叶变换
            沃尔什变换
            离散余弦变换
            小波变换
        图像编码压缩
            对图像施加某种变换或基于区域、特征进行编码的方法
            最常用的无损压缩算法取空间或时间上相邻像素值的差,再进行编码。如游程码。
            有损压缩算法大都采用图像交换的途径,例如对图像进行快速傅里叶变换或离散的余弦变换。
        图像增强
            空间域
                一些平滑去噪的方法:局部求平均值法和中值滤波
                灰度等级直方图处理
            频域
                低通滤波器可以滤除噪声
                高通滤波器可以增强边缘信息
        图像复原
            图像复原要求对图像降质的原因有一定的了解,一般讲应根据降质过程建立“降质模型”,再采用某种滤波方法,恢复或重建原来的图像。
        图像分割
            传统方法用到连通域,连通域的问题在于阈值的选择
        图像描述
            主要使用深度学习来解决
        图像分类
            参考
                https://blog.csdn.net/jiaoyangwm/article/details/79120601
            步骤
                特征提取
                特征编码
                特征汇聚
                分类器
                    支持向量机
                    K 近邻
                    神经网络
                    随机森林
        检测
            直线检测:霍夫变换
            边缘检测
                参考
                    https://blog.csdn.net/u013270326/article/details/81412566
                算子
                    Sobel
                    Roberts
                    Laplacian
                    Canny
        特征提取
            参考:https://blog.csdn.net/Assure_zhang/article/details/80503196
    神经网络发展
        贝叶斯网络
        SVN(支持向量机)
        BP:反向传播进行参数调整网络
        CNN:卷积神经网络
        RNN:循环神经网络

2019-06-11 17:53:34 tyfwin 阅读数 744

 

图像处理中有许多变换常常选用方波信号或者它的变形。

沃尔什函数是一组矩形波,其取值为1和-1,非常便于计算机运算。

沃尔什函数有三种排列或编号方式以哈达玛排列最便于快速计算。

采用哈达玛排列的沃尔什函数进行的变换称为沃尔什-哈达玛变换,简称WHT或直称哈达玛变换。

 

沃尔什函数

沃尔什函数有三种不同的函数定义,但都可由拉德梅克函数构成。

1、按沃尔什排列的沃尔什函数

其中,R(k+1,t)是任意拉德梅克函数,g(i)是i的格雷码, g(i)k是此格雷码的第k位数。P为正整数,

 

取样后得到的按沃尔什排列的沃尔什函数矩阵:

2、按佩利(Paley)排列的沃尔什函数

其中,R(k+1,t)是任意拉德梅克函数,ik是自然二进制码的第k位数。P为正整数,。    

取样后得到的按佩利排列的沃尔什函数矩阵:     

 

3、按哈达玛(Hadamard)排列的沃尔什函数

其中,R(k+1,t)是任意拉德梅克函数,<ik>是倒序的二进制码的第k位数。P为正整数,。        

取样后得到的按哈达玛排列的沃尔什函数矩阵:

   

2^n阶哈达玛矩阵有如下形式:

 

可见,哈达玛矩阵的最大优点在于它具有简单的递推关系, 即高阶矩阵可用两个低阶矩阵的克罗内克积(Kronecker Product)求得。因此常采用哈达玛排列定义的沃尔什变换。

 

离散沃尔什-哈达玛变换(DWHT)

      

式中,[Hn]为N阶哈达玛矩阵。

由哈达玛矩阵的特点可知,沃尔什-哈达玛变换的本质上是将离散序列f(x)的各项值的符号按一定规律改变后,进行加减运算, 因此,它比采用复数运算的DFT和采用余弦运算的DCT要简单得多

从以上例子可看出,二维WHT具有能量集中的特性,而且原始数据中数字越是均匀分布,经变换后的数据越集中于矩阵的边角上。因此,二维WHT可用于压缩图像信息。

 

快速沃尔什变换(FWHT)

类似于FFT,WHT也有快速算法FWHT, 也可将输入序列f(x)按奇偶进行分组,分别进行WHT。FWHT的基本关系为:

WHT是将一个函数变换成取值为+1或-1的基本函数构成的级数,用它来逼近数字脉冲信号时要比FFT有利。同时, WHT只需要进行实数运算,存储量比FFT要少得多, 运算速度也快得多。因此,WHT在图像传输、 通信技术和数据压缩中被广泛使用。

 

 

2019-07-25 21:37:15 Arthur_Holmes 阅读数 204

实函数的要求已经达到,但是偶函数的要求比较难

假定具有这种对称性,真实情况比会有误差,但是误差可以忽略不计

余弦变换因为只有实变换,所以只有单个幅频谱,而且显然比傅里叶变换更加集中(并且在一个点,而不是四个点)

JPG等都用的是余弦变换

为什么分成小块,因为大块大大增加运算量

 

MATLAB调用demo

哈达玛变换是对离散余弦变换的近似,所以比离散余弦的集中特性要差一点

 

 

 

 

 

图像处理方法

阅读数 556

没有更多推荐了,返回首页