开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 波变换 > 查看源码
DWT.CPP
资源名称：Image_Processing.rar　[点击查看]
上传用户：wangchdtw
上传日期：2014-04-02
资源大小：329k
文件大小：11k
源码类别：

波变换

开发平台：

Visual C++

DWT.CPP：源码内容
  1. // 文件DWT.cpp存放的是有关小波变换的函数
  3. #include "stdafx.h"
  4. #include "cdib.h"
  5. #include "math.h"
  6. #include "GlobalApi.h"
  9. /*************************************************************************
  10.  *
  11.  * 函数名称：
  12.  *   DWT_1D()
  13.  *
  14.  * 输入参数:
  15.  *   double * pDbSrc - 指向源数据的指针
  16.  *   int nMaxLevel - 最大可分解的层数
  17.  *   int nDWTSteps - 需要分界的层数
  18.  *   int nInv - 是否为DWT，1表示为IDWT，0表示DWT
  19.  *   int nStep - 当前的计算层数
  20.  *   int nSupp - 小波基的紧支集的长度
  21.  *
  22.  * 返回值:
  23.  *   BOOL - 成功则返回TRUE，否则返回FALSE
  24.  *
  25.  * 说明:
  26.  *   该函数用对存放在pDBSrc中的数据进行一维DWT或者IDWT。其中，nInv为表示进行
  27.  *   DWT或者IDWT的标志。nStep为当前已经分界的层数。计算后数据仍存放在pDbSrc中
  28.  *
  29.  *************************************************************************
  30.  */
  31. BOOL DWT_1D(double* pDbSrc, int nMaxLevel,
  32. int nDWTSteps, int nInv, int nStep, int nSupp )
  33. {
  34. // 计算最小可分界的层数
  35. int MinLevel = nMaxLevel-nDWTSteps;
  37. // 判断是否为DWT
  38. if (!nInv)
  39. { // DWT
  40. int n = nMaxLevel;
  42. while (n>MinLevel)
  43. // 调用DWTStep_1D进行第n层的DWT
  44. if (!DWTStep_1D(pDbSrc, n--, nInv, nStep, nSupp)) 
  45. return FALSE;
  46. }
  48. // nInv为1则进行IDWT
  49. else
  50. { // IDWT
  51. int n = MinLevel;
  53. while (n<nMaxLevel)
  54. // 调用DWTStep_1D进行第n层的IDWT
  55. if (!DWTStep_1D(pDbSrc, n++, nInv, nStep, nSupp)) 
  56. return FALSE;
  57. }
  58. return TRUE;
  59. }
  61. /*************************************************************************
  62.  *
  63.  * 函数名称：
  64.  *   DWTStep_1D()
  65.  *
  66.  * 输入参数:
  67.  *   double * pDbSrc - 指向源数据的指针
  68.  *   int nCurLevel - 当前分界的层数
  69.  *   int nInv - 是否为DWT，1表示为IDWT，0表示DWT
  70.  *   int nStep - 当前的计算层数
  71.  *   int nSupp - 小波基的紧支集的长度
  72.  *
  73.  * 返回值:
  74.  *   BOOL - 成功则返回TRUE，否则返回FALSE
  75.  *
  76.  * 说明:
  77.  *   该函数用对存放在pDBSrc中的数据进行一层的一维DWT或者IDWT。其中，nInv为表示进行
  78.  *   DWT或者IDWT的标志。nCurLevel为当前需要进行分界的层数。nStep为已经分界的层数
  79.  *   计算后数据仍存放在pDbSrc中
  80.  *
  81.  *************************************************************************
  82.  */
  83. BOOL DWTStep_1D(double* pDbSrc, int nCurLevel,
  84. int nInv, int nStep,int nSupp)
  85. {
  86. double s = sqrt(2);
  88. // 获得小波基的指针
  89. double* h = (double*)hCoef[nSupp-1];
  91. // 确认当前层数有效
  92. ASSERT(nCurLevel>=0);
  94. // 计算当前层数的长度
  95. int CurN = 1<<nCurLevel;
  96. if (nInv) CurN <<= 1;
  98. // 确认所选择的小波基和当前层数的长度有效
  99. if (nSupp<1 || nSupp>10 || CurN<2*nSupp) 
  100. return FALSE;
  102. // 分配临时内存用于存放结果
  103. double *ptemp = new double[CurN];
  104. if (!ptemp) return FALSE;
  106. double s1, s2;
  107. int Index1, Index2;
  109. // 判断是进行DWT还是IDWT
  110. if (!nInv)
  111. { // DWT
  112. Index1=0;
  113. Index2=2*nSupp-1;
  115. // 进行卷积，其中s1为低频部分，s2为高频部分的结果
  116. for (int i=0; i<CurN/2; i++)
  117. {
  118. s1 = s2 = 0;
  119. double t = -1;
  120. for (int j=0; j<2*nSupp; j++, t=-t)
  121. {
  122. s1 += h[j]*pDbSrc[(Index1 & CurN-1) * nStep];
  123. s2 += t*h[j]*pDbSrc[(Index2 & CurN-1) * nStep];
  125. Index1++;
  126. Index2--;
  127. }
  129. // 将结果存放在临时内存中
  130. ptemp[i] = s1/s;
  131. ptemp[i+CurN/2] = s2/s;
  133. Index1 -= 2*nSupp;
  134. Index2 += 2*nSupp;
  135. Index1 += 2;
  136. Index2 += 2;
  137. }
  138. }
  140. // 否则进行IDWT
  141. else
  142. { // IDWT
  143. Index1 = CurN/2;
  144. Index2 = CurN/2-nSupp+1;
  146. // 进行卷积，其中其中s1为低频部分，s2为高频部分的结果
  147. for (int i=0; i<CurN/2; i++)
  148. {
  149. s1 = s2 = 0;
  150. int Index3 = 0;
  151. for (int j=0; j<nSupp; j++)
  152. {
  153. s1 += h[Index3]*pDbSrc[(Index1 & CurN/2-1) * nStep]
  154.  +h[Index3+1]*pDbSrc[((Index2 & CurN/2-1) + CurN/2) * nStep];
  155. s2 += h[Index3+1]*pDbSrc[(Index1 & CurN/2-1) * nStep]
  156.  -h[Index3]*pDbSrc[((Index2 & CurN/2-1) + CurN/2) * nStep];
  158. Index3+=2;
  159. Index1--, Index2++;
  160. }
  162. // 将结果存入临时内存
  163. ptemp[2*i] = s1*s;
  164. ptemp[2*i+1] = s2*s;
  166. Index1 += nSupp;
  167. Index2 -= nSupp;
  168. Index1++;
  169. Index2++;
  170. }
  171. }
  173. // 将结果存入源图象中
  174. for (int i=0; i<CurN; i++)
  175. pDbSrc[i*nStep] = ptemp[i];
  177. // 释放临时内存，并返回
  178. delete[] ptemp;
  179. return TRUE;
  180. }
  182. /*************************************************************************
  183.  *
  184.  * 函数名称：
  185.  *   DWT_2D()
  186.  *
  187.  * 输入参数:
  188.  *   double * pDbSrc - 指向源数据的指针
  189.  *   int nMaxWLevel - X方向最大可分解的层数
  190.  *   int nMaxHLevel - Y方向最大可分解的层数
  191.  *   int nDWTSteps - 需要分界的层数
  192.  *   int nInv - 是否为DWT，1表示为IDWT，0表示DWT
  193.  *   int nStep - 当前的计算层数
  194.  *   int nSupp - 小波基的紧支集的长度
  195.  *
  196.  * 返回值:
  197.  *   BOOL - 成功则返回TRUE，否则返回FALSE
  198.  *
  199.  * 说明:
  200.  *   该函数用对存放在pDBSrc中的二维数据进行二维DWT或者IDWT。其中，nDWTSteps表示
  201.  *   需要分解的层数，nInv为表示进行DWT或者IDWT的标志。nStep为当前已经分界的层数
  202.  *   计算后数据仍存放在pDbSrc中
  203.  *
  204.  *************************************************************************
  205.  */
  206. BOOL DWT_2D(double* pDbSrc, int nMaxWLevel, int nMaxHLevel,
  207. int nDWTSteps, int nInv, int nStep, int nSupp)
  208. {
  209. // 计算X，Y方向上最小的分界层数
  210. int MinWLevel = nMaxWLevel - nDWTSteps;
  211. int MinHLevel = nMaxHLevel - nDWTSteps;
  213. // 判断是进行DWT，还是IDWT
  214. if (!nInv)
  215. { // DWT
  216. int n = nMaxWLevel, m = nMaxHLevel;
  218. // 调用DWTStep_2D进行分解，分解的层数为nDWTSteps
  219. while (n>MinWLevel)
  220. if (!DWTStep_2D(pDbSrc, n--, m--, nMaxWLevel, nMaxHLevel, nInv, nStep, nSupp)) 
  221. return FALSE;
  222. }
  224. // 否则进行IDWT
  225. else
  226. { // IDWT
  227. int n = MinWLevel, m = MinHLevel;
  229. // 调用DWTStep_2D进行IDWT，进行恢复的层数为nDWTSteps
  230. while (n<nMaxWLevel)
  231. if (!DWTStep_2D(pDbSrc, n++, m++, nMaxWLevel, nMaxHLevel, nInv, nStep, nSupp)) 
  232. return FALSE;
  233. }
  235. // 返回
  236. return TRUE;
  237. }
  239. /*************************************************************************
  240.  *
  241.  * 函数名称：
  242.  *   DWTStep_2D()
  243.  *
  244.  * 输入参数:
  245.  *   double * pDbSrc - 指向源数据的指针
  246.  *   int nCurWLevel - X方向上当前分解的层数
  247.  *   int nCurHLevel - Y方向上当前分解的层数
  248.  *   int nMaxWLevel - X方向上最大可分解的层数
  249.  *   int nMaxHLevel - Y方向上最大可分解的层数
  250.  *   int nInv - 是否为DWT，1表示为IDWT，0表示DWT
  251.  *   int nStep - 当前的计算层数
  252.  *   int nSupp - 小波基的紧支集的长度
  253.  *
  254.  * 返回值:
  255.  *   BOOL - 成功则返回TRUE，否则返回FALSE
  256.  *
  257.  * 说明:
  258.  *   该函数用对存放在pDBSrc中的数据进行一层的二维DWT或者IDWT。
  259.  *   计算后数据仍存放在pDbSrc中
  260.  *
  261.  *************************************************************************
  262.  */
  263. BOOL DWTStep_2D(double* pDbSrc, int nCurWLevel, int nCurHLevel,
  264. int nMaxWLevel, int nMaxHLevel, int nInv, int nStep, int nSupp)
  265. {
  266. // 计算图象的长度和宽度（2次幂对齐）
  267. int W = 1<<nMaxWLevel, H = 1<<nMaxHLevel;
  269. // 计算当前分解的图象的长度和宽度
  270. int CurW = 1<<nCurWLevel, CurH = 1<<nCurHLevel;
  272. // 判断是进行DWT还是IDWT
  273. if (!nInv)
  274. { // 对行进行一维DWT
  275. for (int i=0; i<CurH; i++)
  276. if (!DWTStep_1D(pDbSrc+(int)i*W*nStep, nCurWLevel, nInv, nStep, nSupp)) return FALSE;
  277. // 对列进行一维DWT
  278. for (i=0; i<CurW; i++)
  279. if (!DWTStep_1D(pDbSrc+i*nStep, nCurHLevel, nInv, W*nStep, nSupp)) return FALSE;
  280. }
  282. // 否则进行IDWT
  283. else
  284. {
  285. // 计算当前变换的图象的长度和宽度
  286. CurW <<= 1;
  287. CurH <<= 1;
  289. // 对列进行IDWT
  290. for (int i=0; i<CurW; i++)
  291. if (!DWTStep_1D(pDbSrc+i*nStep, nCurHLevel, nInv, W*nStep, nSupp)) return FALSE;
  292. // 对行进行IDWT
  293. for (i=0; i<CurH; i++)
  294. if (!DWTStep_1D(pDbSrc+(int)i*W*nStep, nCurWLevel, nInv, nStep, nSupp)) return FALSE;
  295. }
  297. // 返回
  298. return TRUE;
  299. }
  302. /*************************************************************************
  303.  *
  304.  * 函数名称：
  305.  *   ImageDWT()
  306.  *
  307.  * 输入参数:
  308.  *   CDib* pDibSrc - 指向源数据的指针
  309.  *   int nMaxWLevel - X方向上最大可分解的层数
  310.  *   int nMaxHLevel - Y方向上最大可分解的层数
  311.  *   int nDWTSteps - 需要进行变换的层数
  312.  *   int nInv - 是否为DWT，1表示为IDWT，0表示DWT
  313.  *   int nStep - 当前的计算层数
  314.  *   int nSupp - 小波基的紧支集的长度
  315.  *
  316.  * 返回值:
  317.  *   BOOL - 成功则返回TRUE，否则返回FALSE
  318.  *
  319.  * 说明:
  320.  *   该函数用对存放在pDBSrc中的数据进行一层的二维DWT或者IDWT。
  321.  *   计算后数据仍存放在pDbSrc中
  322.  *
  323.  *************************************************************************
  324.  */
  325. BOOL ImageDWT(LPBYTE lpImage, int nMaxWLevel, int nMaxHLevel,
  326. int nDWTSteps, int nInv, int nStep, int nSupp)
  327. {
  328. // 判断变换的层数以及当前层数是否有效
  329. if (nDWTSteps>nMaxWLevel || nDWTSteps>nMaxHLevel || nStep<=0)
  330. return FALSE;
  332. // 获得X，Y方向上的最大象素数（2次幂对齐）
  333. int W = 1<<nMaxWLevel, H = 1<<nMaxHLevel;
  335. // 获得X，Y方向上变换时最小的象素数
  336. int minW = W>>nDWTSteps, minH = H>>nDWTSteps;
  338. int i, j, index;
  340. // 分配临时内存存放结果
  341. double* pDbTemp = new double[W*H];
  342. if (!pDbTemp) return FALSE;
  344. // 判断是进行DWT还是IDWT，然后将数据存放到临时内存中，需要注意的是，需要进行采样
  345. if (!nInv) // DWT
  346. for (index=0; index<W*H; index++) pDbTemp[index] = lpImage[index*nStep];
  347. else // IDWT
  348. {
  349. index = 0;
  350. for (i=0; i<minH; i++)
  351. {
  352. for (j=0; j<minW; j++, index++)
  353. pDbTemp[index] = lpImage[index*nStep];
  354. for (; j<W; j++, index++)
  355. pDbTemp[index] = (char)lpImage[index*nStep];
  356. }
  357. for (; index<W*H; index++)
  358. pDbTemp[index] = (char)lpImage[index*nStep];
  359. }
  361. // 调用DWT_2D进行小波变换
  362. if(!DWT_2D(pDbTemp, nMaxWLevel, nMaxHLevel, nDWTSteps, nInv, nStep, nSupp))
  363. {
  364. delete []pDbTemp;
  365. return FALSE;
  366. }
  368. // 将数据存入原始的内存中，需要注意的是，存储时需要进行类型转换
  369. if (!nInv) // DWT
  370. {
  371. index = 0;
  372. for (i=0; i<minH; i++)
  373. {
  374. for (j=0; j<minW; j++, index++)
  375. lpImage[index*nStep] = FloatToByte(pDbTemp[index]);
  376. for (; j<W; j++, index++)
  377. lpImage[index*nStep] = (BYTE)FloatToChar(pDbTemp[index]);
  378. // lpImage[index*nStep] = (BYTE)FloatToByte(pDbTemp[index]);
  379. }
  380. for (; index<W*H; index++)
  381. lpImage[index*nStep] = (BYTE)FloatToChar(pDbTemp[index]);
  382. //lpImage[index*nStep] = (BYTE)FloatToByte(pDbTemp[index]);
  383. }
  384. else // IDWT
  385. for (index=0; index<W*H; index++) 
  386. lpImage[index*nStep] = FloatToByte(pDbTemp[index]);
  388. // 释放内存
  389. delete []pDbTemp;
  391. // 返回
  392. return TRUE;
  393. }
  395. /*************************************************************************
  396.  *
  397.  * 函数名称：
  398.  *   FloatToByte()
  399.  *
  400.  * 输入参数:
  401.  *   double  f - 输入双精度变量
  402.  *
  403.  * 返回值:
  404.  *   BYTE - 返回比特型变量
  405.  *
  406.  * 说明:
  407.  *   该函数将输入的双精度变量转换为BYTE型的变量
  408.  *
  409.  *************************************************************************
  410.  */
  411. BYTE FloatToByte(double f)
  412. {
  413. if (f<=0) return (BYTE)0;
  414. else if (f>=255) return (BYTE)255;
  415. else return (BYTE)(f+0.5);
  416. }
  418. /*************************************************************************
  419.  *
  420.  * 函数名称：
  421.  *   FloatToChar()
  422.  *
  423.  * 输入参数:
  424.  *   double  f - 输入双精度变量
  425.  *
  426.  * 返回值:
  427.  *   Char - 返回字符变量
  428.  *
  429.  * 说明:
  430.  *   该函数将输入的双精度变量转换为Char型的变量
  431.  *
  432.  *************************************************************************
  433.  */
  434. char FloatToChar(double f)
  435. {
  436. if (f>=0)
  437. if (f>=127.0)
  438. return (char)127;
  439. else return (char)(f+0.5);
  440. else
  441. if (f<=-128)
  442. return (char)-128;
  443. else return -(char)(-f+0.5);
  444. }
  446. /*************************************************************************
  447.  *
  448.  * 函数名称：
  449.  *   Log2()
  450.  *
  451.  * 输入参数:
  452.  *   int  n - 输入整型变量
  453.  *
  454.  * 返回值:
  455.  *   int - 返回输入参数的对数
  456.  *
  457.  * 说明:
  458.  *   该函数求取输入参数的以2为底的对数，并转换为整型输出。
  459.  *
  460.  *************************************************************************
  461.  */
  462. int Log2(int n)
  463. {
  464. int rsl = 0;
  465. while (n >>= 1) rsl++;
  466. return rsl;
  467. }