字符分割源代码（效果还可以）

1. void FFTGabor::GaborTransform(int * lpDIBBits, LONG lWidth, LONG lHeight, int Orientation, int Frequency, FFTGaborResult * result)
   
2. {
   
3.         LONG        i;
   
4.         LONG        j;
   
5. 
   
6.         complex<double> *TD = new complex<double>[complexWidth * complexHeight];
   
7.         complex<double> *FD = new complex<double>[complexWidth * complexHeight];
   
8.         
   
9.         // 行
   
10.         for(i = 0; i < lHeight; i++) 
    
11.         {
    
12.                 // 列
    
13.                 for(j = 0; j < lWidth; j++)
    
14.                 {
    
15.                         // 给时域赋值
    
16.                         TD[j + complexWidth * i] = complex<double>(lpDIBBits[j+lWidth * i], 0);
    
17.                 }
    
18.         }
    
19.         ::FFT2(TD,complexWidth , complexHeight);
    
20.         
    
21.         //::IFFT2(TD,256,256);
    
22.         //在频域执行卷积
    
23.         double scale = 1.0 / (complexWidth * complexHeight); 
    
24.         
    
25.         for( i=0; i<complexWidth * complexHeight; i++)
    
26.                 FD[i] = TD[i] * KernelFFT2[Orientation * 4 + Frequency][i] ; // * scale; 
    
27.         
    
28.         IFFT2(FD,complexWidth , complexHeight);
    
29.         
    
30.         //计算均值、方差及结果
    
31.         //计算均值并找出tmpMag中的最大最小值，以便调整到0～255，用于显示输出。
    
32.         double min, max;
    
33.         double Sum=0, Avg=0, Deta=0;
    
34.         double tmpModulus=0;
    
35.         double * tmpMag = new double[lWidth*lHeight] ;// [128][128] ;
    
36.         int x ,y;
    
37.         tmpModulus = sqrt(FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].real() *
    
38.                                                                 FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].real() +
    
39.                                                                 FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].imag() *
    
40.                                                                 FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].imag());
    
41.         min = max = tmpModulus;
    
42.         for( y=(GaborHeight/2); y<(GaborHeight/2)+lHeight; y++){
    
43.                 for( x=(GaborWidth/2); x<(GaborWidth/2)+lWidth; x++)
    
44.                 {
    
45.                         tmpModulus = sqrt(FD[y*complexWidth+x].real() * FD[y*complexWidth+x].real() +
    
46.                                 FD[y*complexWidth+x].imag() * FD[y*complexWidth+x].imag());
    
47.                         
    
48.                         if(min>tmpModulus)
    
49.                                 min = tmpModulus;
    
50.                         if(max<tmpModulus)
    
51.                                 max = tmpModulus;        
    
52.                         
    
53.                         Sum += tmpModulus;
    
54.                         tmpMag[(y-(GaborHeight/2))* lWidth + (x-(GaborWidth/2))] = tmpModulus;
    
55.                 }
    
56.         }
    
57.         Avg = Sum / (lHeight * lWidth);
    
58.         //计算方差
    
59.         for( y=0; y < lHeight; y++){
    
60.                 for( x=0; x < lWidth; x++)
    
61.                         Deta += (tmpMag[y* lWidth + x] - Avg)*(tmpMag[y* lWidth + x] - Avg);
    
62.         }
    
63.         Deta = Deta / (lHeight * lWidth);
    
64.         
    
65.         //计算magShow以及均值
    
66.         scale = 255.0/(max-min);
    
67.         
    
68.         for( y=0; y < lHeight; y++){
    
69.                 for( x=0; x < lWidth; x++)
    
70.                 {
    
71.                         result->magShow[y * lWidth + x] = (int)(scale*(tmpMag[y* lWidth + x]-min));
    
72.                 }
    
73.         }
    
74.         result->Avg = Avg;
    
75.         result->Deta = Deta;
    
76.         
    
77.         delete[] tmpMag;
    
78. 
    
79.         delete[] FD;
    
80.         delete[] TD;
    
81. }
    
82. 
    
83. void FFTGabor::intTocomplex(complex<double> * TD,int * lpDIBBits,LONG lWidth, LONG lHeight)
    
84. {
    
85.         LONG        i;
    
86.         LONG        j;
    
87. 
    
88. //        complex<double> *TD = new complex<double>[complexWidth * complexHeight];
    
89.         
    
90.         // 行
    
91.         for(i = 0; i < lHeight; i++) 
    
92.         {
    
93.                 // 列
    
94.                 for(j = 0; j < lWidth; j++)
    
95.                 {
    
96.                         // 给时域赋值
    
97.                         TD[j + complexWidth * i] = complex<double>(lpDIBBits[j+lWidth * i], 0);
    
98.                 }
    
99.         }
    
100.         ::FFT2(TD,complexWidth , complexHeight);
     
101. 
     
102. }
     
103. void FFTGabor::GaborTransform(complex<double> *TD, LONG lWidth, LONG lHeight, double * TransformResult)
     
