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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图形图像处理 > 查看源码
restore.cpp
资源名称：VC_ImageProcessing.rar　[点击查看]
上传用户：panpan8800
上传日期：2013-06-29
资源大小：274k
文件大小：21k
源码类别：

图形图像处理

开发平台：

Visual C++

restore.cpp：源码内容
  1. // ************************************************************************
  2. //  文件名：restore.cpp
  3. //
  4. //  图像复原API函数库：
  5. //
  6. //  DIBNoRestriction() - 图像模糊
  7. //  DIBInverseFilter() - 图像逆滤波复原
  8. //  DIBNoiseDegeneration() - 图像模糊加噪
  9. //  DIBWinnerFilter() - 图像维纳滤波
  10. // DIBMotionDegeneration() - 图像运动模糊
  11. // DIBMotionRestore() - 图像运动模糊复原
  12. //
  13. // *************************************************************************
  16. #include "stdafx.h"
  17. #include "GlobalApi.h"
  18. #include "Cdib.h"
  20. #include <math.h>
  21. #include <direct.h>
  22. #include <complex>
  23. using namespace std;
  25. #define SWAP(a,b) tempr=(a);(a)=(b);(b)=tempr
  27. /*************************************************************************
  28.  *
  29.  * 函数名称：
  30.  *   DIBNoRestriction()
  31.  *
  32.  * 参数:
  33.  *   CDib  *pDib       - 指向CDib类的指针
  34.  *
  35.  * 返回值:
  36.  *   BOOL               - 成功返回TRUE，否则返回FALSE。
  37.  *
  38.  * 说明:
  39.  *   该函数用来对DIB图像进行模糊操作。
  40.  *
  41.  ************************************************************************/
  43. BOOL WINAPI DIBNoRestriction(CDib *pDib)
  44. {
  45. // 指向源图像的指针
  46. BYTE * lpSrc;
  48. //图象的宽度和高度
  49. LONG    lWidth;
  50. LONG    lHeight;
  52. // 图像每行的字节数
  53. LONG lLineBytes;
  55. //得到图象的宽度和高度
  56. CSize   SizeDim;
  57. SizeDim = pDib->GetDimensions();
  58. lWidth  = SizeDim.cx;
  59. lHeight = SizeDim.cy;
  61. //得到实际的Dib图象存储大小
  62. CSize   SizeRealDim;
  63. SizeRealDim = pDib->GetDibSaveDim();
  65. // 计算图像每行的字节数
  66. lLineBytes = SizeRealDim.cx;
  68. //图像数据的指针
  69. LPBYTE  lpDIBBits = pDib->m_lpImage;
  71. //循环变量
  72. long i;
  73. long j;
  75. //临时变量
  76. double temp;
  78. // 实际进行付立叶变换的宽度和高度
  79. LONG lW = 1;
  80. LONG lH = 1;
  82. int wp = 0;
  83. int hp = 0;
  85. // 保证离散傅立叶变换的宽度和高度为2的整数次方
  86. while(lW * 2 <= lLineBytes)
  87. {
  88. lW = lW * 2;
  89. wp++;
  90. }
  92. while(lH * 2 <= lHeight)
  93. {
  94. lH = lH * 2;
  95. hp++;
  96. }
  98. //用来存储源图象和变换核的时域数据
  99. complex<double> *pCTSrc,*pCTH;
  101. //用来存储源图象和变换核的频域数据
  102. complex<double>  *pCFSrc,*pCFH;
  104. //图像归一化因子
  105. double MaxNum;
  107. //输入图象的长和宽必须为2的整数倍
  108. if(lW != (int) lLineBytes)
  109. {
  110. return false;
  111. }
  113. if(lH != (int) lHeight)
  114. {
  115. return false;
  116. }
  118. // 为时域和频域的数组分配空间
  119. pCTSrc = new complex<double> [lHeight*lLineBytes];
  120. pCTH   = new complex<double> [lHeight*lLineBytes];
  122. pCFSrc = new complex<double> [lHeight*lLineBytes];
  123. pCFH   = new complex<double> [lHeight*lLineBytes];
  125. // 将数据存入时域数组
  126. for (j = 0; j < lHeight; j++)
  127. {
  128. for(i = 0; i < lLineBytes; i++)
  129. {
  130. // 指向源图像倒数第j行，第i个象素的指针
  131. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  133. pCTSrc[ lLineBytes*j + i ] = complex<double>((double)*lpSrc , 0);
  134. pCFSrc[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  136. if(i < 5 && j < 5)
  137. {
  138. pCTH[ lLineBytes*j + i ] = complex<double>(0.04 , 0.0);
  139. }
  140. else
  141. {
  142. pCTH[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  143. }
  144. pCFH[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  145. }
  146. }
  148. //对源图像进行FFT
  149. ::DIBFFT_2D(pCTSrc, lLineBytes, lHeight, pCFSrc);
  151. //对变换核图像进行FFT
  152. ::DIBFFT_2D(pCTH, lLineBytes, lHeight, pCFH);
  154. //频域相乘
  155. for (i = 0;i <lHeight*lLineBytes;i++)
  156. {
  157. pCFSrc[i] = pCFSrc[i]*pCFH[i];
  158. }
  160. //对结果图像进行反FFT
  161. IFFT_2D(pCFSrc, pCTSrc, lLineBytes, lHeight);
  163. //确定归一化因子
  164. MaxNum = 0.0;
  165. for (j = 0;j < lHeight ;j++)
  166. {
  167. for(i = 0;i < lLineBytes ;i++)
  168. {
  169. temp = sqrt(pCTSrc[ lLineBytes*j + i ].real() * pCTSrc[ lLineBytes*j + i ].real()
  170. +pCTSrc[lLineBytes*j + i ].imag() * pCTSrc[ lLineBytes*j +i].imag());
  172. //选择归一化因子
  173. if( MaxNum < temp)
  174. MaxNum = temp;
  175. }
  176. }
  178. //转换为图像
  179. for (j = 0;j < lHeight ;j++)
  180. {
  181. for(i = 0;i < lLineBytes ;i++)
  182. {
  183. // 指向源图像倒数第j行，第i个象素的指针
  184.   lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  186. *lpSrc = (unsigned char) (pCTSrc[(lLineBytes)*j + i].real()*255.0/MaxNum);
  187. }
  188. }
  190. //释放存储空间
  191. delete pCTSrc;
  192. delete pCTH;
  194. delete pCFSrc;
  195. delete pCFH;
  197. // 返回
  198. return true;
  199. }
  201. /*************************************************************************
  202.  *
  203.  * 函数名称：
  204.  *   DIBInverseFilter()
  205.  *
  206.  * 参数:
  207.  *   CDib  *pDib       - 指向CDib类的指针
  208.  *
  209.  * 返回值:
  210.  *   BOOL               - 成功返回TRUE，否则返回FALSE
  211.  *
  212.  * 说明:
  213.  *   该函数用来对DIBNoRestriction()生成的DIB图像进行复原操作。
  214.  *
  215.  ************************************************************************/
  217. BOOL WINAPI DIBInverseFilter (CDib *pDib)
  218. {
  220.     // 指向源图像的指针
  221. BYTE * lpSrc;
  223. //图象的宽度和高度
  224. LONG    lWidth;
  225. LONG    lHeight;
  227. // 图像每行的字节数
  228. LONG lLineBytes;
  230. //得到图象的宽度和高度
  231. CSize   SizeDim;
  232. SizeDim = pDib->GetDimensions();
  233. lWidth  = SizeDim.cx;
  234. lHeight = SizeDim.cy;
  236. //得到实际的Dib图象存储大小
  237. CSize   SizeRealDim;
  238. SizeRealDim = pDib->GetDibSaveDim();
  240. // 计算图像每行的字节数
  241. lLineBytes = SizeRealDim.cx;
  243. //图像数据的指针
  244. LPBYTE  lpDIBBits = pDib->m_lpImage;
  246. //循环变量
  247. long i;
  248. long j;
  250. //临时变量
  251. double tempre, tempim, a, b, c, d;
  253. // 实际进行付立叶变换的宽度和高度
  254. LONG lW = 1;
  255. LONG lH = 1;
  257. int wp = 0;
  258. int hp = 0;
  260. // 保证离散傅立叶变换的宽度和高度为2的整数次方
  261. while(lW * 2 <= lLineBytes)
  262. {
  263. lW = lW * 2;
  264. wp++;
  265. }
  267. while(lH * 2 <= lHeight)
  268. {
  269. lH = lH * 2;
  270. hp++;
  271. }
  273. //用来存储源图象和变换核的时域数据
  274. complex<double> *pCTSrc,*pCTH;
  276. //用来存储源图象和变换核的频域数据
  277. complex<double>  *pCFSrc,*pCFH;
  279. //图像归一化因子
  280. double MaxNum;
  282. //输入退化图象的长和宽必须为2的整数倍
  283. if(lW != (int) lLineBytes)
  284. {
  285. return false;
  286. }
  288. if(lH != (int) lHeight)
  289. {
  290. return false;
  291. }
  293. // 为时域和频域的数组分配空间
  294. pCTSrc = new complex<double> [lHeight*lLineBytes];
  295. pCTH   = new complex<double> [lHeight*lLineBytes];
  297. pCFSrc = new complex<double> [lHeight*lLineBytes];
  298. pCFH   = new complex<double> [lHeight*lLineBytes];
  300. // 将退化图象数据存入时域数组
  301. for (j = 0; j < lHeight; j++)
  302. {
  303. for(i = 0; i < lLineBytes; i++)
  304. {
  305. // 指向退化图像倒数第j行，第i个象素的指针
  306. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  308. pCTSrc[ lLineBytes*j + i ] = complex<double>((double)*lpSrc , 0);
  309. pCFSrc[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  311. if(i < 5 && j < 5)
  312. {
  313. pCTH[ lLineBytes*j + i ] = complex<double>(0.04 , 0.0);
  314. }
  315. else
  316. {
  317. pCTH[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  318. }
  319. pCFH[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  320. }
  321. }
  323. //对退化图像进行FFT
  324. ::DIBFFT_2D(pCTSrc, lLineBytes, lHeight, pCFSrc);
  326. //对变换核图像进行FFT
  327. ::DIBFFT_2D(pCTH, lLineBytes, lHeight, pCFH);
  329. //频域相除
  330. for (i = 0;i <lHeight*lLineBytes;i++)
  331. {
  332. a = pCFSrc[i].real();
  333. b = pCFSrc[i].imag();
  334. c = pCFH[i].real();
  335. d = pCFH[i].imag();
  337. //如果频域值太小，不予考虑
  338. if (c*c + d*d > 1e-3)
  339. {
  340. tempre = ( a*c + b*d ) / ( c*c + d*d );
  341. tempim = ( b*c - a*d ) / ( c*c + d*d );
  342. }
  344. pCFSrc[i]= complex<double>(tempre , tempim);
  345. }
  347. //对复原图像进行反FFT
  348. IFFT_2D(pCFSrc, pCTSrc, lLineBytes, lHeight);
  350. //确定归一化因子
  351. MaxNum=300;
  353. //转换为复原图像
  354. for (j = 0;j < lHeight ;j++)
  355. {
  356. for(i = 0;i < lLineBytes ;i++)
  357. {
  358. // 指向复原图像倒数第j行，第i个象素的指针
  359.   lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  361. *lpSrc = (unsigned char) (pCTSrc[(lLineBytes)*j + i].real()*255.0/MaxNum);
  362. }
  363. }
  365. //释放存储空间
  366. delete pCTSrc;
  367. delete pCTH;
  369. delete pCFSrc;
  370. delete pCFH;
  372. // 返回
  373. return true;
  374. }
  376. /*************************************************************************
  377.  *
  378.  * 函数名称：
  379.  *   DIBNoiseDegeneration()
  380.  *
  381.  * 参数:
  382.  *   CDib  *pDib       - 指向CDib类的指针
  383.  *
  384.  * 返回值:
  385.  *   BOOL               - 模糊加噪操作成功返回TRUE，否则返回FALSE。
  386.  *
  387.  * 说明:
  388.  *   该函数用来对DIB图像进行模糊加噪操作。
  389.  *
  390.  ************************************************************************/
  392. BOOL WINAPI DIBNoiseDegeneration (CDib *pDib)
  393. {
  394. // 指向源图像的指针
  395. BYTE * lpSrc;
  397. //图象的宽度和高度
  398. LONG    lWidth;
  399. LONG    lHeight;
  401. // 图像每行的字节数
  402. LONG lLineBytes;
  404. //得到图象的宽度和高度
  405. CSize   SizeDim;
  406. SizeDim = pDib->GetDimensions();
  407. lWidth  = SizeDim.cx;
  408. lHeight = SizeDim.cy;
  410. //得到实际的Dib图象存储大小
  411. CSize   SizeRealDim;
  412. SizeRealDim = pDib->GetDibSaveDim();
  414. // 计算图像每行的字节数
  415. lLineBytes = SizeRealDim.cx;
  417. //图像数据的指针
  418. LPBYTE  lpDIBBits = pDib->m_lpImage;
  420. //循环变量
  421. long i;
  422. long j;
  424. //转换为图像，加噪
  425. unsigned char NoisePoint;
  427. //临时变量
  428. double temp;
  430. //图像归一化因子
  431. double MaxNum;
  433. // 实际进行付立叶变换的宽度和高度
  434. LONG lW = 1;
  435. LONG lH = 1;
  437. int wp = 0;
  438. int hp = 0;
  440. // 保证离散傅立叶变换的宽度和高度为2的整数次方
  441. while(lW * 2 <= lLineBytes)
  442. {
  443. lW = lW * 2;
  444. wp++;
  445. }
  447. while(lH * 2 <= lHeight)
  448. {
  449. lH = lH * 2;
  450. hp++;
  451. }
  453. //用来存储源图象和变换核的时域数据
  454. complex<double> *pCTSrc,*pCTH;
  456. //用来存储源图象和变换核的频域数据
  457. complex<double>  *pCFSrc,*pCFH;
  459. // 为时域和频域的数组分配空间
  460. pCTSrc = new complex<double> [lHeight*lLineBytes];
  461. pCTH   = new complex<double> [lHeight*lLineBytes];
  463. pCFSrc = new complex<double> [lHeight*lLineBytes];
  464. pCFH   = new complex<double> [lHeight*lLineBytes];
  466. for (j = 0;j < lHeight ;j++)
  467. {
  468. for(i = 0;i < lLineBytes ;i++)
  469. {
  470. // 指向源图像倒数第j行，第i个象素的指针
  471. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  473. // 将象素值存储到时域数组中
  474. pCTSrc[ lLineBytes*j + i ] = complex<double>((double)*lpSrc , 0);
  476. // 频域赋零值
  477. pCFSrc[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  479. // 用来对图象做退化的系统
  480. if(i < 5 && j <5 )
  481. {
  482. pCTH[ lLineBytes*j + i ] = complex<double>(0.04 , 0.0);
  483. }
  484. else
  485. {
  486. pCTH[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  487. }
  489. // 频域赋零值
  490. pCFH[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  491. }
  492. }
  494. //对源图像进行FFT
  495. ::DIBFFT_2D(pCTSrc, lLineBytes, lHeight, pCFSrc);
  497. //对变换核图像进行FFT
  498. ::DIBFFT_2D(pCTH, lLineBytes, lHeight, pCFH);
  500. //频域相乘
  501. for (i = 0;i <lHeight*lLineBytes;i++)
  502. {
  503. pCFSrc[i] = pCFSrc[i]*pCFH[i];
  504. }
  506. //对结果图像进行反FFT
  507. IFFT_2D(pCFSrc, pCTSrc, lLineBytes, lHeight);
  509. //确定归一化因子
  510. MaxNum = 0.0;
  511. for (j = 0;j < lHeight ;j++)
  512. {
  513. for(i = 0;i < lLineBytes ;i++)
  514. {
  515. temp = sqrt(pCTSrc[ lLineBytes*j + i ].real() * pCTSrc[ lLineBytes*j + i ].real()
  516. +pCTSrc[lLineBytes*j + i ].imag() * pCTSrc[ lLineBytes*j +i].imag());
  518. //选择归一化因子
  519. if( MaxNum < temp)
  520. MaxNum = temp;
  521. }
  522. }
  524. //生成伪随机数种子
  525. srand((unsigned)time(NULL));
  527. //转换为图像，并加入伪随机噪声
  528. for (j = 0;j < lHeight ;j++)
  529. {
  530. for(i = 0;i < lLineBytes ;i++)
  531. {
  532. // 产生的噪声
  533. NoisePoint = rand()/2048-8;
  535. // 指向源图像倒数第j行，第i个象素的指针
  536.   lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  538. // 时域加噪，存储象素值
  539. *lpSrc = (unsigned char) (pCTSrc[(lLineBytes)*j + i].real()*255.0/MaxNum + NoisePoint);
  541. //如果象素值过大，直接赋值255
  542. if(*lpSrc > 255)
  543. *lpSrc = 255 ;
  544. }
  545. }
  547. //释放存储空间
  548. delete pCTSrc;
  549. delete pCTH;
  551. delete pCFSrc;
  552. delete pCFH;
  554. // 返回
  555. return true;
  556. }
  558. /*************************************************************************
  559.  *
  560.  * 函数名称：
  561.  *   DIBWinnerFilter()
  562.  *
  563.  * 参数:
  564.  *   CDib  *pDib       - 指向CDib类的指针
  565.  *
  566.  * 返回值:
  567.  *   BOOL               - 维纳滤波复原操作成功返回TRUE，否则返回FALSE。
  568.  *
  569.  * 说明:
  570.  *   该函数用来对DIB图像进行维纳滤波复原操作。
  571.  *
  572.  ************************************************************************/
  574. BOOL WINAPI DIBWinnerFilter (CDib *pDib)
  575. {
  576. // 指向源图像的指针
  577. BYTE * lpSrc;
  579. //图象的宽度和高度
  580. LONG    lWidth;
  581. LONG    lHeight;
  583. // 图像每行的字节数
  584. LONG lLineBytes;
  586. //得到图象的宽度和高度
  587. CSize   SizeDim;
  588. SizeDim = pDib->GetDimensions();
  589. lWidth  = SizeDim.cx;
  590. lHeight = SizeDim.cy;
  592. //得到实际的Dib图象存储大小
  593. CSize   SizeRealDim;
  594. SizeRealDim = pDib->GetDibSaveDim();
  596. // 计算图像每行的字节数
  597. lLineBytes = SizeRealDim.cx;
  599. //图像数据的指针
  600. LPBYTE  lpDIBBits = pDib->m_lpImage;
  602. //循环变量
  603. long i;
  604. long j;
  606. //临时变量
  607. double temp, tempre, tempim, 
  608. a, b, c, d, norm2;
  610. // 实际进行付立叶变换的宽度和高度
  611. LONG lW = 1;
  612. LONG lH = 1;
  614. int wp = 0;
  615. int hp = 0;
  617. // 保证离散傅立叶变换的宽度和高度为2的整数次方
  618. while(lW * 2 <= lLineBytes)
  619. {
  620. lW = lW * 2;
  621. wp++;
  622. }
  624. while(lH * 2 <= lHeight)
  625. {
  626. lH = lH * 2;
  627. hp++;
  628. }
  630. //用来存储源图象和变换核的时域数据
  631. complex<double> *pCTSrc,*pCTH;
  633. //用来存储源图象和变换核的频域数据
  634. complex<double>  *pCFSrc,*pCFH;
  636. //输入退化图象的长和宽必须为2的整数倍
  637. if(lW != (int) lLineBytes)
  638. {
  639. return false;
  640. }
  642. if(lH != (int) lHeight)
  643. {
  644. return false;
  645. }
  647. // 为时域和频域的数组分配空间
  648. pCTSrc = new complex<double> [lHeight*lLineBytes];
  649. pCTH = new complex<double> [lHeight*lLineBytes];
  651. pCFSrc = new complex<double> [lHeight*lLineBytes];
  652. pCFH = new complex<double> [lHeight*lLineBytes];
  654. // 滤波器加权系数
  655. double *pCFFilter   = new double [lHeight*lLineBytes];
  657. for (j = 0;j < lHeight ;j++)
  658. {
  659. for(i = 0;i < lLineBytes ;i++)
  660. {
  661. // 指向退化图像倒数第j行，第i个象素的指针
  662. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  664. // 将象素值存储到时域数组中
  665. pCTSrc[ lLineBytes*j + i ] = complex<double>((double)*lpSrc , 0);
  667. // 频域赋零值
  668. pCFSrc[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  670. // 退化系统时域及维纳滤波加权系数赋值
  671. if(i < 5 && j <5)
  672. {
  673. pCTH[ lLineBytes*j + i ] = complex<double>(0.04 , 0.0);
  674. pCFFilter[ lLineBytes*j + i ] = 0.5;
  675. }
  676. else
  677. {
  678. pCTH[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  679. pCFFilter[ lLineBytes*j + i ] = 0.05;
  680. }
  682. // 频域赋零值
  683. pCFH[ lLineBytes*j + i ] = complex<double>(0.0 , 0.0);
  684. }
  685. }
  687. //对退化图像进行FFT
  688. ::DIBFFT_2D(pCTSrc, lLineBytes, lHeight, pCFSrc);
  690. //对变换核图像进行FFT
  691. ::DIBFFT_2D(pCTH, lLineBytes, lHeight, pCFH);
  693. // 计算M
  694. for (i = 0; i < lHeight * lLineBytes; i++)
  695. {
  696. // 赋值
  697. a = pCFSrc[i].real();
  698. b = pCFSrc[i].imag();
  699. c = pCFH[i].real();
  700. d = pCFH[i].imag();
  702. // |H(u,v)|*|H(u,v)|
  703. norm2 = c * c + d * d;
  705. // |H(u,v)|*|H(u,v)|/(|H(u,v)|*|H(u,v)|+a)
  706. temp  = (norm2 ) / (norm2 + pCFFilter[i]);
  708. {
  709. tempre = ( a*c + b*d ) / ( c*c + d*d );
  710. tempim = ( b*c - a*d ) / ( c*c + d*d );
  712. // 求得f(u,v)
  713. pCFSrc[i]= complex<double>(temp*tempre , temp*tempim);
  714. }
  715. }
  717. //对复原图像进行反FFT
  718. IFFT_2D(pCFSrc, pCTSrc, lLineBytes, lHeight);
  720. //转换为复原图像
  721. for (j = 0;j < lHeight ;j++)
  722. {
  723. for(i = 0;i < lLineBytes ;i++)
  724. {
  725. // 指向复原图像倒数第j行，第i个象素的指针
  726.   lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  728. a = pCTSrc[(lLineBytes)*j + i].real();
  729. b = pCTSrc[(lLineBytes)*j + i].imag();
  731. norm2  = a*a + b*b;
  732. norm2  = sqrt(norm2) + 40;
  734. if(norm2 > 255)
  735. norm2 = 255.0;
  736. if(norm2 < 0)
  737. norm2 = 0;
  739. *lpSrc = (unsigned char) (norm2);
  740. }
  741. }
  743. //释放存储空间
  744. delete pCTSrc;
  745. delete pCTH;
  747. delete pCFSrc;
  748. delete pCFH;
  749. delete pCFFilter;
  751. // 返回
  752. return true;
  753. }
  755. /*************************************************************************
  756.  *
  757.  * 函数名称：
  758.  *   DIBMotionDegeneration()
  759.  *
  760.  * 参数:
  761.  *   CDib  *pDib       - 指向CDib类的指针
  762.  *
  763.  * 返回值:
  764.  *   BOOL               - 成功返回TRUE，否则返回FALSE。
  765.  *
  766.  * 说明:
  767.  *   该函数用来对DIB图像模拟由匀速直线运动造成的模糊
  768.  *
  769.  ***********************************************************************
  770.  */
  772. BOOL WINAPI DIBMotionDegeneration(CDib *pDib)
  773. {
  774. // 指向源图像的指针
  775. BYTE * lpSrc;
  777. //图象的宽度和高度
  778. LONG    lWidth;
  779. LONG    lHeight;
  781. // 图像每行的字节数
  782. LONG lLineBytes;
  784. //得到图象的宽度和高度
  785. CSize   SizeDim;
  786. SizeDim = pDib->GetDimensions();
  787. lWidth  = SizeDim.cx;
  788. lHeight = SizeDim.cy;
  790. //得到实际的Dib图象存储大小
  791. CSize   SizeRealDim;
  792. SizeRealDim = pDib->GetDibSaveDim();
  794. // 计算图像每行的字节数
  795. lLineBytes = SizeRealDim.cx;
  797. //图像数据的指针
  798. LPBYTE  lpDIBBits = pDib->m_lpImage;
  800. //循环变量
  801. long iColumn;
  802. long jRow;
  804. //临时变量
  805. int temp,m;
  807. // 临时变量
  808. double p,q;
  810. int nTotTime, nTotLen, nTime;
  812. //总的运动时间10s
  813. nTotTime = 10;
  815. // 总的运动距离10个象素点
  816. nTotLen = 10;
  818. // 摄像机的暴光系数
  819. double B;
  821. B = 0.1;
  823. //用来存储源图象和变换核的时域数据
  824. int *nImageDegener;
  826. // 为时域和频域的数组分配空间
  827. nImageDegener = new int [lHeight*lLineBytes];
  829. // 将数据存入时域数组
  830. for (jRow = 0; jRow < lHeight; jRow++)
  831. {
  832. for(iColumn = 0; iColumn < lLineBytes; iColumn++)
  833. {
  834. temp=0;
  836. // 指向源图像倒数第jRow行，第iColumn个象素的指针
  837. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * jRow + iColumn;
  839. // 象素点的象素值积累
  840. for ( nTime = 0; nTime < nTotTime; nTime++ )
  841. {
  842. p = (float)iColumn - (float)(nTotLen)*nTime/nTotTime;
  844. if (p > 0)
  845. {
  846. q = p - floor((double)p);
  848. if(q >= 0.5)
  849. m = (int)ceil((double)p);
  850. else
  851. m = (int)floor((double)p);
  853. // 累加
  854. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * jRow + m;
  855. temp = temp + *lpSrc;
  856. }
  857. }
  859. // 乘以摄像机的暴光系数
  860. temp = B * temp;
  862. temp=(int)ceil((double)temp);
  864. // 使得temp的取值符合取值范围
  865. if(temp<0)
  866. temp=0;
  868. if(temp>255)
  869. temp=255;
  871. nImageDegener[lLineBytes*jRow + iColumn] = temp;
  872. }
  873. }
  875. //转换为图像
  876. for (jRow = 0;jRow < lHeight ;jRow++)
  877. {
  878. for(iColumn = 0;iColumn < lLineBytes ;iColumn++)
  879. {
  880. // 指向源图像倒数第jRow行，第iColumn个象素的指针
  881.   lpSrc = (unsigned char *)lpDIBBits + lLineBytes * jRow + iColumn;
  883. *lpSrc = nImageDegener[lLineBytes*jRow + iColumn];
  884. }
  885. }
  887. //释放存储空间
  888. delete nImageDegener;
  890. // 返回
  891. return true;
  892. }
  894. /*************************************************************************
  895.  *
  896.  * 函数名称：
  897.  *   DIBMotionRestore()
  898.  *
  899.  * 参数:
  900.  *   CDib  *pDib       - 指向CDib类的指针
  901.  *
  902.  * 返回值:
  903.  *   BOOL               - 成功返回TRUE，否则返回FALSE。
  904.  *
  905.  * 说明:
  906.  *   该函数用来对拟由匀速直线运动造成的模糊图象进行复原
  907.  *
  908.  ***********************************************************************
  909.  */
  911. BOOL WINAPI DIBMotionRestore(CDib *pDib)
  912. {
  913. // 指向源图像的指针
  914. BYTE * lpSrc;
  916. //图象的宽度和高度
  917. LONG    lWidth;
  918. LONG    lHeight;
  920. // 图像每行的字节数
  921. LONG lLineBytes;
  923. //得到图象的宽度和高度
  924. CSize   SizeDim;
  925. SizeDim = pDib->GetDimensions();
  926. lWidth  = SizeDim.cx;
  927. lHeight = SizeDim.cy;
  929. //得到实际的Dib图象存储大小
  930. CSize   SizeRealDim;
  931. SizeRealDim = pDib->GetDibSaveDim();
  933. // 计算图像每行的字节数
  934. lLineBytes = SizeRealDim.cx;
  936. //图像数据的指针
  937. LPBYTE  lpDIBBits = pDib->m_lpImage;
  939. //循环变量
  940. long iColumn;
  941. long jRow;
  943. int i,n,m;
  945. //临时变量
  946. int temp1,temp2,
  947. totalq,q1,q2,z;
  949. double p,q;
  951. // 常量A赋值
  952. int A = 80;
  954. //常量B赋值
  955. int B = 10;
  957. //总的移动距离
  958. int nTotLen=10;
  960. // 图象宽度包含多少个ntotlen
  961. int K=lLineBytes/nTotLen;
  963. int error[10];
  965. //用来存储源图象时域数据
  966. int *nImageDegener;
  968. // 为时域数组分配空间
  969. nImageDegener = new int [lHeight*lLineBytes];
  971. // 将象素存入数组中
  972. for (jRow = 0; jRow < lHeight; jRow++)
  973. {
  974. for(iColumn = 0; iColumn < lLineBytes; iColumn++)
  975. {
  976. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * jRow + iColumn;
  978. nImageDegener[lLineBytes*jRow + iColumn] = (*lpSrc);
  979. }
  980. }
  982. for (jRow = 0; jRow < lHeight; jRow++)
  983. {
  984. // 计算error[i]
  985. for(i = 0; i < 10; i++)
  986. {
  988. error[i] = 0;
  990. for(n = 0; n < K; n++)
  991. for(m = 0; m <= n; m++)
  992. {
  993. // 象素是否为一行的开始处
  994. if(i == 0 && m == 0)
  995. {
  996. temp1=temp2=0;
  997. }
  999. // 进行差分运算
  1000. else
  1001. {
  1002. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * jRow + m*10+i;
  1003. temp1=*lpSrc;
  1005. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * jRow + m*10+i-1;
  1006. temp2 = *lpSrc;
  1007. }
  1009. error[i] = error[i] + temp1 - temp2;
  1011. }
  1013. error[i] = B * error[i] / K;
  1014. }
  1016. for(iColumn = 0; iColumn < lLineBytes; iColumn++)
  1017. {
  1018. // 计算m，以及z
  1019. m = iColumn / nTotLen;
  1020. z = iColumn - m*nTotLen;
  1022. // 初始化
  1023. totalq = 0;
  1024. q = 0;
  1026. for(n = 0; n <= m; n++)
  1027. {
  1028. q1 = iColumn - nTotLen*n;
  1030. if(q1 == 0)
  1031. q = 0;
  1033. // 进行差分运算
  1034. else
  1035. {
  1036. q2 = q1 - 1;
  1038. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * jRow + q1;
  1039. temp1 = *lpSrc;
  1041. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * jRow + q2;
  1042. temp2 = *lpSrc;
  1044. q = (temp1 - temp2) * B;
  1045. }
  1047. totalq = totalq + q;
  1048. }
  1050. p = error[z];
  1052. // 得到f(x,y)的值
  1053. temp1 = totalq + A - p;
  1055. // 使得象素的取值符合取值范围
  1056. if(temp1 < 0)
  1057. temp1 = 0;
  1059. if(temp1 > 255)
  1060. temp1 = 255;
  1062. nImageDegener[lLineBytes*jRow + iColumn] = temp1;
  1063. }
  1064. }
  1066. //转换为图像
  1067. for (jRow = 0;jRow < lHeight ;jRow++)
  1068. {
  1069. for(iColumn = 0;iColumn < lLineBytes ;iColumn++)
  1070. {
  1071. // 指向源图像倒数第jRow行，第iColumn个象素的指针
  1072.   lpSrc = (unsigned char *)lpDIBBits + lLineBytes * jRow + iColumn;
  1074. // 存储象素值
  1075. *lpSrc = nImageDegener[lLineBytes*jRow + iColumn];
  1076. }
  1077. }
  1079. //释放存储空间
  1080. delete nImageDegener;
  1082. // 返回
  1083. return true;
  1084. }
  1085. #undef SWAP