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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 数学计算 > 查看源码
PinYuLuBoDib.cpp
资源名称：FFT2Dsource.rar　[点击查看]
上传用户：hnhlzg
上传日期：2013-10-19
资源大小：289k
文件大小：22k
源码类别：

数学计算

开发平台：

Visual C++

PinYuLuBoDib.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "windowsx.h"
  3. #include "math.h"
  4. #include "PinYuLuBoDib.h"
  5. #include "malloc.h"
  6. #include "MainFrm.h"
  7. #include "DSplitView.h"
  8. #include "Cdib.h"
  9. #define WIDTHBYTES(bits)    (((bits) + 31) / 32 * 4) 
  12. #define SWAP(a,b) tempr=(a);(a)=(b);(b)=tempr
  13. #define pi 3.14159265359
  14.  
  15.  
  16. PinYuLuBoDib::PinYuLuBoDib()
  17. {
  18. }
  19. PinYuLuBoDib::~PinYuLuBoDib()
  20. {
  21. }
  23. CNumber PinYuLuBoDib::Add(CNumber c1,CNumber c2)
  24. {
  25. CNumber c;
  26. c.re=c1.re+c2.re;
  27. c.im=c1.im+c2.im;
  28. return c;
  29. }
  30. CNumber PinYuLuBoDib::Sub(CNumber c1,CNumber c2)
  31. {
  32. CNumber c;
  33. c.re=c1.re-c2.re;
  34. c.im=c1.im-c2.im;
  35. return c;
  36. }
  37. CNumber PinYuLuBoDib::Mul(CNumber c1,CNumber c2)
  38. {
  39. CNumber c;
  40. c.re=c1.re*c2.re-c1.im*c2.im;
  41. c.im=c1.re*c2.im+c2.re*c1.im;
  42. return c;
  43. }
  45. ///////////////////////////////////////////////////
  46. //此函数实现快速傅立叶变换
  47. //参数t、f分别是指向时域和频域的指针，power是2的幂数
  48. ///////////////////////////////////////////////////
  49. void PinYuLuBoDib::QFC(CNumber* t,CNumber* f,int power)
  50. {
  51. long count;//傅立叶变换点数
  52. int i,j,k,p,bfsize;
  53. CNumber *w,*x,*a,*b;//复数结构类型的指针变量，其中w指向加权系数
  54. double angle;//计算加权系数所用的角度值
  55. count=1<<power;//计算傅立叶变换点数
  56. //分配所需运算空间
  57. w=new CNumber[count/2];
  58. a=new CNumber[count];
  59. b=new CNumber[count];
  60. //计算加权系数
  61. for(i=0;i<count/2;i++)
  62. {
  63. angle=-i*pi*2/count;
  64. w[i].re=cos(angle);
  65. w[i].im=sin(angle);
  66. }
  67. memcpy(a,t,sizeof(CNumber)*count);
  68. //采用频率分解法进行蝶形运算
  69. for(k=0;k<power;k++)
  70. {
  71. for(j=0;j<1<<k;j++)
  72. {
  73. bfsize=1<<(power-k);
  74. for(i=0;i<bfsize/2;i++)
  75. {
  76. p=j*bfsize;
  77. b[i+p]=Add(a[i+p],a[i+p+bfsize/2]);
  78. b[i+p+bfsize/2]=Mul(Sub(a[i+p],a[i+p+bfsize/2]),w[i*(1<<k)]);
  79. }
  80. }
  81. x=a;
  82. a=b;
  83. b=x;
  84. }
  85. //将乱序的变换序列重新排序
  86. for(j=0;j<count;j++)
  87. {
  88. p=0;
  89. for(i=0;i<power;i++)
  90. {
  91. if(j&(1<<i))
  92. p+=1<<(power-i-1);
  93. }
  94. f[j]=a[p];
  95. }
  96. //释放存储器空间
  97. delete w;
  98. delete a;
  99. delete b;
  100. }
  102. ///////////////////////////////////////////////
  103. //此函数用来实现图象的傅立叶变换
  104. //两次调用快速傅立叶变换QFC()实现二维傅立叶变换
  105. ///////////////////////////////////////////////
  106. void PinYuLuBoDib::QuickFourier()
  107. {
  108. LPBYTE  p_data, p;//指向原图象数据区指针
  109. int width,height;//原图象的宽度和高度       
  110. long w=1,h=1;//进行傅立叶变换的宽度和高度（2的整数次方）
  111. int wp=0,hp=0;//迭代次数
  112. int i,j;
  113. double temp;//中间变量
  114. CNumber *t,*f;
  115.     if(this->byBitCount==8) //灰度图像
  116.    p_data=this->GetData();//指向原图象数据区
  117. else //24位真彩色
  118.    p_data=this->GetData2();
  119. width=this->GetWidth();//得到图象宽度
  120. height=this->GetHeight();//得到图象高度
  121.     long lLineBytes=WIDTHBYTES(width*8);//计算图象每行的字节数
  122. while(w*2<=width)//计算进行傅立叶变换的宽度（2的整数次方）
  123. {
  124. w*=2;
  125. wp++;
  126. }
  127. while(h*2<=height)//计算进行傅立叶变换的高度（2的整数次方）
  128. {
  129. h*=2;
  130. hp++;
  131. }
  132. t=new CNumber[w*h];//分配存储器空间
  133. f=new CNumber[w*h];
  134. for(j=0;j<h;j++)
  135. {
  136. for(i=0;i<w;i++)
  137. {
  138. p=p_data+lLineBytes*(height-j-1)+i;//指向第i行第j列象素
  139. t[i+w*j].re=*(p);//给时域赋值
  140. t[i+w*j].im=0;
  141. }
  142. }
  143. for(j=0;j<h;j++)//在垂直方向上进行快速傅立叶变换
  144. {
  145. QFC(&t[w*j],&f[w*j],wp);
  146. }
  147. for(j=0;j<h;j++)//转换变换结果
  148. {
  149. for(i=0;i<w;i++)
  150. {
  151. t[j+h*i]=f[i+w*j];
  152. }
  153. }
  154. for(j=0;j<w;j++)//水平方向进行快速傅立叶变换
  155. {
  156. QFC(&t[j*h],&f[j*h],hp);
  157. }
  158. for(j=0;j<h;j++)
  159. {
  160. for(i=0;i<w;i++)
  161. {
  162. temp=sqrt(f[i*h+j].re*f[i*h+j].re+f[i*h+j].im*f[i*h+j].im)/100;
  163. if(temp>255)
  164. temp=255;
  166. p=p_data+lLineBytes*(height-(j<h/2?j+h/2:j-h/2)-1)+
  167. (i<w/2?i+w/2:i-w/2);//将变换后的原点移到中心
  169. *(p)=(BYTE)(temp);
  170. }
  171. }
  172. delete t;
  173. delete f;
  174. }
  176. ///////////////////////////////////////////////
  177. //此函数用来实现图象的傅立叶变换(没有对处理后的显示结果进行平移)
  178. //两次调用快速傅立叶变换QFC()实现二维傅立叶变换
  179. ///////////////////////////////////////////////
  180. void PinYuLuBoDib::FirstQuickFourier()
  181. {
  182. LPBYTE  p_data,p;//指向原图象数据区指针
  183. int width,height;//原图象的宽度和高度       
  184. long w=1,h=1;//进行傅立叶变换的宽度和高度（2的整数次方）
  185. int wp=0,hp=0;//迭代次数
  186. int i,j;
  187. double temp;//中间变量
  188. CNumber *t,*f;
  189.     if(this->byBitCount==8)//灰度图像
  190.    p_data=this->GetData();//指向原图象数据区
  191. else//24位真彩色
  192.    p_data=this->GetData2();
  193. width=this->GetWidth();//得到图象宽度
  194. height=this->GetHeight();//得到图象高度
  195.     long lLineBytes=WIDTHBYTES(width*8);//计算图象每行的字节数
  196. while(w*2<=width)//计算进行傅立叶变换的宽度（2的整数次方）
  197. {
  198. w*=2;
  199. wp++;
  200. }
  201. while(h*2<=height)//计算进行傅立叶变换的高度（2的整数次方）
  202. {
  203. h*=2;
  204. hp++;
  205. }
  206. t=new CNumber[w*h];//分配存储器空间
  207. f=new CNumber[w*h];
  208. for(j=0;j<h;j++)
  209. {
  210. for(i=0;i<w;i++)
  211. {
  212. p=p_data+lLineBytes*(height-j-1)+i;//指向第i行第j列象素
  213. t[i+w*j].re=*(p);//给时域赋值
  214. t[i+w*j].im=0;
  215. }
  216. }
  217. for(j=0;j<h;j++)//在垂直方向上进行快速傅立叶变换
  218. {
  219. QFC(&t[w*j],&f[w*j],wp);
  220. }
  221. for(j=0;j<h;j++)//转换变换结果
  222. {
  223. for(i=0;i<w;i++)
  224. {
  225. t[j+h*i]=f[i+w*j];
  226. }
  227. }
  228. for(j=0;j<w;j++)//水平方向进行快速傅立叶变换
  229. {
  230. QFC(&t[j*h],&f[j*h],hp);
  231. }
  232. for(j=0;j<h;j++)
  233. {
  234. for(i=0;i<w;i++)
  235. {
  236. temp=sqrt(f[i*h+j].re*f[i*h+j].re+f[i*h+j].im*f[i*h+j].im)/100;
  237. if(temp>255)
  238. temp=255;
  239. p=p_data+lLineBytes*(height-(j<h/2?j+h/2:j-h/2)-1)+
  240. (i<w/2?i+w/2:i-w/2);//将变换后的原点移到中心
  241. p=p_data+lLineBytes*(height-(j<h/2?j:j)-1)+
  242. (i<w/2?i:i);
  243. *(p)=(BYTE)(temp);
  244. }
  245. }
  246. delete t;
  247. delete f;
  248. }
  251. //////////////////////////////////////////////////////////////
  252. //该函数用来实现二维傅立叶变换
  253. //参数height、width分别表示图象的高度和宽度，ising表示正反变换
  254. //////////////////////////////////////////////////////////////
  255. void PinYuLuBoDib::fourier(double * data, int height, int width, int isign)
  256. {
  257. int idim;
  258. unsigned long i1,i2,i3,i2rev,i3rev,ip1,ip2,ip3,ifp1,ifp2;
  259. unsigned long ibit,k1,k2,n,nprev,nrem,ntot,nn[3];
  260. double tempi,tempr;
  261. double theta,wi,wpi,wpr,wr,wtemp;
  262. ntot=height*width; 
  263. nn[1]=height;
  264. nn[2]=width;
  265. nprev=1;
  266. for (idim=2;idim>=1;idim--) 
  267. {
  268. n=nn[idim];
  269. nrem=ntot/(n*nprev);
  270. ip1=nprev << 1;
  271. ip2=ip1*n;
  272. ip3=ip2*nrem;
  273. i2rev=1;
  274. for (i2=1;i2<=ip2;i2+=ip1)
  275. {
  276. if (i2 < i2rev) 
  277. {
  278. for (i1=i2;i1<=i2+ip1-2;i1+=2) 
  279. {
  280. for (i3=i1;i3<=ip3;i3+=ip2)
  281. {
  282. i3rev=i2rev+i3-i2;
  283. SWAP(data[i3],data[i3rev]);
  284. SWAP(data[i3+1],data[i3rev+1]);
  285. }
  286. }
  287. }
  288. ibit=ip2 >> 1;
  289. while (ibit >= ip1 && i2rev > ibit)
  290. {
  291. i2rev -= ibit;
  292. ibit >>= 1;
  293. }
  294. i2rev += ibit;
  295. }
  296. ifp1=ip1;
  297. while (ifp1 < ip2) 
  298. {
  299. ifp2=ifp1 << 1;
  300. theta=isign*pi*2/(ifp2/ip1);
  301. wtemp=sin(0.5*theta);
  302. wpr = -2.0*wtemp*wtemp;
  303. wpi=sin(theta);
  304. wr=1.0;
  305. wi=0.0;
  306. for (i3=1;i3<=ifp1;i3+=ip1)
  307. {
  308. for (i1=i3;i1<=i3+ip1-2;i1+=2) 
  309. {
  310. for (i2=i1;i2<=ip3;i2+=ifp2) 
  311. {
  312. k1=i2;
  313. k2=k1+ifp1;
  314. tempr=wr*data[k2]-wi*data[k2+1];
  315. tempi=wr*data[k2+1]+wi*data[k2];
  316. data[k2]=data[k1]-tempr;
  317. data[k2+1]=data[k1+1]-tempi;
  318. data[k1] += tempr;
  319. data[k1+1] += tempi;
  320. }
  321. }
  322. wr=(wtemp=wr)*wpr-wi*wpi+wr;
  323. wi=wi*wpr+wtemp*wpi+wi;
  324. }
  325. ifp1=ifp2;
  326. }
  327. nprev *= n;
  328. }
  329. }
  331. /*************************************************************************
  332. * 函数：BWFilterL(int u,int v,int u1,int v1)
  333. *参数：u、v分别是截止频率的x、y分量值，由用户给定
  334. *功能：此函数用来实现图象的布特沃斯低通滤波
  335. /*************************************************************************/
  337. void PinYuLuBoDib::BWFilterL(int u,int v,int n)
  338. {
  339. LPBYTE  p_data, p;//指向原图象数据区指针
  340. int width,height;//原图象的宽度和高度       
  341. int i,j;
  342. double max=0.0,d0,d;//中间变量
  343. double *t,*H;
  344. if(this->byBitCount==8)//灰度图像
  345.    p_data=this->GetData();//指向原图象数据区
  346. else//24位真彩色
  347.    p_data=this->GetData2();//指向原图象数据区
  348. width=this->GetWidth();//得到图象宽度
  349. height=this->GetHeight();//得到图象高度
  350.     long lLineBytes=WIDTHBYTES(width*8);//计算图象每行的字节数
  351. t=new double [height*lLineBytes*2+1];//分配存储器空间
  352. H=new double [height*lLineBytes*2+1];
  353. d0=sqrt(u*u+v*v);//计算截止频率d0
  354. for(j=0;j<height;j++)
  355. {
  356. for(i=0;i<lLineBytes;i++)
  357. {
  358. p=p_data+lLineBytes*j+i;//指向第i行第j列象素
  359. t[(2*lLineBytes)*j+2*i+1]=*(p);//给时域赋值
  360. t[(2*lLineBytes)*j+2*i+2]=0.0;
  361. d=sqrt(i*i+j*j);
  362. H[2*i+(2*lLineBytes)*j+1]=1/(1+pow((d/d0),(2*n)));
  363. H[2*i+(2*lLineBytes)*j+2]=0.0;
  364. }
  365. }
  366.     fourier(t,height,lLineBytes,1);
  367. for(j=1;j<height*lLineBytes*2;j+=2)
  368. {
  369. t[j]=t[j]*H[j]-t[j+1]*H[j+1];
  370. t[j+1]=t[j]*H[j+1]+t[j+1]*H[j];
  371. }
  372. fourier(t,height,lLineBytes,-1);
  373. for(j=0;j<height;j++)
  374. {
  375. for(i=0;i<lLineBytes;i++)
  376. {
  377. t[(2*lLineBytes)*j+2*i+1]=sqrt(t[(2*lLineBytes)*j+2*i+1]*t[(2*lLineBytes)*j+2*i+1]+t[(2*lLineBytes)*j+2*i+2]*t[(2*lLineBytes)*j+2*i+2]);
  378. if(max<t[(2*lLineBytes)*j+2*i+1])
  379. max=t[(2*lLineBytes)*j+2*i+1];
  380. }
  381. }
  382. for(j=0;j<height;j++)
  383. {
  384. for(i=0;i<lLineBytes;i++)
  385. {
  386. p=p_data+lLineBytes*j+i;
  387. *(p)=(BYTE)(t[(2*lLineBytes)*j+2*i+1]*255.0/max);
  388. }
  389. }
  390. delete t;
  391. delete H;
  392. }
  396. ////////////////////////////////////////////////
  397. //此函数用来实现图象的布特沃斯高通滤波
  398. //参数u、v分别是截止频率的x、y分量值，由用户给定
  399. ////////////////////////////////////////////////
  400. void PinYuLuBoDib::BWFilterH(int u,int v,int n)
  401. {
  402. LPBYTE p_data,p;//指向原图象数据区指针
  403. int width,height;//原图象的宽度和高度       
  404. int i,j;
  405. double max=0.0,d0,d;//中间变量
  406. double *t,*H;
  407. if(this->byBitCount==8)//灰度图像
  408.    p_data=this->GetData();//指向原图象数据区
  409. else//24位真彩色
  410.    p_data=this->GetData2();//指向原图象数据区
  411. width=this->GetWidth();//得到图象宽度
  412. height=this->GetHeight();//得到图象高度
  413.     long lLineBytes=WIDTHBYTES(width*8);//计算图象每行的字节数
  414. t=new double [height*lLineBytes*2+1];//分配存储器空间
  415. H=new double [height*lLineBytes*2+1];
  416. d0=sqrt(u*u+v*v);//计算截止频率d0
  417. for(j=0;j<height;j++)
  418. {
  419. for(i=0;i<lLineBytes;i++)
  420. {
  421. p=p_data+lLineBytes*j+i;//指向第i行第j列象素
  422. t[(2*lLineBytes)*j+2*i+1]=*(p);//给时域赋值
  423. t[(2*lLineBytes)*j+2*i+2]=0.0;
  424. d=sqrt(j*j+i*i);
  425. H[2*i+(2*lLineBytes)*j+1]=1/(1+pow((d0/d),(2*n)));
  426. H[2*i+(2*lLineBytes)*j+2]=0.0;
  427. }
  428. }
  429.     fourier(t,height,lLineBytes,1);
  430. for(j=1;j<height*lLineBytes*2;j+=2)
  431. {
  432. t[j]=t[j]*H[j]-t[j+1]*H[j+1];
  433. t[j+1]=t[j]*H[j+1]+t[j+1]*H[j];
  434. }
  435. fourier(t,height,lLineBytes,-1);
  436. for(j=0;j<height;j++)
  437. {
  438. for(i=0;i<lLineBytes;i++)
  439. {
  440. t[(2*lLineBytes)*j+2*i+1]=sqrt(t[(2*lLineBytes)*j+2*i+1]*t[(2*lLineBytes)*j+2*i+1]+t[(2*lLineBytes)*j+2*i+2]*t[(2*lLineBytes)*j+2*i+2]);
  441. if(max<t[(2*lLineBytes)*j+2*i+1])
  442. max=t[(2*lLineBytes)*j+2*i+1];
  443. }
  444. }
  445. for(j=0;j<height;j++)
  446. {
  447. for(i=0;i<lLineBytes;i++)
  448. {
  449. p=p_data+lLineBytes*j+i;
  450. *(p)=(BYTE)(t[(2*lLineBytes)*j+2*i+1]*255.0/max);
  451. }
  452. }
  453. delete t;
  454. delete H;
  455. }
  458. /*************************************************************************
  459. * 函数：PerfectFilterL(int u,int v)
  460. *参数：u、v分别是截止频率的x、y分量值，由用户给定
  461. *功能：此函数用来实现图象的理想低通滤波
  462. /*************************************************************************/
  464.  void PinYuLuBoDib::PerfectFilterL(int u,int v)
  465. {
  466. LPBYTE  p_data, p;//指向原图象数据区指针
  467. int width,height;//原图象的宽度和高度       
  468. int i,j;
  469. double d0,max=0.0;//中间变量
  470. double *t,*H;
  471. if(this->byBitCount==8)//灰度图像
  472. p_data=this->GetData();//指向原图象数据区
  473. else//24位真彩色
  474. p_data=this->GetData2();//指向原图象数据区
  475. width=this->GetWidth();//得到图象宽度
  476. height=this->GetHeight();//得到图象高度
  477.     long lLineBytes=WIDTHBYTES(width*8);//计算图象每行的字节数
  478. t=new double [height*lLineBytes*2+1];//分配存储器空间
  479. H=new double [height*lLineBytes*2+1];
  480. d0=sqrt(u*u+v*v);//计算截止频率d0
  481. for(j=0;j<height;j++)
  482. {
  483. for(i=0;i<lLineBytes;i++)
  484. {
  485. p=p_data+lLineBytes*j+i;//指向第i行第j列象素
  486. t[(2*lLineBytes)*j+2*i+1]=*(p);//给时域赋值
  487. t[(2*lLineBytes)*j+2*i+2]=0.0;
  488. if((sqrt(i*i+j*j))<=d0)
  489. H[2*i+(2*lLineBytes)*j+1]=1.0;
  490. else
  491. H[2*i+(2*lLineBytes)*j+1]=0.0;
  492. H[2*i+(2*lLineBytes)*j+2]=0.0;
  493. }
  494. }
  495.     fourier(t,height,lLineBytes,1);
  496. for(j=1;j<height*lLineBytes*2;j+=2)
  497. {
  498. t[j]=t[j]*H[j]-t[j+1]*H[j+1];
  499. t[j+1]=t[j]*H[j+1]+t[j+1]*H[j];
  500. }
  501. fourier(t,height,lLineBytes,-1);
  502. for(j=0;j<height;j++)
  503. {
  504. for(i=0;i<lLineBytes;i++)
  505. {
  506. t[(2*lLineBytes)*j+2*i+1]=sqrt(t[(2*lLineBytes)*j+2*i+1]*t[(2*lLineBytes)*j+2*i+1]+t[(2*lLineBytes)*j+2*i+2]*t[(2*lLineBytes)*j+2*i+2]);
  507. if(max<t[(2*lLineBytes)*j+2*i+1])
  508. max=t[(2*lLineBytes)*j+2*i+1];
  509. }
  510. }
  511. for(j=0;j<height;j++)
  512. {
  513. for(i=0;i<lLineBytes;i++)
  514. {
  515. p=p_data+lLineBytes*j+i;
  516. *(p)=(BYTE)(t[(2*lLineBytes)*j+2*i+1]*255.0/max);
  517. }
  518. }
  519. delete t;
  520. delete H;
  521. }
  524. ////////////////////////////////////////////////
  525. //此函数用来实现图象的理想高通滤波
  526. //参数u、v分别是截止频率的x、y分量值，由用户给定
  527. ////////////////////////////////////////////////
  528. void PinYuLuBoDib::PerfectFilterH(int u,int v)
  529. {
  530. LPBYTE  p_data, p;//指向原图象数据区指针
  531. int width,height;//原图象的宽度和高度       
  532. int i,j;
  533. double d0,max=0.0;//中间变量
  534. double *t,*H;
  535. if(this->byBitCount==8)//灰度图像
  536. p_data=this->GetData();//指向原图象数据区
  537. else//24位真彩色
  538. p_data=this->GetData2();//指向原图象数据区
  539. width=this->GetWidth();//得到图象宽度
  540. height=this->GetHeight();//得到图象高度
  541.     long lLineBytes=WIDTHBYTES(width*8);//计算图象每行的字节数
  542. t=new double [height*lLineBytes*2+1];//分配存储器空间
  543. H=new double [height*lLineBytes*2+1];
  544. d0=sqrt(u*u+v*v);//计算截止频率d0
  545. for(j=0;j<height;j++)
  546. {
  547. for(i=0;i<lLineBytes;i++)
  548. {
  549. p=p_data+lLineBytes*j+i;//指向第i行第j列象素
  550. t[(2*lLineBytes)*j+2*i+1]=*(p);//给时域赋值
  551. t[(2*lLineBytes)*j+2*i+2]=0.0;
  552. if((sqrt(i*i+j*j))<=d0)
  553. H[2*i+(2*lLineBytes)*j+1]=0.0;
  554. else
  555. H[2*i+(2*lLineBytes)*j+1]=1.0;
  556. H[2*i+(2*lLineBytes)*j+2]=0.0;
  557. }
  558. }
  559.     fourier(t,height,lLineBytes,1);
  560. for(j=1;j<height*lLineBytes*2;j+=2)
  561. {
  562. t[j]=t[j]*H[j]-t[j+1]*H[j+1];
  563. t[j+1]=t[j]*H[j+1]+t[j+1]*H[j];
  564. }
  565. fourier(t,height,lLineBytes,-1);
  566. for(j=0;j<height;j++)
  567. {
  568. for(i=0;i<lLineBytes;i++)
  569. {
  570. t[(2*lLineBytes)*j+2*i+1]=sqrt(t[(2*lLineBytes)*j+2*i+1]*t[(2*lLineBytes)*j+2*i+1]+t[(2*lLineBytes)*j+2*i+2]*t[(2*lLineBytes)*j+2*i+2]);
  571. if(max<t[(2*lLineBytes)*j+2*i+1])
  572. max=t[(2*lLineBytes)*j+2*i+1];
  573. }
  574. }
  575. for(j=0;j<height;j++)
  576. {
  577. for(i=0;i<lLineBytes;i++)
  578. {
  579. p=p_data+lLineBytes*j+i;
  580. *(p)=(BYTE)(t[(2*lLineBytes)*j+2*i+1]*255.0/max);
  581. }
  582. }
  583. delete t;
  584. delete H;
  585. }
  587. /*************************************************************************
  588. * 函数：TLFilter(int u,int v,int u1,int v1)
  589. *参数：u、v分别是截止频率的x、y分量值，由用户给定
  590. *功能：此函数用来实现图象的梯形低通滤波
  591. /*************************************************************************/
  593. void PinYuLuBoDib::TLFilter(int u,int v,int u1,int v1)
  594. {
  595. LPBYTE  p_data, p;//指向原图象数据区指针
  596. int width,height;//原图象的宽度和高度       
  597. int i,j;
  598. double max=0.0,d0,d,d1;//中间变量
  599. double *t,*H;
  601. if(this->byBitCount==8)//灰度图像
  602.    p_data=this->GetData();//指向原图象数据区
  603. else//24位真彩色
  604.    p_data=this->GetData2();//指向原图象数据区
  605. width=this->GetWidth();//得到图象宽度
  606. height=this->GetHeight();//得到图象高度
  607.     long lLineBytes=WIDTHBYTES(width*8);//计算图象每行的字节数
  608. t=new double [height*lLineBytes*2+1];//分配存储器空间
  609. H=new double [height*lLineBytes*2+1];
  610. d0=sqrt(u*u+v*v);//计算截止频率d0
  611. d1=sqrt(u1*u1+v1*v1);
  612. for(j=0;j<height;j++)
  613. {
  614. for(i=0;i<lLineBytes;i++)
  615. {
  616. p=p_data+lLineBytes*j+i;//指向第i行第j列象素
  617. t[(2*lLineBytes)*j+2*i+1]=*(p);//给时域赋值
  618. t[(2*lLineBytes)*j+2*i+2]=0.0;
  619. d=sqrt(i*i+j*j);
  620. if(d<d0)
  621. {
  622. H[2*i+(2*lLineBytes)*j+1]=1;
  623. H[2*i+(2*lLineBytes)*j+2]=0.0;
  624. }
  625. if(d>d1)
  626. {
  627. H[2*i+(2*lLineBytes)*j+1]=0.0;
  628. H[2*i+(2*lLineBytes)*j+2]=0.0;
  629. }
  630. else
  631. {
  632. H[2*i+(2*lLineBytes)*j+1]=(d-d1)/(d0-d1);
  633. H[2*i+(2*lLineBytes)*j+2]=0.0;
  634. }
  635. }
  636. }
  637.     fourier(t,height,lLineBytes,1);
  638. for(j=1;j<height*lLineBytes*2;j+=2)
  639. {
  640. t[j]=t[j]*H[j]-t[j+1]*H[j+1];
  641. t[j+1]=t[j]*H[j+1]+t[j+1]*H[j];
  642. }
  643. fourier(t,height,lLineBytes,-1);
  644. for(j=0;j<height;j++)
  645. {
  646. for(i=0;i<lLineBytes;i++)
  647. {
  648. t[(2*lLineBytes)*j+2*i+1]=sqrt(t[(2*lLineBytes)*j+2*i+1]*t[(2*lLineBytes)*j+2*i+1]+t[(2*lLineBytes)*j+2*i+2]*t[(2*lLineBytes)*j+2*i+2]);
  649. if(max<t[(2*lLineBytes)*j+2*i+1])
  650. max=t[(2*lLineBytes)*j+2*i+1];
  651. }
  652. }
  653. for(j=0;j<height;j++)
  654. {
  655. for(i=0;i<lLineBytes;i++)
  656. {
  657. p=p_data+lLineBytes*j+i;
  658. *(p)=(BYTE)(t[(2*lLineBytes)*j+2*i+1]*255.0/max);
  659. }
  660. }
  661. delete t;
  662. delete H;
  663. }
  666. ////////////////////////////////////////////////
  667. //此函数用来实现图象的梯形高通滤波
  668. //参数u、v分别是截止频率的x、y分量值，由用户给定
  669. ////////////////////////////////////////////////
  670. void PinYuLuBoDib::THFilter(int u,int v,int u1,int v1)
  671. {
  672. LPBYTE  p_data, p;//指向原图象数据区指针
  673. int width,height;//原图象的宽度和高度       
  674. int i,j;
  675. double max=0.0,d0,d,d1;//中间变量
  676. double *t,*H;
  677. if(this->byBitCount==8)//灰度图像
  678. p_data=this->GetData();//指向原图象数据区
  679. else//24位真彩色
  680. p_data=this->GetData2();//指向原图象数据区
  681. width=this->GetWidth();//得到图象宽度
  682. height=this->GetHeight();//得到图象高度
  683.     long lLineBytes=WIDTHBYTES(width*8);//计算图象每行的字节数
  684. t=new double [height*lLineBytes*2+1];//分配存储器空间
  685. H=new double [height*lLineBytes*2+1];
  686. d0=sqrt(u*u+v*v);//计算截止频率d0
  687. d1=sqrt(u1*u1+v1*v1);
  688. for(j=0;j<height;j++)
  689. {
  690. for(i=0;i<lLineBytes;i++)
  691. {
  692. p=p_data+lLineBytes*j+i;//指向第i行第j列象素
  693. t[(2*lLineBytes)*j+2*i+1]=*(p);//给时域赋值
  694. t[(2*lLineBytes)*j+2*i+2]=0.0;
  695. d=sqrt(i*i+j*j);
  697. if(d<d0)
  698. {
  699. H[2*i+(2*lLineBytes)*j+1]=0;
  700. H[2*i+(2*lLineBytes)*j+2]=0.0;
  701. }
  702. if(d>d1)
  703. {
  704. H[2*i+(2*lLineBytes)*j+1]=1;
  705. H[2*i+(2*lLineBytes)*j+2]=0.0;
  706. }
  707. else
  708. {
  709. H[2*i+(2*lLineBytes)*j+1]=(d-d0)/(d1-d0);
  710. H[2*i+(2*lLineBytes)*j+2]=0.0;
  711. }
  712. }
  713. }
  714.     fourier(t,height,lLineBytes,1);
  715. for(j=1;j<height*lLineBytes*2;j+=2)
  716. {
  717. t[j]=t[j]*H[j]-t[j+1]*H[j+1];
  718. t[j+1]=t[j]*H[j+1]+t[j+1]*H[j];
  719. }
  720. fourier(t,height,lLineBytes,-1);
  721. for(j=0;j<height;j++)
  722. {
  723. for(i=0;i<lLineBytes;i++)
  724. {
  725. t[(2*lLineBytes)*j+2*i+1]=sqrt(t[(2*lLineBytes)*j+2*i+1]*t[(2*lLineBytes)*j+2*i+1]+t[(2*lLineBytes)*j+2*i+2]*t[(2*lLineBytes)*j+2*i+2]);
  726. if(max<t[(2*lLineBytes)*j+2*i+1])
  727. max=t[(2*lLineBytes)*j+2*i+1];
  728. }
  729. }
  730. for(j=0;j<height;j++)
  731. {
  732. for(i=0;i<lLineBytes;i++)
  733. {
  734. p=p_data+lLineBytes*j+i;
  735. *(p)=(BYTE)(t[(2*lLineBytes)*j+2*i+1]*255.0/max);
  736. }
  737. }
  738. delete t;
  739. delete H;
  740. }
  742. /*************************************************************************
  743. * 函数：ZLFilter(int u,int v,int u1,int v1)
  744. *参数：u、v分别是截止频率的x、y分量值，由用户给定
  745. *功能：此函数用来实现图象的指数低通滤波
  746. ///////////////////////////////////////////////*/
  747. void PinYuLuBoDib::ZLFilter(int u,int v,int n)
  748. {
  749. LPBYTE  p_data, p;//指向原图象数据区指针
  750. int width,height;//原图象的宽度和高度       
  751. int i,j;
  752. double max=0.0,d0,d;//中间变量
  753. double *t,*H;
  754. if(this->byBitCount==8)//灰度图像
  755. p_data=this->GetData();//指向原图象数据区
  756. else//24位真彩色
  757. p_data=this->GetData2();//指向原图象数据区
  758. width=this->GetWidth();//得到图象宽度
  759. height=this->GetHeight();//得到图象高度
  760.     long lLineBytes=WIDTHBYTES(width*8);//计算图象每行的字节数
  761. t=new double [height*lLineBytes*2+1];//分配存储器空间
  762. H=new double [height*lLineBytes*2+1];
  763. d0=sqrt(u*u+v*v);//计算截止频率d0
  764. for(j=0;j<height;j++)
  765. {
  766. for(i=0;i<lLineBytes;i++)
  767. {
  768. p=p_data+lLineBytes*j+i;//指向第i行第j列象素
  769. t[(2*lLineBytes)*j+2*i+1]=*(p);//给时域赋值
  770. t[(2*lLineBytes)*j+2*i+2]=0.0;
  771. d=sqrt(i*i+j*j);
  772. H[2*i+(2*lLineBytes)*j+1]=exp(-pow((d/d0),n));
  773. H[2*i+(2*lLineBytes)*j+2]=0.0;
  774. }
  775. }
  776.     fourier(t,height,lLineBytes,1);
  777. for(j=1;j<height*lLineBytes*2;j+=2)
  778. {
  779. t[j]=t[j]*H[j]-t[j+1]*H[j+1];
  780. t[j+1]=t[j]*H[j+1]+t[j+1]*H[j];
  781. }
  782. fourier(t,height,lLineBytes,-1);
  783. for(j=0;j<height;j++)
  784. {
  785. for(i=0;i<lLineBytes;i++)
  786. {
  787. t[(2*lLineBytes)*j+2*i+1]=sqrt(t[(2*lLineBytes)*j+2*i+1]*t[(2*lLineBytes)*j+2*i+1]+t[(2*lLineBytes)*j+2*i+2]*t[(2*lLineBytes)*j+2*i+2]);
  788. if(max<t[(2*lLineBytes)*j+2*i+1])
  789. max=t[(2*lLineBytes)*j+2*i+1];
  790. }
  791. }
  792. for(j=0;j<height;j++)
  793. {
  794. for(i=0;i<lLineBytes;i++)
  795. {
  796. p=p_data+lLineBytes*j+i;
  797. *(p)=(BYTE)(t[(2*lLineBytes)*j+2*i+1]*255.0/max);
  798. }
  799. }
  800. delete t;
  801. delete H;
  802. }
  805. ////////////////////////////////////////////////
  806. //此函数用来实现图象的指数高通滤波
  807. //参数u、v分别是截止频率的x、y分量值，由用户给定
  808. ////////////////////////////////////////////////
  809. void PinYuLuBoDib::ZHFilter(int u,int v,int n)
  810. {
  811. LPBYTE  p_data, p;//指向原图象数据区指针
  812. int width,height;//原图象的宽度和高度       
  813. int i,j;
  814. double max=0.0,d0,d;//中间变量
  815. double *t,*H;
  816. if(this->byBitCount==8)//灰度图像
  817. p_data=this->GetData();//指向原图象数据区
  818. else//24位真彩色
  819. p_data=this->GetData2();//指向原图象数据区
  820. width=this->GetWidth();//得到图象宽度
  821. height=this->GetHeight();//得到图象高度
  822.     long lLineBytes=WIDTHBYTES(width*8);//计算图象每行的字节数
  823. t=new double [height*lLineBytes*2+1];//分配存储器空间
  824. H=new double [height*lLineBytes*2+1];
  825. d0=sqrt(u*u+v*v);//计算截止频率d0
  826. for(j=0;j<height;j++)
  827. {
  828. for(i=0;i<lLineBytes;i++)
  829. {
  830. p=p_data+lLineBytes*j+i;//指向第i行第j列象素
  831. t[(2*lLineBytes)*j+2*i+1]=*(p);//给时域赋值
  832. t[(2*lLineBytes)*j+2*i+2]=0.0;
  833. d=sqrt(i*i+j*j);
  834. H[2*i+(2*lLineBytes)*j+1]=exp(-pow((d0/d),n));
  835. H[2*i+(2*lLineBytes)*j+2]=0.0;
  836. }
  837. }
  838.     fourier(t,height,lLineBytes,1);
  839. for(j=1;j<height*lLineBytes*2;j+=2)
  840. {
  841. t[j]=t[j]*H[j]-t[j+1]*H[j+1];
  842. t[j+1]=t[j]*H[j+1]+t[j+1]*H[j];
  843. }
  844. fourier(t,height,lLineBytes,-1);
  845. for(j=0;j<height;j++)
  846. {
  847. for(i=0;i<lLineBytes;i++)
  848. {
  849. t[(2*lLineBytes)*j+2*i+1]=sqrt(t[(2*lLineBytes)*j+2*i+1]*t[(2*lLineBytes)*j+2*i+1]+t[(2*lLineBytes)*j+2*i+2]*t[(2*lLineBytes)*j+2*i+2]);
  850. if(max<t[(2*lLineBytes)*j+2*i+1])
  851. max=t[(2*lLineBytes)*j+2*i+1];
  852. }
  853. }       
  854. for(j=0;j<height;j++)
  855. {
  856. for(i=0;i<lLineBytes;i++)
  857. {
  858. p=p_data+lLineBytes*j+i;
  859. *(p)=(BYTE)(t[(2*lLineBytes)*j+2*i+1]*255.0/max);
  860. }
  861. }
  862. delete t;
  863. delete H;
  864. }