104. {
     
105.         // 循环变量
     
106.         LONG        i;
     
107. //        LONG        j;
     
108.         int Orientation, Frequency ;
     
109.         // 分配内存
     
110.         complex<double> *FD = new complex<double>[complexWidth * complexHeight];
     
111.         
     
112.         double scale = 1.0 / (complexWidth * complexHeight); 
     
113.         double Sum=0, Avg=0, Deta=0;
     
114.         double tmpModulus=0;
     
115.         double * tmpMag = new double[lWidth*lHeight] ;// [128][128] ;
     
116.         int x ,y;
     
117.         
     
118.         for( Orientation=0; Orientation<8; Orientation++){
     
119.                 for( Frequency=0; Frequency<4; Frequency++)
     
120.                 {
     
121.                         //在频域执行卷积
     
122.                         for( i=0; i<complexWidth * complexHeight; i++)
     
123.                                 FD[i] = TD[i] * KernelFFT2[Orientation * 4 + Frequency][i] ; // * scale; 
     
124.                         
     
125.                         IFFT2(FD,complexWidth , complexHeight);
     
126.                         
     
127.                         //计算均值、方差及结果
     
128.                         Sum=0, Avg=0, Deta=0;
     
129.                         
     
130.                         for( y=(GaborHeight/2); y<(GaborHeight/2)+lHeight; y++){
     
131.                                 for( x=(GaborWidth/2); x<(GaborWidth/2)+lWidth; x++)
     
132.                                 {
     
133.                                         tmpModulus = sqrt(FD[y*complexWidth+x].real() * FD[y*complexWidth+x].real() +
     
134.                                                 FD[y*complexWidth+x].imag() * FD[y*complexWidth+x].imag());
     
135.                                         
     
136.                                         Sum += tmpModulus;
     
137.                                         tmpMag[(y-(GaborHeight/2)) * lWidth + (x-(GaborWidth/2))] = tmpModulus;
     
138.                                 }
     
139.                         }
     
140.                         Avg = Sum / (lHeight * lWidth);
     
141.                         //计算方差
     
142.                         for( y=0; y < lHeight; y++){
     
143.                                 for( x=0; x < lWidth; x++)
     
144.                                         Deta += (tmpMag[y* lWidth + x] - Avg)*(tmpMag[y* lWidth + x] - Avg);
     
145.                         }
     
146.                         Deta = Deta / (lHeight * lWidth);
     
147.                         
     
148. 
     
149.                         TransformResult[(Orientation * 4 + Frequency)*2] = Avg;
     
150.                         TransformResult[(Orientation * 4 + Frequency)*2+1] = Deta;
     
151.                 }
     
152.         }
     
153.         
     
154.         delete[] tmpMag;
     
155.         delete[] FD;
     
156. }
     
157. 
     
158. void FFTGabor::GaborTransform(complex<double> *TD, LONG lWidth, LONG lHeight, int Orientation, int Frequency, FFTGaborResult * result)
     
159. {
     
160.         LONG        i;
     
161. //        LONG        j;
     
162. 
     
163.         complex<double> *FD = new complex<double>[complexWidth * complexHeight];
     
164.         
     
165. 
     
166.         //在频域执行卷积
     
167.         double scale = 1.0 / (complexWidth * complexHeight); 
     
168.         
     
169.         for( i=0; i<complexWidth * complexHeight; i++)
     
170.                 FD[i] = TD[i] * KernelFFT2[Orientation * 4 + Frequency][i] ; // * scale; 
     
171.         
     
172.         IFFT2(FD,complexWidth , complexHeight);
     
173.         
     
174.         //计算均值、方差及结果
     
175.         //计算均值并找出tmpMag中的最大最小值，以便调整到0～255，用于显示输出。
     
176.         double min, max;
     
177.         double Sum=0, Avg=0, Deta=0;
     
178.         double tmpModulus=0;
     
179.         double * tmpMag = new double[lWidth*lHeight] ;// [128][128] ;
     
180.         int x ,y;
     
181.         tmpModulus = sqrt(FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].real() *
     
182.                                                                 FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].real() +
     
183.                                                                 FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].imag() *
     
184.                                                                 FD[(GaborHeight/2)*complexWidth+(GaborWidth/2)].imag());
     
185.         min = max = tmpModulus;
     
186.         for( y=(GaborHeight/2); y<(GaborHeight/2)+lHeight; y++){
     
187.                 for( x=(GaborWidth/2); x<(GaborWidth/2)+lWidth; x++)
     
188.                 {
     
189.                         tmpModulus = sqrt(FD[y*complexWidth+x].real() * FD[y*complexWidth+x].real() +
     
190.                                 FD[y*complexWidth+x].imag() * FD[y*complexWidth+x].imag());
     
191.                         
     
192.                         if(min>tmpModulus)
     
193.                                 min = tmpModulus;
     
194.                         if(max<tmpModulus)
     
195.                                 max = tmpModulus;        
     
196.                         
     
197.                         Sum += tmpModulus;
     
198.                         tmpMag[(y-(GaborHeight/2))* lWidth + (x-(GaborWidth/2))] = tmpModulus;
     
199.                 }
     
200.         }
     
201.         Avg = Sum / (lHeight * lWidth);
     
202.         //计算方差
     
203.         for( y=0; y < lHeight; y++){
     
204.                 for( x=0; x < lWidth; x++)
     
205.                         Deta += (tmpMag[y* lWidth + x] - Avg)*(tmpMag[y* lWidth + x] - Avg);
     
206.         }
     
207.         Deta = Deta / (lHeight * lWidth);
     
208.         
     
209.         //计算magShow以及均值
     
210.         scale = 255.0/(max-min);
     
211.         
     
212.         for( y=0; y < lHeight; y++){
     
213.                 for( x=0; x < lWidth; x++)
     
214.                 {
     
215.                         result->magShow[y * lWidth + x] = (int)(scale*(tmpMag[y* lWidth + x]-min));
     
216.                 }
     
217.         }
     
218.         result->Avg = Avg;
     
219.         result->Deta = Deta;
     
220.         
     
221.         delete[] tmpMag;
     
222. 
     
223.         delete[] FD;
     
224. }