Category

Development Platform
Home > SourceCode/Document > Graph program > Special Effects > View Code
WvltTransDib2.cpp
Package: tuxiang.rar　[view]
Upload User: szkelitina
Upload Date: 2022-05-21
Package Size: 6797k
Code Size: 20k
Category:

Special Effects

Development Platform:

Visual C++

WvltTransDib2.cpp：Code Content
  1. // WvltTrans.cpp: implementation of the CWvltTrans class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "windowsx.h"
  7. #include "math.h"
  9. #include "MainFrm.h"
  10. #include "DynSplitView2.h"
  11. //#include "wavelets.h"
  12. //#include "DIP_System.h"
  13. #include "WvltTransDib.h"
  15. #ifdef _DEBUG
  16. #undef THIS_FILE
  17. static char THIS_FILE[]=__FILE__;
  18. #define new DEBUG_NEW
  19. #endif
  21. //////////////////////////////////////////////////////////////////////
  22. // Construction/Destruction
  23. //////////////////////////////////////////////////////////////////////
  25. CWvltTransDib::CWvltTransDib()
  26. {
  27. layer1=FALSE;
  28. layer2=FALSE;
  29. layer3=FALSE;
  30. }
  32. CWvltTransDib::~CWvltTransDib()
  33. {
  35. }
  37. void CWvltTransDib::Hangbianhuan()
  38. {
  39. int i,j;
  40. LONG width,height;
  41. BYTE r, g, b;
  42. LPBYTE temp1, temp2;
  43. float tpBuffer;
  44. short maxVal,minVal,difVal;
  46. width=this->GetWidth();
  47. height=this->GetHeight();
  48. int nWidth=width/2;
  49. LONG lLineBytes = (width*3+3)/4 *4;
  50. //分配临时数据空间
  51. temp1 = new BYTE[height*width];
  52. temp2 = new BYTE[height*width];
  54. //从设备缓存中获得原始图像数据
  55. for(j=0; j<(int)height; j++)
  56. {
  57. for( i=0; i<(int)width; i++)
  58. {
  59. b=m_pData[j*lLineBytes+3*i];
  60. g=m_pData[j*lLineBytes+3*i+1];
  61. r=m_pData[j*lLineBytes+3*i+2];
  62. temp1[(height-1-j)*width+i]=(BYTE)(0.3*r+0.59*g+0.11*b);  
  63. }
  64. }
  66.     for(j = 0; j < height; j ++)            
  67. {
  68. for(i = 0; i < nWidth; i ++)           
  69. {
  70. int w = i *2;
  71. temp2[j*width+i] = temp1[j*width+w]; //偶
  72. temp2[j*width+nWidth+i] = temp1[j*width+w+1]; //奇
  73. }
  74. }
  75. //通过图像的差分，完成小波变换
  76. for(j=0; j<height; j++)
  77. {
  78. for(i=0; i<nWidth-1; i++)
  79. {
  80. temp2[j*width+nWidth+i] = temp2[j*width+nWidth+i] -temp2[j*width+i]+128;
  81. }
  82. }
  84. maxVal=temp2[0*width+0];
  85. minVal=temp2[0*width+0];
  86. //得到图像小波系数的极大值与极小值
  87. for( j=0; j<(int)height; j++)
  88. {
  89. for( i=0; i<(int)width; i++)
  90. {
  91. if(maxVal<temp2[j*width+i])
  92. maxVal=temp2[j*width+i];
  93. if(minVal>temp2[j*width+i])
  94. minVal=temp2[j*width+i];
  95. }
  96. }
  97. //计算获取图像小波系数的极值差
  98. difVal=maxVal-minVal;
  99. //小波经过处理后，放入显示缓存中
  100.     for(j=0; j<(int)height; j++)
  101. {
  102. for(i=0; i<(int)width; i++)
  103. {
  104. //因为小波变换后的小波系数有可能超过255甚至更多，那么就将
  105. //小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的
  106. tpBuffer=temp2[(height-1-j)*width+i];
  107. tpBuffer-=minVal;
  108. tpBuffer*=255;
  109. tpBuffer/=difVal;
  110. m_pData[j*lLineBytes+3*i]  = (BYTE)tpBuffer;
  111. m_pData[j*lLineBytes+3*i+1]= (BYTE)tpBuffer;
  112. m_pData[j*lLineBytes+3*i+2]= (BYTE)tpBuffer;
  113. }
  114. }
  115. //删除临时的数据空间
  116. delete temp1;
  117. delete temp2;
  119. }
  121. void CWvltTransDib::Liebianhuan()
  122. {
  123. int i,j;
  124. LONG width,height;
  125. BYTE r, g, b;
  126. LPBYTE temp1, temp2;
  127. float tpBuffer;
  128. short maxVal,minVal,difVal;
  130. width=this->GetWidth();
  131. height=this->GetHeight();
  132. int nHeight=height/2;
  133. LONG lLineBytes = (width*3+3)/4 *4;
  134. //分配临时数据空间
  135. temp1 = new BYTE[height*width];
  136. temp2 = new BYTE[height*width];
  138. //从设备缓存中获得原始图像数据
  139. for(j=0; j<(int)height; j++)
  140. {
  141. for( i=0; i<(int)width; i++)
  142. {
  143. b=m_pData[j*lLineBytes+3*i];
  144. g=m_pData[j*lLineBytes+3*i+1];
  145. r=m_pData[j*lLineBytes+3*i+2];
  146. temp1[(height-1-j)*width+i]=(BYTE)(0.3*r+0.59*g+0.11*b);  
  147. }
  148. }
  150. for(i = 0; i < width; i ++)            
  151. {
  152. for(j = 0; j < nHeight; j ++)           
  153. {
  154. int h = j *2 ;
  155. temp2[j*width+i] = temp1[h*width+i]; //even
  156. temp2[(nHeight + j)*width+i] = temp1[(h+1)*width+i]; //odd
  157. }
  158. }
  160. //通过图像的差分，完成小波变换
  161. for(i=0; i<width; i++)
  162. {
  163. for(j=0; j<nHeight-1; j++)
  164. {
  165. temp2[(nHeight + j)*width+i] -= temp2[j*width+i]+128;
  166. }
  167. }
  169. maxVal=temp2[0*width+0];
  170. minVal=temp2[0*width+0];
  171. //得到图像小波系数的极大值与极小值
  172. for( j=0; j<(int)height; j++)
  173. {
  174. for( i=0; i<(int)width; i++)
  175. {
  176. if(maxVal<temp2[j*width+i])
  177. maxVal=temp2[j*width+i];
  178. if(minVal>temp2[j*width+i])
  179. minVal=temp2[j*width+i];
  180. }
  181. }
  182. //计算获取图像小波系数的极值差
  183. difVal=maxVal-minVal;
  184. //小波经过处理后，放入显示缓存中
  185.     for(j=0; j<(int)height; j++)
  186. {
  187. for(i=0; i<(int)width; i++)
  188. {
  189. //因为小波变换后的小波系数有可能超过255甚至更多，那么就将
  190. //小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的
  191. tpBuffer=temp2[(height-1-j)*width+i];
  192. tpBuffer-=minVal;
  193. tpBuffer*=255;
  194. tpBuffer/=difVal;
  195. m_pData[j*lLineBytes+3*i]  = (BYTE)tpBuffer;
  196. m_pData[j*lLineBytes+3*i+1]= (BYTE)tpBuffer;
  197. m_pData[j*lLineBytes+3*i+2]= (BYTE)tpBuffer;
  198. }
  199. }
  200. //删除临时的数据空间
  201. delete temp1;
  202. delete temp2;
  203. }
  205. void CWvltTransDib::Once()
  206. {
  207. // Hangbianhuan();
  208. // Liebianhuan();
  209. int i,j;
  210. LONG width,height,nWidth,nHeight;
  211. BYTE r, g, b;
  212. LPBYTE temp1, temp2,temp3;
  213. float tpBuffer;
  214. short maxVal,minVal,difVal;
  216. width=this->GetWidth();
  217. height=this->GetHeight();
  218. nWidth=width/2;
  219. nHeight=height/2;
  220. LONG lLineBytes = (width*3+3)/4 *4;
  221. //分配临时数据空间
  222. temp1 = new BYTE[height*width];
  223. temp2 = new BYTE[height*width];
  224. temp3 = new BYTE[height*width];
  226. //从设备缓存中获得原始图像数据
  227. for(j=0; j<(int)height; j++)
  228. {
  229. for( i=0; i<(int)width; i++)
  230. {
  231. b=m_pData[j*lLineBytes+3*i];
  232. g=m_pData[j*lLineBytes+3*i+1];
  233. r=m_pData[j*lLineBytes+3*i+2];
  234. temp1[(height-1-j)*width+i]=(BYTE)(0.3*r+0.59*g+0.11*b);  
  235. }
  236. }
  238.     for(j = 0; j < height; j ++)            
  239. {
  240. for(i = 0; i < nWidth; i ++)           
  241. {
  242. int w = i *2;
  243. temp2[j*width+i] = temp1[j*width+w]; //偶
  244. temp2[j*width+nWidth+i] = temp1[j*width+w+1]; //奇
  245. }
  246. }
  247. //通过图像的差分，完成小波变换
  248. for(j=0; j<height; j++)
  249. {
  250. for(i=0; i<nWidth-1; i++)
  251. {
  252. temp2[j*width+nWidth+i] -= temp2[j*width+i]+128;
  253. }
  254. }
  256. for(i=0;i<nWidth;i++)
  257. {
  258. for(j=0;j<nHeight;j++)
  259. {
  260. int h=j*2;
  261. temp3[j*width+i]=temp2[h*width+i];//左上
  262. temp3[(j+nHeight)*width+i]=temp2[(h+1)*width+i];//左下
  263. temp3[j*width+nWidth+i]=temp2[h*width+nWidth+i];//右上
  264. temp3[(j+nWidth)*width+nWidth+i]=temp2[(h+1)*width+nWidth+i];//右下
  265. }
  266. for(j=0;j<nHeight;j++)
  267. {
  268. temp3[(j+nHeight)*width+i]-= temp3[j*width+i]+128;
  269. temp3[(j+nHeight)*width+nWidth+i]-= temp3[j*width+nWidth+i]+128;
  270. }
  271. }
  273. maxVal=temp3[0*width+0];
  274. minVal=temp3[0*width+0];
  275. //得到图像小波系数的极大值与极小值
  276. for( j=0; j<(int)height; j++)
  277. {
  278. for( i=0; i<(int)width; i++)
  279. {
  280. if(maxVal<temp3[j*width+i])
  281. maxVal=temp3[j*width+i];
  282. if(minVal>temp3[j*width+i])
  283. minVal=temp3[j*width+i];
  284. }
  285. }
  286. //计算获取图像小波系数的极值差
  287. difVal=maxVal-minVal;
  288. //小波经过处理后，放入显示缓存中
  289.     for(j=0; j<(int)height; j++)
  290. {
  291. for(i=0; i<(int)width; i++)
  292. {
  293. //因为小波变换后的小波系数有可能超过255甚至更多，那么就将
  294. //小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的
  295. tpBuffer=temp3[(height-1-j)*width+i];
  296. tpBuffer-=minVal;
  297. tpBuffer*=255;
  298. tpBuffer/=difVal;
  299. m_pData[j*lLineBytes+3*i]  = (BYTE)tpBuffer;
  300. m_pData[j*lLineBytes+3*i+1]= (BYTE)tpBuffer;
  301. m_pData[j*lLineBytes+3*i+2]= (BYTE)tpBuffer;
  302. }
  303. }
  304. //删除临时的数据空间
  305. delete temp1;
  306. delete temp2;
  307. delete temp3;
  308. layer1=TRUE;
  309. }
  311. void CWvltTransDib::Twice()
  312. {
  313. Once();
  314. int i,j;
  315. LONG width,height,nWidth,nHeight;
  316. BYTE r, g, b;
  317. LPBYTE temp1, temp2,temp3;
  318. float tpBuffer;
  319. short maxVal,minVal,difVal;
  321. width=this->GetWidth()/2;
  322. height=this->GetHeight()/2;
  323. nWidth=width/2;
  324. nHeight=height/2;
  325. LONG lLineBytes = (this->GetWidth()*3+3)/4 *4;
  326. //分配临时数据空间
  327. temp1 = new BYTE[height*width];
  328. temp2 = new BYTE[height*width];
  329. temp3 = new BYTE[height*width];
  331. //从设备缓存中获得原始图像数据
  332. for(j=0; j<(int)height; j++)
  333. {
  334. for( i=0; i<(int)width; i++)
  335. {
  336. b=m_pData[(j+height)*lLineBytes+3*i];
  337. g=m_pData[(j+height)*lLineBytes+3*i+1];
  338. r=m_pData[(j+height)*lLineBytes+3*i+2];
  339. temp1[(height-1-j)*width+i]=(BYTE)(0.3*r+0.59*g+0.11*b);  
  340. }
  341. }
  343.     for(j = 0; j < height; j ++)            
  344. {
  345. for(i = 0; i < nWidth; i ++)           
  346. {
  347. int w = i *2;
  348. temp2[j*width+i] = (temp1[j*width+w]); //偶
  349. temp2[j*width+nWidth+i] = (temp1[j*width+w+1]); //奇
  350. }
  351. }
  352. //通过图像的差分，完成小波变换
  353. for(j=0; j<height; j++)
  354. {
  355. for(i=0; i<nWidth-1; i++)
  356. {
  357. temp2[j*width+nWidth+i] -= temp2[j*width+i]+128;
  358. }
  359. }
  361. for(i=0;i<nWidth;i++)
  362. {
  363. for(j=0;j<nHeight;j++)
  364. {
  365. int h=j*2;
  366. temp3[j*width+i]=temp2[h*width+i];//左上
  367. temp3[(j+nHeight)*width+i]=temp2[(h+1)*width+i];//左下
  368. temp3[j*width+nWidth+i]=temp2[h*width+nWidth+i];//右上
  369. temp3[(j+nWidth)*width+nWidth+i]=temp2[(h+1)*width+nWidth+i];//右下
  370. }
  371. for(j=0;j<nHeight;j++)
  372. {
  373. temp3[(j+nHeight)*width+i]-= temp3[j*width+i]+128;
  374. temp3[(j+nHeight)*width+nWidth+i]-= temp3[j*width+nWidth+i]+128;
  375. }
  376. }
  378. maxVal=temp3[0*width+0];
  379. minVal=temp3[0*width+0];
  380. //得到图像小波系数的极大值与极小值
  381. for( j=0; j<(int)height; j++)
  382. {
  383. for( i=0; i<(int)width; i++)
  384. {
  385. if(maxVal<temp3[j*width+i])
  386. maxVal=temp3[j*width+i];
  387. if(minVal>temp3[j*width+i])
  388. minVal=temp3[j*width+i];
  389. }
  390. }
  391. //计算获取图像小波系数的极值差
  392. difVal=maxVal-minVal;
  393. //小波经过处理后，放入显示缓存中
  394.     for(j=0; j<(int)height; j++)
  395. {
  396. for(i=0; i<(int)width; i++)
  397. {
  398. //因为小波变换后的小波系数有可能超过255甚至更多，那么就将
  399. //小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的
  400. tpBuffer=temp3[(height-1-j)*width+i];
  401. tpBuffer-=minVal;
  402. tpBuffer*=255;
  403. tpBuffer/=difVal;
  404. m_pData[(j+height)*lLineBytes+3*i]  = (BYTE)tpBuffer;
  405. m_pData[(j+height)*lLineBytes+3*i+1]= (BYTE)tpBuffer;
  406. m_pData[(j+height)*lLineBytes+3*i+2]= (BYTE)tpBuffer;
  407. }
  408. }
  409. //删除临时的数据空间
  410. delete temp1;
  411. delete temp2;
  412. delete temp3;
  413. layer2=TRUE;
  414. }
  416. void CWvltTransDib::Thrice()
  417. {
  418. Twice();
  419. int i,j;
  420. LONG width,height,nWidth,nHeight;
  421. BYTE r, g, b;
  422. LPBYTE temp1, temp2,temp3;
  423. float tpBuffer;
  424. short maxVal,minVal,difVal;
  426. width=this->GetWidth()/4;
  427. height=this->GetHeight()/4;
  428. nWidth=width/2;
  429. nHeight=height/2;
  430. LONG lLineBytes = (this->GetWidth()*3+3)/4 *4;
  431. //分配临时数据空间
  432. temp1 = new BYTE[height*width];
  433. temp2 = new BYTE[height*width];
  434. temp3 = new BYTE[height*width];
  436. //从设备缓存中获得原始图像数据
  437. for(j=0; j<(int)height; j++)
  438. {
  439. for( i=0; i<(int)width; i++)
  440. {
  441. b=m_pData[(j+height*3)*lLineBytes+3*i];
  442. g=m_pData[(j+height*3)*lLineBytes+3*i+1];
  443. r=m_pData[(j+height*3)*lLineBytes+3*i+2];
  444. temp1[(height-1-j)*width+i]=(BYTE)(0.3*r+0.59*g+0.11*b);  
  445. }
  446. }
  448.     for(j = 0; j < height; j ++)            
  449. {
  450. for(i = 0; i < nWidth; i ++)           
  451. {
  452. int w = i *2;
  453. temp2[j*width+i] = (temp1[j*width+w]); //偶
  454. temp2[j*width+nWidth+i] = (temp1[j*width+w+1]); //奇
  455. }
  456. }
  457. //通过图像的差分，完成小波变换
  458. for(j=0; j<height; j++)
  459. {
  460. for(i=0; i<nWidth-1; i++)
  461. {
  462. temp2[j*width+nWidth+i] -= temp2[j*width+i]+128;
  463. }
  464. }
  466. for(i=0;i<nWidth;i++)
  467. {
  468. for(j=0;j<nHeight;j++)
  469. {
  470. int h=j*2;
  471. temp3[j*width+i]=temp2[h*width+i];//左上
  472. temp3[(j+nHeight)*width+i]=temp2[(h+1)*width+i];//左下
  473. temp3[j*width+nWidth+i]=temp2[h*width+nWidth+i];//右上
  474. temp3[(j+nWidth)*width+nWidth+i]=temp2[(h+1)*width+nWidth+i];//右下
  475. }
  476. for(j=0;j<nHeight;j++)
  477. {
  478. temp3[(j+nHeight)*width+i]-= temp3[j*width+i]+128;
  479. temp3[(j+nHeight)*width+nWidth+i]-= temp3[j*width+nWidth+i]+128;
  480. }
  481. }
  483. maxVal=temp3[0*width+0];
  484. minVal=temp3[0*width+0];
  485. //得到图像小波系数的极大值与极小值
  486. for( j=0; j<(int)height; j++)
  487. {
  488. for( i=0; i<(int)width; i++)
  489. {
  490. if(maxVal<temp3[j*width+i])
  491. maxVal=temp3[j*width+i];
  492. if(minVal>temp3[j*width+i])
  493. minVal=temp3[j*width+i];
  494. }
  495. }
  496. //计算获取图像小波系数的极值差
  497. difVal=maxVal-minVal;
  498. //小波经过处理后，放入显示缓存中
  499.     for(j=0; j<(int)height; j++)
  500. {
  501. for(i=0; i<(int)width; i++)
  502. {
  503. //因为小波变换后的小波系数有可能超过255甚至更多，那么就将
  504. //小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的
  505. tpBuffer=temp3[(height-1-j)*width+i];
  506. tpBuffer-=minVal;
  507. tpBuffer*=255;
  508. tpBuffer/=difVal;
  509. m_pData[(j+height*3)*lLineBytes+3*i]  = (BYTE)tpBuffer;
  510. m_pData[(j+height*3)*lLineBytes+3*i+1]= (BYTE)tpBuffer;
  511. m_pData[(j+height*3)*lLineBytes+3*i+2]= (BYTE)tpBuffer;
  512. }
  513. }
  514. //删除临时的数据空间
  515. delete temp1;
  516. delete temp2;
  517. delete temp3;
  518. layer3=TRUE;
  519. }
  521. void CWvltTransDib::IDWT()
  522. {
  523. if ((layer1==TRUE)||(layer2==TRUE)||(layer3==TRUE))
  524. {
  525. if(layer3)
  526. IDWT_Thrice();
  527. if(layer2)
  528. IDWT_Twice();
  529. if(layer1)
  530. IDWT_Once();
  531. }
  532. else
  533. AfxMessageBox("请先做小波变换。",MB_OK,NULL);
  534. }
  536. void CWvltTransDib::IDWT_Once()
  537. {
  538. int i,j;
  539. LONG width,height,nWidth,nHeight;
  540. BYTE r, g, b;
  541. LPBYTE temp1, temp2,temp3;
  542. float tpBuffer;
  543. short maxVal,minVal,difVal;
  545. width=this->GetWidth();
  546. height=this->GetHeight();
  547. nWidth=width/2;
  548. nHeight=height/2;
  549. LONG lLineBytes = (width*3+3)/4 *4;
  550. //分配临时数据空间
  551. temp1 = new BYTE[height*width];
  552. temp2 = new BYTE[height*width];
  553. temp3 = new BYTE[height*width];
  555. memset(temp1,0,height*width);
  556. memset(temp2,0,height*width);
  557. memset(temp3,0,height*width);
  559. //从设备缓存中获得原始图像数据
  560. for(j=0; j<(int)height; j++)
  561. {
  562. for( i=0; i<(int)width; i++)
  563. {
  564. b=m_pData[j*lLineBytes+3*i];
  565. g=m_pData[j*lLineBytes+3*i+1];
  566. r=m_pData[j*lLineBytes+3*i+2];
  567. temp1[(height-1-j)*width+i]=(BYTE)(0.3*r+0.59*g+0.11*b);  
  568. }
  569. }
  571. for(j=0; j<nHeight; j++)
  572. {
  573. for( i=0; i<width; i++)
  574. {
  575. int h=j*2;
  576. temp2[h*width+i]=temp1[j*width+i];
  577. temp2[(h+1)*width+i]=temp1[j*width+i]+temp1[(j+nHeight)*width+i]-128;
  578. }
  579. }
  581. for( i=0; i<nWidth-1; i++)
  582. {
  583. for(j=0; j<height; j++)
  584. {
  585. int w=i*2;
  586. temp3[j*width+w]=temp2[j*width+i];
  587. temp3[j*width+w+1]=temp2[j*width+i]+temp2[j*width+nWidth+i]-128;
  588. }
  589. }
  591. maxVal=temp3[0*width+0];
  592. minVal=temp3[0*width+0];
  593. //得到图像小波系数的极大值与极小值
  594. for( j=0; j<(int)height; j++)
  595. {
  596. for( i=0; i<(int)width; i++)
  597. {
  598. if(maxVal<temp3[j*width+i])
  599. maxVal=temp3[j*width+i];
  600. if(minVal>temp3[j*width+i])
  601. minVal=temp3[j*width+i];
  602. }
  603. }
  604. //计算获取图像小波系数的极值差
  605. difVal=maxVal-minVal;
  606. //小波经过处理后，放入显示缓存中
  607.     for(j=0; j<(int)height; j++)
  608. {
  609. for(i=0; i<(int)width; i++)
  610. {
  611. //因为小波变换后的小波系数有可能超过255甚至更多，那么就将
  612. //小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的
  613. tpBuffer=temp3[(height-1-j)*width+i];
  614. tpBuffer-=minVal;
  615. tpBuffer*=255;
  616. tpBuffer/=difVal;
  617. m_pData[j*lLineBytes+3*i]  = (BYTE)tpBuffer;
  618. m_pData[j*lLineBytes+3*i+1]= (BYTE)tpBuffer;
  619. m_pData[j*lLineBytes+3*i+2]= (BYTE)tpBuffer;
  620. }
  621. }
  622. //删除临时的数据空间
  623. delete temp1;
  624. delete temp2;
  625. delete temp3;
  626. layer1=FALSE;
  627. }
  629. void CWvltTransDib::IDWT_Twice()
  630. {
  631. int i,j;
  632. LONG width,height,nWidth,nHeight;
  633. BYTE r, g, b;
  634. LPBYTE temp1, temp2,temp3;
  635. float tpBuffer;
  636. short maxVal,minVal,difVal;
  638. width=this->GetWidth()/2;
  639. height=this->GetHeight()/2;
  640. nWidth=width/2;
  641. nHeight=height/2;
  642. LONG lLineBytes = (this->GetWidth()*3+3)/4 *4;
  643. //分配临时数据空间
  644. temp1 = new BYTE[height*width];
  645. temp2 = new BYTE[height*width];
  646. temp3 = new BYTE[height*width];
  648. memset(temp1,0,height*width);
  649. memset(temp2,0,height*width);
  650. memset(temp3,0,height*width);
  652. //从设备缓存中获得原始图像数据
  653. for(j=0; j<(int)height; j++)
  654. {
  655. for( i=0; i<(int)width; i++)
  656. {
  657. b=m_pData[(j+height)*lLineBytes+3*i];
  658. g=m_pData[(j+height)*lLineBytes+3*i+1];
  659. r=m_pData[(j+height)*lLineBytes+3*i+2];
  660. temp1[(height-1-j)*width+i]=(BYTE)(0.3*r+0.59*g+0.11*b);  
  661. }
  662. }
  664. for(j=0; j<nHeight; j++)
  665. {
  666. for( i=0; i<width; i++)
  667. {
  668. int h=j*2;
  669. temp2[h*width+i]=temp1[j*width+i];
  670. temp2[(h+1)*width+i]=temp1[j*width+i]+temp1[(j+nHeight)*width+i]-128;
  671. }
  672. }
  674. for( i=0; i<nWidth-1; i++)
  675. {
  676. for(j=0; j<height; j++)
  677. {
  678. int w=i*2;
  679. temp3[j*width+w]=temp2[j*width+i];
  680. temp3[j*width+w+1]=temp2[j*width+i]+temp2[j*width+nWidth+i]-128;
  681. }
  682. }
  684. maxVal=temp3[0*width+0];
  685. minVal=temp3[0*width+0];
  686. //得到图像小波系数的极大值与极小值
  687. for( j=0; j<(int)height; j++)
  688. {
  689. for( i=0; i<(int)width; i++)
  690. {
  691. if(maxVal<temp3[j*width+i])
  692. maxVal=temp3[j*width+i];
  693. if(minVal>temp3[j*width+i])
  694. minVal=temp3[j*width+i];
  695. }
  696. }
  697. //计算获取图像小波系数的极值差
  698. difVal=maxVal-minVal;
  699. //小波经过处理后，放入显示缓存中
  700.     for(j=0; j<(int)height; j++)
  701. {
  702. for(i=0; i<(int)width; i++)
  703. {
  704. //因为小波变换后的小波系数有可能超过255甚至更多，那么就将
  705. //小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的
  706. tpBuffer=temp3[(height-1-j)*width+i];
  707. tpBuffer-=minVal;
  708. tpBuffer*=255;
  709. tpBuffer/=difVal;
  710. m_pData[(j+height)*lLineBytes+3*i]  = (BYTE)tpBuffer;
  711. m_pData[(j+height)*lLineBytes+3*i+1]= (BYTE)tpBuffer;
  712. m_pData[(j+height)*lLineBytes+3*i+2]= (BYTE)tpBuffer;
  713. }
  714. }
  715. //删除临时的数据空间
  716. delete temp1;
  717. delete temp2;
  718. delete temp3;
  719. layer2=FALSE;
  720. }
  722. void CWvltTransDib::IDWT_Thrice()
  723. {
  724. int i,j;
  725. LONG width,height,nWidth,nHeight;
  726. BYTE r, g, b;
  727. LPBYTE temp1, temp2,temp3;
  728. float tpBuffer;
  729. short maxVal,minVal,difVal;
  731. width=this->GetWidth()/4;
  732. height=this->GetHeight()/4;
  733. nWidth=width/2;
  734. nHeight=height/2;
  735. LONG lLineBytes = (this->GetWidth()*3+3)/4 *4;
  736. //分配临时数据空间
  737. temp1 = new BYTE[height*width];
  738. temp2 = new BYTE[height*width];
  739. temp3 = new BYTE[height*width];
  741. memset(temp1,0,height*width);
  742. memset(temp2,0,height*width);
  743. memset(temp3,0,height*width);
  745. //从设备缓存中获得原始图像数据
  746. for(j=0; j<(int)height; j++)
  747. {
  748. for( i=0; i<(int)width; i++)
  749. {
  750. b=m_pData[(j+height*3)*lLineBytes+3*i];
  751. g=m_pData[(j+height*3)*lLineBytes+3*i+1];
  752. r=m_pData[(j+height*3)*lLineBytes+3*i+2];
  753. temp1[(height-1-j)*width+i]=(BYTE)(0.3*r+0.59*g+0.11*b);  
  754. }
  755. }
  757. for(j=0; j<nHeight; j++)
  758. {
  759. for( i=0; i<width; i++)
  760. {
  761. int h=j*2;
  762. temp2[h*width+i]=temp1[j*width+i];
  763. temp2[(h+1)*width+i]=temp1[j*width+i]+temp1[(j+nHeight)*width+i]-128;
  764. }
  765. }
  767. for( i=0; i<nWidth-1; i++)
  768. {
  769. for(j=0; j<height; j++)
  770. {
  771. int w=i*2;
  772. temp3[j*width+w]=temp2[j*width+i];
  773. temp3[j*width+w+1]=temp2[j*width+i]+temp2[j*width+nWidth+i]-128;
  774. }
  775. }
  777. maxVal=temp3[0*width+0];
  778. minVal=temp3[0*width+0];
  779. //得到图像小波系数的极大值与极小值
  780. for( j=0; j<(int)height; j++)
  781. {
  782. for( i=0; i<(int)width; i++)
  783. {
  784. if(maxVal<temp3[j*width+i])
  785. maxVal=temp3[j*width+i];
  786. if(minVal>temp3[j*width+i])
  787. minVal=temp3[j*width+i];
  788. }
  789. }
  790. //计算获取图像小波系数的极值差
  791. difVal=maxVal-minVal;
  792. //小波经过处理后，放入显示缓存中
  793.     for(j=0; j<(int)height; j++)
  794. {
  795. for(i=0; i<(int)width; i++)
  796. {
  797. //因为小波变换后的小波系数有可能超过255甚至更多，那么就将
  798. //小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的
  799. tpBuffer=temp3[(height-1-j)*width+i];
  800. tpBuffer-=minVal;
  801. tpBuffer*=255;
  802. tpBuffer/=difVal;
  803. m_pData[(j+height*3)*lLineBytes+3*i]  = (BYTE)tpBuffer;
  804. m_pData[(j+height*3)*lLineBytes+3*i+1]= (BYTE)tpBuffer;
  805. m_pData[(j+height*3)*lLineBytes+3*i+2]= (BYTE)tpBuffer;
  806. }
  807. }
  808. //删除临时的数据空间
  809. delete temp1;
  810. delete temp2;
  811. delete temp3;
  812. layer3=FALSE;
  813. }
  815. void CWvltTransDib::LowFilter()
  816. {
  817. int i,j;
  818. LONG width,height,nWidth,nHeight;
  819. width=this->GetWidth();
  820. height=this->GetHeight();
  821. nWidth=width/2;
  822. nHeight=height/2;
  823. LONG lLineBytes = (width*3+3)/4 *4;
  825. Once();
  826. for(j=0;j<height;j++)
  827. {
  828. for(i=0;i<width;i++)
  829. {
  830. if(!((i<nWidth)&&(j>nHeight)))
  831. {
  832. m_pData[j*lLineBytes+3*i]  = (BYTE)128;
  833. m_pData[j*lLineBytes+3*i+1]= (BYTE)128;
  834. m_pData[j*lLineBytes+3*i+2]= (BYTE)128;
  835. }
  836. }
  837. }
  838. IDWT_Once();
  840. }
  842. void CWvltTransDib::HighFilter()
  843. {
  844. int i,j;
  845. LONG width,height,nWidth,nHeight;
  846. width=this->GetWidth();
  847. height=this->GetHeight();
  848. nWidth=width/2;
  849. nHeight=height/2;
  850. LONG lLineBytes = (width*3+3)/4 *4;
  852. Once();
  853. for(j=0;j<height;j++)
  854. {
  855. for(i=0;i<width;i++)
  856. {
  857. if((i<nWidth)&&(j>nHeight))
  858. {
  859. m_pData[j*lLineBytes+3*i]  = (BYTE)128;
  860. m_pData[j*lLineBytes+3*i+1]= (BYTE)128;
  861. m_pData[j*lLineBytes+3*i+2]= (BYTE)128;
  862. }
  863. }
  864. }
  865. IDWT_Once();
  866. }