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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 波变换 > 查看源码
fft.cs
资源名称：ImageProcess.rar　[点击查看]
上传用户：c6x6r6
上传日期：2022-07-31
资源大小：515k
文件大小：11k
源码类别：

波变换

开发平台：

Visual Basic

fft.cs：源码内容
  1. using System;
  2. using System.Drawing;
  5. namespace WindowsFormsApplication2
  6. {
  7. /// <summary>
  8. /// Summary description for Class1.
  9. /// </summary>
  10. /// 
  11. public class complexd
  12. {
  13. public double real;
  14. public double im;
  15. public complexd(double x,double y)
  16. {
  17. real=x;
  18. im=y;
  19. }
  20. }
  21. public class MyFFT
  22. {
  23. private int myHeight;
  24. private int myWidth;
  25. private double[][] BitIll;
  27. public MyFFT()
  28. {
  29. InitialBitIll();
  30. }
  31. private void InitialBitIll()
  32. {
  33. BitIll=new double[5][];
  34. BitIll[0]=new double[5];
  35. BitIll[0][0]=0;
  36. BitIll[0][1]=1;
  37. BitIll[0][2]=2;
  38. BitIll[0][3]=1;
  39. BitIll[0][4]=0;
  40. BitIll[1]=new double[5];
  41. BitIll[1][0]=1;
  42. BitIll[1][1]=4;
  43. BitIll[1][2]=8;
  44. BitIll[1][3]=4;
  45. BitIll[1][4]=1;
  46. BitIll[2]=new double[5];
  47. BitIll[2][0]=2;
  48. BitIll[2][1]=8;
  49. BitIll[2][2]=16;
  50. BitIll[2][3]=8;
  51. BitIll[2][4]=2;
  52. BitIll[3]=new double[5];
  53. BitIll[3][0]=1;
  54. BitIll[3][1]=4;
  55. BitIll[3][2]=8;
  56. BitIll[3][3]=4;
  57. BitIll[3][4]=1;
  58. BitIll[4]=new double[5];
  59. BitIll[4][0]=0;
  60. BitIll[4][1]=1;
  61. BitIll[4][2]=2;
  62. BitIll[4][3]=1;
  63. BitIll[4][4]=0;
  64. for(int i=0;i<5;i++)
  65. for(int j=0;j<5;j++)
  66. BitIll[i][j]=BitIll[i][j]/80;
  67. }
  68. private complexd[][] GetBits(Bitmap myBitmap)
  69. {
  70. int height=myBitmap.Height;
  71. int width=myBitmap.Width;
  72. int nHeight=(int) Math.Pow(2,Math.Ceiling(Math.Log(height,2)));
  73. int nWidth=(int) Math.Pow(2,Math.Ceiling(Math.Log(width,2)));
  74. myHeight=height;
  75. myWidth=width;
  76. complexd[][] array=new complexd[nHeight][];
  77. int i,j;
  78. for(i=0;i<=nHeight-1;i++)
  79. {
  80. array[i]=new complexd[nWidth];
  81. for(j=0;j<=nWidth-1;j++)
  82. {
  83. if(i<height&&j<width)
  84. array[i][j]=new complexd(myBitmap.GetPixel(j,i).R,0);
  85. else array[i][j]=new complexd(0,0);
  86. }
  87. }
  88. return array;
  89. }
  90. private double[][] GetArray(Bitmap myBitmap)
  91. {
  92. int height=myBitmap.Height;
  93. int width=myBitmap.Width;
  95. double[][] array=new double[height][];
  96. int i,j;
  97. for(i=0;i<=height-1;i++)
  98. {
  99. array[i]=new double[width];
  100. for(j=0;j<=width-1;j++)
  101. {
  102. array[i][j]=myBitmap.GetPixel(j,i).R;
  103. }
  104. }
  105. return array;
  106. }
  107. private complexd Mux(complexd x1,complexd x2)
  108. {
  109. double real=x1.real*x2.real-x1.im*x2.im;
  110. double im=x1.real*x2.im+x1.im*x2.real;
  111. complexd x=new complexd(real,im);
  112. return x;
  113. }
  114. private complexd Add(complexd x1,complexd x2)
  115. {
  116. complexd x=new complexd(0,0);
  117. x.real=x1.real+x2.real;
  118. x.im=x1.im+x2.im;
  119. return x;
  120. }
  121. private complexd Del(complexd x1,complexd x2)
  122. {
  123. complexd x=new complexd(0,0);
  124. x.real=x1.real-x2.real;
  125. x.im=x1.im-x2.im;
  126. return x;
  127. }
  128. private void BitReverse(int[] br, int m,int N)
  129. {
  130. for(int i=0;i<N;i++)
  131. {
  132. br[i]=i;
  133. }
  134. int lh=N/2;
  135. int j=lh;
  136. int n1=N-2;
  138. for(int i=1;i<=n1;i++)
  139. {
  140. if(i<j)
  141. {
  142. int t=br[i];
  143. br[i]=br[j];
  144. br[j]=t;
  145. }
  146. int k=lh;
  147. while(j>=k)
  148. {
  149. j=j-k;
  150. k/=2;
  151. }
  152. j=j+k;
  153. }
  154. }
  155. private complexd WNR(int N,int r)
  156. {
  157. double x=Math.Cos(((-2)*r*Math.PI)/N);
  158. double y=Math.Sin(((-2)*r*Math.PI)/N);
  159. complexd c=new complexd(x,y);
  160. return c;
  161. }
  162. private complexd IWNR(int N,int r)
  163. {
  164. double x=Math.Cos(((-2)*r*Math.PI)/N);
  165. double y=Math.Sin(((-2)*r*Math.PI)/N);
  166. complexd c=new complexd(x,y);
  167. return c;
  168. }
  169. private complexd[][] Rotate(complexd[][] array)
  170. {
  171. int n=array[0].Length;
  172. complexd[][] ar=new complexd[n][];
  173. for(int i=0;i<n;i++)
  174. {
  175. ar[i]=new complexd[array.Length];
  176. for(int j=0;j<array.Length;j++)
  177. ar[i][j]=array[j][i];
  178. }
  179. return ar;
  180. }
  181. private void Operate(complexd[] array,int i,int j,complexd W)
  182. {
  183. complexd ii=array[i];
  184. complexd jj=array[j];
  185. array[i]=Add(ii,Mux(W,jj));
  186. array[j]=Del(ii,Mux(W,jj));
  187. }
  188. private void FFT1(complexd[] array,int sig)
  189. {
  190. int Width=array.Length;
  191. int bit=(int)Math.Ceiling(Math.Log(Width,2))+1;
  192. int[] br=new int[Width];
  193. BitReverse(br,bit,Width);
  194. complexd[] ar=(complexd[])array.Clone();
  195. for(int i=0;i<Width;i++)
  196. array[i]=ar[br[i]];
  197. int m=(int) Math.Log(Width,2);
  199. for(int l=1;l<=m;l++)
  200. {
  201. int b=(int)Math.Pow(2,l-1);
  202. for(int j=0;j<=b-1;j++)
  203. {
  204. int r=(int)Math.Pow(2,m-l)*j;
  205. for (int k=j;k<=Width-1;k+=(int)Math.Pow(2,l))
  206. {
  207. complexd w;
  208. if(sig==0)
  209. w=WNR(Width,r);
  210. else w=IWNR(Width,r);
  211. Operate(array,k,k+b,w);
  212. }
  213. }
  214. }
  215. if(sig==1)
  216. {
  217. for(int i=0;i<Width;i++)
  218. {
  219. array[i].real=array[i].real/Width;
  220. array[i].im=array[i].im/Width;
  221. }
  222. }
  223. }
  224. private complexd[][] FFT2(complexd[][] PicData,int sig)
  225. {
  226. int height=PicData.Length;
  227. int width=PicData[0].Length;
  228. for(int i=0;i<height;i++)
  229. FFT1(PicData[i],sig);
  230. PicData=Rotate(PicData);
  231. for(int i=0;i<width;i++)
  232. FFT1(PicData[i],sig);
  233. PicData=Rotate(PicData);
  234. return PicData;
  235. }
  236. private complexd[][] FFT2(Bitmap myBitmap)
  237. {
  238. complexd[][] PicData=GetBits(myBitmap);
  239. PicData=FFT2(PicData,0);
  240. PicData=Array2Array(PicData);
  241. return PicData;
  242. }
  243. public Bitmap Butterworth(Bitmap myBitmap,double pass)
  244. {
  245. complexd[][] PicData=FFT2(myBitmap);
  246. Bitmap m=new Bitmap(PicData.Length,PicData[0].Length);
  247. //Bitmap m=new Bitmap(myHeight,myWidth);
  248. double tp=TotalPower(PicData);
  249. int D0=0;
  250. int M=m.Height;
  251. int N=m.Width;
  252. while(true)
  253. {
  254. if(PartPower(PicData,D0)/tp>=pass)
  255. break;
  256. else D0++;
  257. }
  258. complexd[][] f=new complexd[M][];
  260. for(int i=0;i<M;i++)
  261. {
  262. f[i]=new complexd[N];
  263. for(int j=0;j<N;j++)
  264. {
  265. double bt=Math.Sqrt(Math.Pow(Math.Abs(i-M/2),2)+Math.Pow(Math.Abs(j-N/2),2))/D0;
  266. bt=1/(1+Math.Pow(bt,2));
  267. f[i][j]=new complexd(PicData[i][j].real*bt,PicData[i][j].im*bt);
  268. }
  269. }
  270. f=Array2Array(f);
  271. f=FFT2(f,1);
  272. for(int i=0;i<M;i++)
  273. for(int j=0;j<N;j++)
  274. {
  275. int c=(int)r2(f[i][j]);
  276. if(c>255) c=255;
  277. if(c<0) c=0;
  278. m.SetPixel(j,i,Color.FromArgb(c,c,c));
  279. }
  280. m.RotateFlip(RotateFlipType.Rotate180FlipNone);
  281. Rectangle rect=new Rectangle(0,0,myWidth,myHeight);
  282. m=m.Clone(rect,m.PixelFormat);
  283. return m;
  284. }
  286. public Bitmap IdealLowPass(Bitmap myBitmap,double pass)
  287. {
  288. complexd[][] PicData=FFT2(myBitmap);
  289. Bitmap m=new Bitmap(PicData.Length,PicData[0].Length);
  290. double tp=TotalPower(PicData);
  291. int D0=0;
  292. int M=PicData.Length;
  293. int N=PicData[0].Length;
  294. while(true)
  295. {
  296. if(PartPower(PicData,D0)/tp>=pass)
  297. break;
  298. else D0++;
  299. }
  300. complexd[][] f=new complexd[M][];
  302. for(int i=0;i<M;i++)
  303. {
  304. f[i]=new complexd[N];
  305. for(int j=0;j<N;j++)
  306. {
  307. f[i][j]=new complexd(0,0);
  308. if((Math.Pow(Math.Abs(i-M/2),2)+Math.Pow(Math.Abs(j-N/2),2))<=D0*D0)
  309. {
  310. f[i][j]=PicData[i][j];
  311. }
  312. }
  313. }
  314. f=Array2Array(f);
  315. f=FFT2(f,1);
  316. for(int i=0;i<m.Height;i++)
  317. for(int j=0;j<m.Width;j++)
  318. {
  319. int c=(int)r2(f[i][j]);
  320. if(c>255) c=255;
  321. if(c<0) c=0;
  322. m.SetPixel(j,i,Color.FromArgb(c,c,c));
  323. }
  324. m.RotateFlip(RotateFlipType.Rotate180FlipNone);
  325. Rectangle rect=new Rectangle(0,0,myWidth,myHeight);
  326. m=m.Clone(rect,m.PixelFormat);
  327. return m;
  328. }
  329. private double TotalPower(complexd[][] array)
  330. {
  331. double re=0;
  332. for(int i=0;i<array.Length;i++)
  333. for(int j=0;j<array[0].Length;j++)
  334. {
  335. double f=r2(array[i][j]);
  336. re+=f*f;
  337. }
  338. return re;
  339. }
  340. private double PartPower(complexd[][] array,int D0)
  341. {
  342. double re=0;
  343. int M=array.Length;
  344. int N=array[0].Length;
  345. for(int i=0;i<array.Length;i++)
  346. for(int j=0;j<array[0].Length;j++)
  347. {
  348. if((Math.Pow(Math.Abs(i-M/2),2)+Math.Pow(Math.Abs(j-N/2),2))<=D0*D0)
  349. {
  350. double f=r2(array[i][j]);
  351. re+=f*f;
  352. }
  353. }
  354. return re;
  355. }
  356. public complexd[][] Array2Array(complexd[][] array)
  357. {
  359. int M=array[0].Length;
  360. int N=array.Length;
  361. complexd[][] re=new complexd[N][];
  362. for(int i=0;i<N/2;i++)
  363. {
  364. re[i]=new complexd[M];
  365. for(int j=0;j<M/2;j++)//1
  366. {
  367. re[i][j]=array[i+N/2][j+M/2];
  368. }
  369. for(int j=M/2;j<M;j++)//2
  370. {
  371. re[i][j]=array[i+N/2][j-M/2];
  372. }
  373. }
  374. for(int i=N/2;i<N;i++)//4
  375. {
  376. re[i]=new complexd[M];
  377. for(int j=0;j<M/2;j++)
  378. {
  379. re[i][j]=array[i-N/2][j+M/2];
  380. }
  381. for(int j=M/2;j<M;j++)
  382. {
  383. re[i][j]=array[i-N/2][j-M/2];
  384. }
  385. }
  386. return re;
  387. }
  389. private double r2(complexd c)
  390. {
  391. return Math.Sqrt(c.real*c.real+c.im*c.im);
  392. }
  393. public Bitmap GetFFTPic(Bitmap myBitmap)
  394. {
  395. complexd[][] PicData=GetBits(myBitmap);
  396. PicData=FFT2(PicData,0);
  397. complexd[][] PicData1=Array2Array(PicData);
  398. double[][] data=GetPowerData(PicData1);
  399. double[] maxmin=GetMaxMinData(data);
  400. maxmin[0]=(int)Math.Log(1+maxmin[0],Math.E);
  401. maxmin[1]=(int)Math.Log(1+maxmin[1],Math.E);
  402. Bitmap m=new Bitmap(PicData1.Length,PicData1[0].Length);
  403. for(int i=0;i<m.Height;i++)
  404. for(int j=0;j<m.Width;j++)
  405. {
  406. int c=(255/(int)(maxmin[0]-maxmin[1]))*((int)Math.Log(1+data[i][j],Math.E));
  407. if(c>255) c=255;
  408. if(c<0) c=0;
  409. m.SetPixel(j,i,Color.FromArgb(c,c,c));
  410. }
  411. return m;
  412. }
  413. private double[][] GetPowerData(complexd[][] array)
  414. {
  415. double[][] re=new double[array.Length][];
  416. for(int i=0;i<array.Length;i++)
  417. {
  418. re[i]=new double[array[0].Length];
  419. for(int j=0;j<array[0].Length;j++)
  420. {
  421. re[i][j]=r2(array[i][j]);
  422. }
  423. }
  424. return re;
  425. }
  426. private double[] GetMaxMinData(double[][] array)
  427. {
  428. double[] re=new double[2];
  429. re[0]=array[0][0];
  430. re[1]=array[0][0];
  431. for(int i=0;i<array.Length;i++)
  432. for(int j=0;j<array[0].Length;j++)
  433. {
  434. if(array[i][j]>re[0]) re[0]=array[i][j];
  435. else re[1]=array[i][j];
  436. }
  437. return re;
  438. }
  439. public double GetError(Bitmap myBitmap1,Bitmap myBitmap2)
  440. {
  441. double[][] array1=GetArray(myBitmap1);
  442. double[][] array2=GetArray(myBitmap2);
  443. double re=0;
  444. for(int i=0;i<=array1.Length-1;i++)
  445. for(int j=0;j<=array1[0].Length-1;j++)
  446. {
  447. re+=Math.Pow((array1[i][j]-array2[i][j]),2);
  448. }
  449. re=re/(array1.Length*array1[0].Length);
  450. re=Math.Sqrt(re);
  451. return re;
  452. }
  454. private double GetError(double[][] array1,double[][] array2)
  455. {
  456. double re=0;
  457. for(int i=0;i<=array1.Length-1;i++)
  458. for(int j=0;j<=array1[0].Length-1;j++)
  459. {
  460. re+=Math.Pow((array1[i][j]-array2[i][j]),2);
  461. }
  462. re=re/(array1.Length*array1[0].Length);
  463. re=Math.Sqrt(re);
  464. return re;
  465. }
  469. }
  471. }