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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 波变换 > 查看源码
WaveTranform.cpp
资源名称：imagefusionwavelettransform.rar　[点击查看]
上传用户：aqingfeng
上传日期：2014-03-25
资源大小：1839k
文件大小：18k
源码类别：

波变换

开发平台：

Visual C++

WaveTranform.cpp：源码内容
  1. // WaveTranform.cpp: implementation of the CWaveTranform class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "小波变换.h"
  7. #include "WaveTranform.h"
  8. #include "DIBAPI.h"
  9. #include "Diproc.h"
  11. #include <math.h>
  12. #include <direct.h>
  14. #ifdef _DEBUG
  15. #undef THIS_FILE
  16. static char THIS_FILE[]=__FILE__;
  17. #define new DEBUG_NEW
  18. #endif
  20. //////////////////////////////////////////////////////////////////////
  21. // Construction/Destruction
  22. //////////////////////////////////////////////////////////////////////
  24. CWaveTranform::CWaveTranform()
  25. {
  26. m_GrayMax=255;
  27. m_GrayMin=0;
  28. for(int i=0;i<3;i++)
  29. {
  30. m_ColorMax[i]=255;//0蓝1绿2红
  31. m_ColorMin[i]=0;
  32. }
  33. m_preoffset=0;
  34. m_aftoffset=0;
  35. }
  37. CWaveTranform::~CWaveTranform()
  38. {
  40. }
  42. /*************************************************************************
  43.  *
  44.  * 函数名称：
  45.  *   Convolution()
  46.  *
  47.  * 参数:
  48.  *   double * LF HF - 指向小波的指针，是常量
  49.  *   FR                     - 小波窗的宽度 
  50.  *   double * f - 指向时域值的指针和返回的小波变换频域的指针
  51.  *   fr －原图象每一行的像素个数
  52.  *
  53.  * 返回值:
  54.  *   无。
  55.  *
  56.  * 说明:
  57.  *   该函数用来实现卷积运算。
  58.  *
  59.  ************************************************************************/
  61. void CWaveTranform::Convolution(double *LF,double *HF,int FR, double *f, int fr)
  62. {
  63. int i,j,m;// 循环变量
  64. double *X;
  65. X = new double[fr]; // 分配运算所需的数组
  66. // 卷积运算
  67. for(i=0;i<fr/2;i++)
  68. {
  69. X[i]=0;
  70. X[i+fr/2]=0;
  71. for(j=0;j<FR;j++)
  72. {
  73. m=(2*i+j+fr-m_preoffset)%fr;
  74. X[i]+=f[m]*LF[j];
  75. X[i+fr/2]+=f[m]*HF[j];
  76. }
  77. }
  78. //运算结果反传给f。
  79. for(i= 0; i <fr; i++)
  80. {
  81. f[i]=X[i];
  82. }
  83. delete X;// 释放内存
  84. }
  86. /*************************************************************************
  87.  *
  88.  * 函数名称：
  89.  *   DisConvolution()
  90.  *
  91.  * 参数:
  92.  *   double * F - 指向小波的指针，是常量
  93.  *   FR                     - 小波窗的宽度 
  94.  *   double * f - 指向时域值的指针和返回的小波变换频域的指针
  95.  *   fr －原图象每一行的像素个数
  96.  *
  97.  * 返回值:
  98.  *   无。
  99.  *
  100.  * 说明:
  101.  *   该函数用来实现解卷积运算。
  102.  *
  103.  ************************************************************************/
  105. void CWaveTranform::DisConvolution(double *LF,double *HF,int FR, double *f0,double *f1, int fr)
  106. {
  107. int i,j;// 循环变量
  108. double *X,*Y;
  109. // 分配运算所需的数组
  110. X = new double[fr];
  111. Y = new double[fr];
  112. // 解卷积运算
  113. for(i=0;i<fr;i++)
  114. {
  115. X[i]=0;
  116. Y[i]=0;
  117. for(j=0;j<FR;j++)
  118. {
  119. X[i]+=f0[(i+j)%fr]*LF[j];
  120. Y[i]+=f1[(i+j)%fr]*HF[j];
  121. }
  122. }
  123. //运算结果反传给f0。
  124. for(i= 0; i <fr; i++)
  125. {
  126. j=(i+fr-m_aftoffset)%fr;//循环移位
  127. f0[i]=X[j]+Y[j];
  128. }
  129. delete X,Y; // 释放内存
  130. }
  132. /*************************************************************************
  133.  *
  134.  * 函数名称：
  135.  *   DIBWavelet()
  136.  *
  137.  * 参数:
  138.  *   LPSTR lpDIB        - 指向DIB图像指针
  139.  *   LPSTR lpDIBBits    - 指向源DIB象素指针
  140.  *   double *LF         - 使用的小波尺度函数，是常量
  141.  *   double *HF         - 使用的小波母函数，是常量
  142.  *   int FWidth         - 小波窗的宽度
  143.  *   int nLevel         - 小波分解的层数  
  144.  *
  145.  * 返回值:
  146.  *   BOOL               - 成功返回TRUE，否则返回FALSE。
  147.  *
  148.  * 说明:
  149.  *   该函数用来对图像进行小波变换分解。于上面不同的是，此处是将二维
  150.  * 矩阵转换成一个列向量，然后对该列向量进行一次一维小波变换。
  151.  *
  152.  ************************************************************************/
  154. BOOL CWaveTranform::DIBWavelet(LPSTR lpDIB,LPSTR lpDIBBits,double* LF,double* HF,int FWidth,int nLevel)
  155. {
  156. unsigned char* lpSrc;// 指向源图像的指针
  157. double dTemp;// 中间变量
  158. LONG lLineBytes; // 图像每行的字节数
  159. LONG lWidth, lHeight;
  160. lWidth=::DIBWidth(lpDIB);
  161. lHeight=::DIBHeight(lpDIB);
  162. LONG i,j;//循环变量
  163. double *f = new double[lWidth*lHeight];// 分配内存
  164. if(::DIBNumColors(lpDIB)==256)
  165. {
  166. lLineBytes = WIDTHBYTES(lWidth * 8);// 计算图像每行的字节数
  167. // 从源图像中读取数据。
  168. for(i = 0; i < lHeight; i++)//每列
  169. {
  170. for(j = 0; j < lWidth; j++)// 每行
  171. {
  172. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) +j; // 指向DIB第i行，第j个象素的指针
  173. f[i*lWidth+j] = *(lpSrc);// 给时域赋值
  174. }
  175. }
  176. int n;//层数循环变量
  177. //小波变换分解过程循环
  178. for(n=0;n<nLevel;n++)
  179. {
  180. LONG Height,Width;//第n层图象的高度和宽度
  181. Height=long(lHeight/pow(2,n));
  182. Width=long(lWidth/pow(2,n));
  183. double *LH=new double[Width];  //存放每一行元素
  184. for(i = 0; i < Height; i++)
  185. {
  186. for(j=0;j<Width;j++)
  187. {
  188. LH[j]=f[i*lWidth+j];
  189. }
  190. Convolution( LF,HF, FWidth,LH, Width);// 对x方向进行卷积运算
  191. for(j=0;j<Width;j++)
  192. {
  193. f[i*lWidth+j]=LH[j];
  194. }
  195. }
  196. delete LH;
  197. LH=new double[Height];  //存放每一列元素
  198. for(i = 0; i < Width; i++)
  199. {
  200. for(j=0;j<Height;j++)
  201. {
  202. LH[j]=f[i+j*lWidth];
  203. }
  204. Convolution( LF,HF, FWidth,LH, Height);// 对y方向进行卷积运算
  205. for(j=0;j<Height;j++)
  206. {
  207. f[i+j*lWidth]=LH[j];
  208. }
  209. }
  210. delete LH;//释放内存
  211. }
  212. //将分解后的值规划处理
  213. m_GrayMax=0;
  214. m_GrayMin=255;
  215. for(i=0;i<lHeight;i++)
  216. {
  217. for(j=0;j<lWidth;j++)
  218. {
  219. m_GrayMax=m_GrayMax>f[i * lWidth + j]?m_GrayMax:f[i * lWidth + j];
  220. m_GrayMin=m_GrayMin<f[i * lWidth + j]?m_GrayMin:f[i * lWidth + j];
  221. }
  222. }
  223. // 更新源图像
  224. for(i = 0; i < lHeight; i++)// 每列
  225. {
  226. for(j = 0; j < lWidth; j++)// 每行
  227. {
  228. dTemp = f[i * lWidth + j]; // 计算频谱
  229. dTemp=255/(m_GrayMax-m_GrayMin)*(dTemp-m_GrayMin);
  230. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;// 指向DIB第i行，第j个象素的指针
  231. * (lpSrc) = (BYTE)(dTemp);// 更新源图像
  232. }
  233. }
  234. }
  235. //处理真彩色
  236. else
  237. {
  238. int ncolor;//颜色值循环
  239. for(ncolor=0;ncolor<3;ncolor++)
  240. {
  241. lLineBytes = WIDTHBYTES(lWidth * 24);// 计算图像每行的字节数
  242. // 从源图像中读取数据。
  243. for(i = 0; i < lHeight; i++)//每列
  244. {
  245. for(j = 0; j < lWidth; j++)// 每行
  246. {
  247. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) +3*j+ncolor; // 指向DIB第i行，第j个象素的指针
  248. f[i*lWidth+j] = *(lpSrc);// 给时域赋值
  249. }
  250. }
  251. int n;//层数循环变量
  252. //小波变换分解过程循环
  253. for(n=0;n<nLevel;n++)
  254. {
  255. LONG Height,Width;//第n层图象的高度和宽度
  256. Height=long(lHeight/pow(2,n));
  257. Width=long(lWidth/pow(2,n));
  258. double *LH=new double[Width];  //存放每一行元素
  259. for(i = 0; i < Height; i++)
  260. {
  261. for(j=0;j<Width;j++)
  262. {
  263. LH[j]=f[i*lWidth+j];
  264. }
  265. Convolution( LF,HF, FWidth,LH, Width);// 对x方向进行卷积运算
  266. for(j=0;j<Width;j++)
  267. {
  268. f[i*lWidth+j]=LH[j];
  269. }
  270. }
  271. delete LH;
  272. LH=new double[Height];  //存放每一列元素
  273. for(i = 0; i < Width; i++)
  274. {
  275. for(j=0;j<Height;j++)
  276. {
  277. LH[j]=f[i+j*lWidth];
  278. }
  279. Convolution( LF,HF, FWidth,LH, Height);// 对y方向进行卷积运算
  280. for(j=0;j<Height;j++)
  281. {
  282. f[i+j*lWidth]=LH[j];
  283. }
  284. }
  285. delete LH;//释放内存
  286. }
  287. //将分解后的值规划处理
  288. m_ColorMax[ncolor]=0;
  289. m_ColorMin[ncolor]=255;
  290. for(i=0;i<lHeight;i++)
  291. {
  292. for(j=0;j<lWidth;j++)
  293. {
  294. m_ColorMax[ncolor]=m_ColorMax[ncolor]>f[i * lWidth + j]?m_ColorMax[ncolor]:f[i * lWidth + j];
  295. m_ColorMin[ncolor]=m_ColorMin[ncolor]<f[i * lWidth + j]?m_ColorMin[ncolor]:f[i * lWidth + j];
  296. }
  297. }
  298. // 更新源图像
  299. for(i = 0; i < lHeight; i++)// 每列
  300. {
  301. for(j = 0; j < lWidth; j++)// 每行
  302. {
  303. dTemp = f[i * lWidth + j]; // 计算频谱
  304. dTemp=255/(m_ColorMax[ncolor]-m_ColorMin[ncolor])*(dTemp-m_ColorMin[ncolor]);
  305. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + 3*j+ncolor;// 指向DIB第i行，第j个象素的指针
  306. * (lpSrc) = (BYTE)(dTemp);// 更新源图像
  307. }
  308. }
  309. }
  310. }
  311. delete f;//释放内存
  312. return TRUE;// 返回
  313. }
  315. /*************************************************************************
  316.  *
  317.  * 函数名称：
  318.  *   DIBDisWavelet()
  319.  *
  320.  * 参数:
  321.  *   LPSTR lpDIB        - 指向DIB图像指针
  322.  *   LPSTR lpDIBBits    - 指向源DIB象素指针
  323.  *   double *LF         - 使用的小波尺度函数，是常量
  324.  *   double *HF         - 使用的小波母函数，是常量
  325.  *   int FWidth         - 小波窗的宽度
  326.  *   int nLevel         - 小波分解的层数  
  327.  *
  328.  * 返回值:
  329.  *   BOOL               - 成功返回TRUE，否则返回FALSE。
  330.  *
  331.  * 说明:
  332.  *   该函数用来对图像进行小波变换重建。于上面不同的是，此处是将二维
  333.  * 矩阵转换成一个列向量，然后对该列向量进行一次一维小波变换。
  334.  *
  335.  ************************************************************************/
  337. BOOL CWaveTranform::DIBDisWavelet(LPSTR lpDIB,LPSTR lpDIBBits,double* LF,double* HF,int FWidth,int nLevel)
  338. {
  339. unsigned char* lpSrc;// 指向源图像的指针
  340. double dTemp;// 中间变量
  341. LONG lLineBytes; // 图像每行的字节数
  342. LONG lWidth,lHeight;
  343. lWidth=::DIBWidth(lpDIB);
  344. lHeight=::DIBHeight(lpDIB);
  345. LONG i,j;//循环变量
  346. double *f = new double[lWidth*lHeight];// 分配内存
  347. if(::DIBNumColors(lpDIB)==256)
  348. {
  349. lLineBytes = WIDTHBYTES(lWidth * 8);// 计算图像每行的字节数
  350. // 从源图像中读取数据。
  351. for(i = 0; i < lHeight; i++)// 每列
  352. {
  353. for(j = 0; j < lWidth; j++)// 每行
  354. {
  355. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) +j; // 指向DIB第i行，第j个象素的指针
  356. f[i*lWidth+j] = *(lpSrc);// 给时域赋值
  357. //将规划处理后的值变回原样
  358. f[i*lWidth+j]=(m_GrayMax-m_GrayMin)/255*f[i*lWidth+j]+m_GrayMin;
  359. }
  360. }
  361. int n;//层数循环变量
  362. //小波变换重建过程循环
  363. for(n=nLevel-1;n>=0;n--)
  364. {
  365. LONG Height,Width;
  366. Height=long(lHeight/pow(2,n));
  367. Width=long(lWidth/pow(2,n));
  368. double *H00=new double[Height];  //按列存放低低元素
  369. double *H01=new double[Height];  //按列存放低高元素
  370. double *H10=new double[Height];  //按列存放高低元素
  371. double *H11=new double[Height];  //按列存放高高元素
  372. for(i = 0; i < Width/2; i++)
  373. {
  374. for(j=0;j<Height/2;j++)
  375. {
  376. H00[2*j]=f[i+j*lWidth];
  377. H00[2*j+1]=0;
  378. }
  379. for(j=Height/2;j<Height;j++)
  380. {
  381. H01[2*j-Height]=f[i+j*lWidth];
  382. H01[2*j-Height+1]=0;
  383. }
  384. DisConvolution( LF,HF, FWidth,H00,H01 ,Height);// 对y方向进行解内积运算
  385. for(j=0;j<Height;j++)
  386. {
  387. f[i+j*lWidth]=H00[j];
  388. }
  389. }
  390. for(i =Width/2 ; i < Width; i++)
  391. {
  392. for(j=0;j<Height/2;j++)
  393. {
  394. H10[2*j]=f[i+j*lWidth];
  395. H10[2*j+1]=0;
  396. }
  397. for(j=Height/2;j<Height;j++)
  398. {
  399. H11[2*j-Height]=f[i+j*lWidth];
  400. H11[2*j-Height+1]=0;
  401. }
  402. DisConvolution( LF,HF, FWidth,H10,H11, Height); // 对y方向进行解内积运算
  403. for(j=0;j<Height;j++)
  404. {
  405. f[i+j*lWidth]=H10[j];
  406. }
  407. }
  408. delete H00,H01,H10,H11;//释放内存
  409. double *H0=new double[Width];  //按行存放低元素
  410. double *H1=new double[Width];  //按行存放高元素
  411. for(i = 0; i < Height; i++)
  412. {
  413. for(j=0;j<Width/2;j++)
  414. {
  415. H0[2*j]=f[i*lWidth+j];
  416. H0[2*j+1]=0;
  417. }
  418. for(j=Width/2;j<Width;j++)
  419. {
  420. H1[2*j-Width]=f[i*lWidth+j];
  421. H1[2*j-Width+1]=0;
  422. }
  423. DisConvolution( LF,HF, FWidth,H0,H1, Width);// 对x方向进行解卷积运算
  424. for(j=0;j<Width;j++)
  425. {
  426. f[i*lWidth+j]=H0[j];
  427. }
  428. }
  429. delete H0,H1;
  430. }
  431. // 更新源图像
  432. for(i = 0; i < lHeight; i++)// 每列
  433. {
  434. for(j = 0; j < lWidth; j++)// 每行
  435. {
  436. dTemp = f[i * lWidth + j]; // 计算频谱
  437. if (dTemp > 255)
  438. dTemp = 255;
  439. if(dTemp < 0)
  440. dTemp=0;
  441. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;// 指向DIB第i行，第j个象素的指针
  442. * (lpSrc) = (BYTE)(dTemp);// 更新源图像
  443. }
  444. }
  445. }
  446. else
  447. {
  448. int ncolor;
  449. for(ncolor=0;ncolor<3;ncolor++)
  450. {
  451. lLineBytes = WIDTHBYTES(lWidth * 24);// 计算图像每行的字节数
  452. // 从源图像中读取数据。
  453. for(i = 0; i < lHeight; i++)// 每列
  454. {
  455. for(j = 0; j < lWidth; j++)// 每行
  456. {
  457. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) +3*j+ncolor; // 指向DIB第i行，第j个象素的指针
  458. f[i*lWidth+j] = *(lpSrc);// 给时域赋值
  459. //将规划处理后的值变回原样
  460. f[i*lWidth+j]=(m_ColorMax[ncolor]-m_ColorMin[ncolor])/255*f[i*lWidth+j]+m_ColorMin[ncolor];
  461. }
  462. }
  463. int n;//层数循环变量
  464. //小波变换重建过程循环
  465. for(n=nLevel-1;n>=0;n--)
  466. {
  467. LONG Height,Width;
  468. Height=long(lHeight/pow(2,n));
  469. Width=long(lWidth/pow(2,n));
  470. double *H00=new double[Height];  //按列存放低低元素
  471. double *H01=new double[Height];  //按列存放低高元素
  472. double *H10=new double[Height];  //按列存放高低元素
  473. double *H11=new double[Height];  //按列存放高高元素
  474. for(i = 0; i < Width/2; i++)
  475. {
  476. for(j=0;j<Height/2;j++)
  477. {
  478. H00[2*j]=f[i+j*lWidth];
  479. H00[2*j+1]=0;
  480. }
  481. for(j=Height/2;j<Height;j++)
  482. {
  483. H01[2*j-Height]=f[i+j*lWidth];
  484. H01[2*j-Height+1]=0;
  485. }
  486. DisConvolution( LF,HF, FWidth,H00,H01 ,Height);// 对y方向进行解内积运算
  487. for(j=0;j<Height;j++)
  488. {
  489. f[i+j*lWidth]=H00[j];
  490. }
  491. }
  492. for(i =Width/2 ; i < Width; i++)
  493. {
  494. for(j=0;j<Height/2;j++)
  495. {
  496. H10[2*j]=f[i+j*lWidth];
  497. H10[2*j+1]=0;
  498. }
  499. for(j=Height/2;j<Height;j++)
  500. {
  501. H11[2*j-Height]=f[i+j*lWidth];
  502. H11[2*j-Height+1]=0;
  503. }
  504. DisConvolution( LF,HF, FWidth,H10,H11, Height); // 对y方向进行解内积运算
  505. for(j=0;j<Height;j++)
  506. {
  507. f[i+j*lWidth]=H10[j];
  508. }
  509. }
  510. delete H00,H01,H10,H11;//释放内存
  511. double *H0=new double[Width];  //按行存放低元素
  512. double *H1=new double[Width];  //按行存放高元素
  513. for(i = 0; i < Height; i++)
  514. {
  515. for(j=0;j<Width/2;j++)
  516. {
  517. H0[2*j]=f[i*lWidth+j];
  518. H0[2*j+1]=0;
  519. }
  520. for(j=Width/2;j<Width;j++)
  521. {
  522. H1[2*j-Width]=f[i*lWidth+j];
  523. H1[2*j-Width+1]=0;
  524. }
  525. DisConvolution( LF,HF, FWidth,H0,H1, Width);// 对x方向进行解卷积运算
  526. for(j=0;j<Width;j++)
  527. {
  528. f[i*lWidth+j]=H0[j];
  529. }
  530. }
  531. delete H0,H1;
  532. }
  533. // 更新源图像
  534. for(i = 0; i < lHeight; i++)// 每列
  535. {
  536. for(j = 0; j < lWidth; j++)// 每行
  537. {
  538. dTemp = f[i * lWidth + j]; // 计算频谱
  539. if (dTemp > 255)
  540. dTemp = 255;
  541. if(dTemp < 0)
  542. dTemp=0;
  543. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + 3*j+ncolor;// 指向DIB第i行，第j个象素的指针
  544. * (lpSrc) = (BYTE)(dTemp);// 更新源图像
  545. }
  546. }
  547. }
  548. }
  549. delete f;//释放内存
  550. return TRUE;// 返回
  551. }
  555. void CWaveTranform::DIP_ImageFusion2(LPSTR lpDIB1,LPSTR lpDIBBits1,LPSTR lpDIB2,LPSTR lpDIBBits2,int nlever)
  556. {
  557.     unsigned char* lpSrc;// 指向源图像的指针
  558. double dTemp;// 中间变量
  559. LONG lLineBytes; // 图像每行的字节数
  560. LONG lWidth,lHeight;
  561. lWidth=::DIBWidth(lpDIB1);
  562. lHeight=::DIBHeight(lpDIB1);
  563. LONG i,j;//循环变量
  564. double *f1 = new double[lWidth*lHeight];// 分配内存
  565. double *f2 = new double[lWidth*lHeight];
  567. int N=lWidth*lHeight;
  568. int x,y;
  569. int dd=(int)pow(2,nlever);
  570. int nw=lWidth/dd;
  571. int nh=lHeight/dd;
  572. int p1,p2;
  575. if((::DIBNumColors(lpDIB1)==256)&&(::DIBNumColors(lpDIB2)==256))
  576. {
  577. lLineBytes = WIDTHBYTES(lWidth * 8);// 计算图像每行的字节数
  578. // 从源图像1中读取数据。
  579. for(i = 0; i < lHeight; i++)// 每列
  580. {
  581. for(j = 0; j < lWidth; j++)// 每行
  582. {
  583. lpSrc = (unsigned char*)lpDIBBits1 + lLineBytes * (lHeight - 1 - i) +j; // 指向DIB第i行，第j个象素的指针
  584. f1[i*lWidth+j] = *(lpSrc);// 给时域赋值
  585. //将规划处理后的值变回原样
  586. f1[i*lWidth+j]=(m_GrayMax-m_GrayMin)/255*f1[i*lWidth+j]+m_GrayMin;
  587. }
  588. }
  589.    // 从源图像1中读取数据。
  590. for(i = 0; i < lHeight; i++)// 每列
  591. {
  592. for(j = 0; j < lWidth; j++)// 每行
  593. {
  594. lpSrc = (unsigned char*)lpDIBBits2 + lLineBytes * (lHeight - 1 - i) +j; // 指向DIB第i行，第j个象素的指针
  595. f2[i*lWidth+j] = *(lpSrc);// 给时域赋值
  596. //将规划处理后的值变回原样
  597. f2[i*lWidth+j]=(m_GrayMax-m_GrayMin)/255*f2[i*lWidth+j]+m_GrayMin;
  598. }
  599. }
  600.         for(i=0;i<N;i++)
  601. {
  602. p1=f1[i];
  603. p2=f2[i];
  604.             x=i%lWidth;
  605. y=i/lWidth;
  606. if((x<nw)&&(y<nh))
  607. {
  608. f1[i]=(p1+p2)/2;
  609. }
  610. else
  611. {
  612. f1[i]=(abs(p1)>abs(p2))?p1:p2;
  613. }
  614. }
  615. //更新图像源
  616. for(i = 0; i < lHeight; i++)// 每列
  617. {
  618. for(j = 0; j < lWidth; j++)// 每行
  619. {
  620. dTemp = f1[i * lWidth + j]; // 计算频谱
  621. dTemp=255/(m_GrayMax-m_GrayMin)*(dTemp-m_GrayMin);
  622. lpSrc = (unsigned char*)lpDIBBits1 + lLineBytes * (lHeight - 1 - i) + j;// 指向DIB第i行，第j个象素的指针
  623. * (lpSrc) = (BYTE)(dTemp);// 更新源图像
  624. }
  625. }
  626. }
  627. else 
  628. {
  629. int ncolor;
  630. for(ncolor=0;ncolor<3;ncolor++)
  631. {
  632. lLineBytes = WIDTHBYTES(lWidth * 24);// 计算图像每行的字节数
  633. // 从源图像中读取数据。
  634. for(i = 0; i < lHeight; i++)// 每列
  635. {
  636. for(j = 0; j < lWidth; j++)// 每行
  637. {
  638. lpSrc = (unsigned char*)lpDIBBits1 + lLineBytes * (lHeight - 1 - i) +3*j+ncolor; // 指向DIB第i行，第j个象素的指针
  639. f1[i*lWidth+j] = *(lpSrc);// 给时域赋值
  640. //将规划处理后的值变回原样
  641. f1[i*lWidth+j]=(m_ColorMax[ncolor]-m_ColorMin[ncolor])/255*f1[i*lWidth+j]+m_ColorMin[ncolor];
  642. }
  643. }
  644. // 从源图像中读取数据。
  645. for(i = 0; i < lHeight; i++)// 每列
  646. {
  647. for(j = 0; j < lWidth; j++)// 每行
  648. {
  649. lpSrc = (unsigned char*)lpDIBBits2 + lLineBytes * (lHeight - 1 - i) +3*j+ncolor; // 指向DIB第i行，第j个象素的指针
  650. f2[i*lWidth+j] = *(lpSrc);// 给时域赋值
  651. //将规划处理后的值变回原样
  652. f2[i*lWidth+j]=(m_ColorMax[ncolor]-m_ColorMin[ncolor])/255*f2[i*lWidth+j]+m_ColorMin[ncolor];
  653. }
  654. }
  655. for(i=0;i<N;i++)
  656. {
  657. p1=f1[i];
  658. p2=f2[i];
  659.             x=i%lWidth;
  660. y=i/lWidth;
  661. if((x<nw)&&(y<nh))
  662. {
  663. f1[i]=(p1+p2)/2;
  664. }
  665. else
  666. {
  667. f1[i]=(abs(p1)>abs(p2))?p1:p2;
  668. }
  669. }
  670. for(i = 0; i < lHeight; i++)// 每列
  671. {
  672. for(j = 0; j < lWidth; j++)// 每行
  673. {
  674. dTemp = f1[i * lWidth + j]; // 计算频谱
  675. dTemp=255/(m_ColorMax[ncolor]-m_ColorMin[ncolor])*(dTemp-m_ColorMin[ncolor]);
  676. lpSrc = (unsigned char*)lpDIBBits1 + lLineBytes * (lHeight - 1 - i) + 3*j+ncolor;// 指向DIB第i行，第j个象素的指针
  677. * (lpSrc) = (BYTE)(dTemp);// 更新源图像
  678. }
  679. }
  680. }
  681. delete f1;//释放内存
  682. delete f2;//释放内存
  683. }
  684. }