巴特沃斯滤波器c语言
1. 模拟滤波器的设计
1.1巴特沃斯滤波器的次数
根据给定的参数设计模拟滤波器，然后进行变数变换，求取数字滤波器的方法，称为滤波器的间接设计。做为数字滤波器的设计基础的模拟滤波器，称之为原型滤波器。这里，我们首先介绍的是最简单最基础的原型滤波器，巴特沃斯低通滤波器。由于IIR滤波器不具有线性相位特性，因此不必考虑相位特性，直接考虑其振幅特性。
在这里，N是滤波器的次数，Ωc是截止频率。从上式的振幅特性可以看出，这个是单调递减的函数，其振幅特性是不存在纹波的。设计的时候，一般需要先计算跟所需要设计参数相符合的次数N。首先，就需要先由阻带频率，计算出阻带衰减
将巴特沃斯低通滤波器的振幅特性，直接带入上式，则有
最后，可以解得次数N为
当然，这里的N只能为正数，因此，若结果为小数，则舍弃小数，向上取整。
1.2巴特沃斯滤波器的传递函数
巴特沃斯低通滤波器的传递函数，可由其振幅特性的分母多项式求得。其分母多项式
根据S解开，可以得到极点。这里，为了方便处理，我们分为两种情况去解这个方程。当N为偶数的时候，
这里，使用了欧拉公式。同样的，当N为奇数的时候，
同样的，这里也使用了欧拉公式。归纳以上，极点的解为
上式所求得的极点，是在s平面内，在半径为Ωc的圆上等间距的点，其数量为2N个。为了使得其IIR滤
波器稳定，那么，只能选取极点在S平面左半平面的点。选定了稳定的极点之后，其模拟滤波器的传递函数就可由下式求得。
1.3巴特沃斯滤波器的实现（C语言）
首先，是次数的计算。次数的计算，我们可以由下式求得。
其对应的C语言程序为
[cpp]view plaincopy
1.N = Ceil(0.5*( log10 ( pow (10, Stopband_attenuation/10) - 1) /
2. log10 (Stopband/Cotoff) ));
然后是极点的选择，这里由于涉及到复数的操作，我们就声明一个复数结构体就可以了。最重要的是，极点的计算含有自然指数函数，这点对于计算机来讲，不是太方便，所以，我们将其替换为三角函数，
这样的话，实部与虚部就还可以分开来计算。其代码实现为
[cpp]view plaincopy
1.typedef struct
2.{
3.double Real_part;
4.double Imag_Part;
5.} COMPLEX;
6.
7.
https://www.360docs.net/doc/1311173303.html,PLEX poles[N];
9.
10.for(k = 0;k <= ((2*N)-1) ; k++)
11.{
12.if(Cotoff*cos((k+dk)*(pi/N)) < 0)
13. {
14. poles[count].Real_part = -Cotoff*cos((k+dk)*(pi/N));
15.poles[count].Imag_Part= -Cotoff*sin((k+dk)*(pi/N));
16. count++;
17.if (count == N) break;
18. }
19.}
计算出稳定的极点之后，就可以进行传递函数的计算了。传递的函数的计算，就像下式一样
这里，为了得到模拟滤波器的系数，需要将分母乘开。很显然，这里的极点不一定是整数，或者来说，这里的乘开需要做复数运算。其复数的乘法代码如下，
[cpp]view plaincopy
1.int Complex_Multiple(COMPLEX a,COMPLEX b,
2.double *Res_Real,double *Res_Imag)
3.
4.{
5. *(Res_Real) = (a.Real_part)*(b.Real_part) - (a.Imag_Part)*(b.Imag_Part);
6. *(Res_Imag)= (a.Imag_Part)*(b.Real_part) + (a.Real_part)*(b.Imag_Part);
7.return (int)1;
8.}
有了乘法代码之后，我们现在简单的情况下，看看其如何计算其滤波器系数。我们做如下假设
这个时候，其传递函数为
将其乘开，其大致的关系就像下图所示一样。
计算的关系一目了然，这样的话，实现就简单多了。高阶的情况下也一样，重复这种计算就可以了。其代码为
[cpp]view plaincopy
1. Res[0].Real_part = poles[0].Real_part;
2. Res[0].Imag_Part= poles[0].Imag_Part;
3. Res[1].Real_part = 1;
4. Res[1].Imag_Part= 0;
5.
6.for(count_1 = 0;count_1 < N-1;count_1++)
7.{
8.for(count = 0;count <= count_1 + 2;count++)
9. {
10.if(0 == count)
11.{
12. Complex_Multiple(Res[count], poles[count_1+1],
13. &(Res_Save[count].Real_part),
14. &(Res_Save[count].Imag_Part));
15. }
16.else if((count_1 + 2) == count)
17. {
18. Res_Save[count].Real_part += Res[count - 1].Real_part;
19.Res_Save[count].Imag_Part += Res[count - 1].Imag_Part;
20. }
21.else
22.{
23. Complex_Multiple(Res[count], poles[count_1+1],
24. &(Res_Save[count].Real_part),
25. &(Res_Save[count].Imag_Part));
26.1 Res_Save[count].Real_part += Res[count - 1].Real_part;
27. Res_Save[count].Imag_Part += Res[count - 1].Imag_Part;
28.}
29. }
30.*(b+N) = *(a+N);
到此，我们就可以得到一个模拟滤波器巴特沃斯低通滤波器了。
2.双1次z变换
2.1双1次z变换的原理
我们为了将模拟滤波器转换为数字滤波器的，可以用的方法很多。这里着重说说双1次z变换。我们希望通过双1次z变换，建立一个s平面到z平面的映射关系，将模拟滤波器转换为数字滤波器。
和之前的例子一样，我们假设有如下模拟滤波器的传递函数。
将其做拉普拉斯逆变换，可得到其时间域内的连续微分方程式，
其中，x(t)表示输入，y(t)表示输出。然后我们需要将其离散化，假设其采样周期是T，用差分方程去近似的替代微分方程，可以得到下面结果
然后使用z变换，再将其化简。可得到如下结果
从而，我们可以得到了s平面到z平面的映射关系，即
由于所有的高阶系统都可以视为一阶系统的并联，所以，这个映射关系在高阶系统中，也是成立的。
然后，将关系式
带入上式，可得
到这里，我们可以就可以得到Ω与ω的对应关系了。
这里的Ω与ω的对应关系很重要。我们最终的目的设计的是数字滤波器，所以，设计时候给的参数
必定是数字滤波器的指标。而我们通过间接设计设计IIR滤波器时候，首先是要设计模拟滤波器，再通过变换，得到数字滤波器。那么，我们首先需要做的，就是将数字滤波器的指标，转换为模拟滤波器的指标，基
于这个指标去设计模拟滤波器。另外，这里的采样时间T的取值很随意，为了方便计算，一般取1s就可以。
2.2双1次z变换的实现（C语言）
我们设计好的巴特沃斯低通滤波器的传递函数如下所示。
我们将其进行双1次z变换，我们可以得到如下式子
可以看出，我们还是需要将式子乘开，进行合并同类项，这个跟之前说的算法相差不大。其代码为。[cpp]view plaincopy
1.for(Count = 0;Count<=N;Count++)
2. {
3.for(Count_Z = 0;Count_Z <= N;Count_Z++)
4. {
5. Res[Count_Z] = 0;
6. Res_Save[Count_Z] = 0;
7. }
8. Res_Save [0] = 1;
9.for(Count_1 = 0; Count_1 < N-Count;Count_1++)
10. {
11.for(Count_2 = 0; Count_2 <= Count_1+1;Count_2++)
12. {
13.if(Count_2 == 0) Res[Count_2] += Res_Save[Count_2];
14.else if((Count_2 == (Count_1+1))&&(Count_1 != 0))
15. Res[Count_2] += -Res_Save[Count_2 - 1];
16.else Res[Count_2] += Res_Save[Count_2] - Res_Save[Count_2 - 1];
17.for(Count_Z = 0;Count_Z<= N;Count_Z++)
18.{
19. Res_Save[Count_Z] = Res[Count_Z] ;
20.Res[Count_Z] = 0;
21.}
22. }
23.for(Count_1 = (N-Count); Count_1 < N;Count_1++)
24. {
25.for(Count_2 = 0; Count_2 <= Count_1+1;Count_2++)
26. {
27.if(Count_2 == 0) Res[Count_2] += Res_Save[Count_2];
28.else if((Count_2 == (Count_1+1))&&(Count_1 != 0))
29. Res[Count_2] += Res_Save[Count_2 - 1];
30.else
31. Res[Count_2] += Res_Save[Count_2] + Res_Save[Count_2 - 1];
32.}
33.for(Count_Z = 0;Count_Z<= N;Count_Z++)
34. {
35. Res_Save[Count_Z] = Res[Count_Z] ;
36. Res[Count_Z] = 0;
37. }
38. }
39.for(Count_Z = 0;Count_Z<= N;Count_Z++)
40. {
41. *(az+Count_Z) += pow(2,N-Count) * (*(as+Count)) *
42.Res_Save[Count_Z];
43. *(bz+Count_Z) += (*(bs+Count)) * Res_Save[Count_Z];
44. }
45. }
到此，我们就已经实现了一个数字滤波器。
3.IIR滤波器的间接设计代码（C语言）
[cpp]view plaincopy
1.#include
2.#include
3.#include
4.#include
5.
6.
7.#define pi ((double)3.1415926)
8.
9.
10.struct DESIGN_SPECIFICATION
11.{
12.double Cotoff;
13.double Stopband;
14.double Stopband_attenuation;
15.};
16.
17.typedef struct
18.{
19.double Real_part;
20.double Imag_Part;
21.} COMPLEX;
22.
23.
24.
25.int Ceil(double input)
26.{
27.if(input != (int)input) return ((int)input) +1;
28.else return ((int)input);
29.}
30.
31.
32.int Complex_Multiple(COMPLEX a,COMPLEX b
33. ,double *Res_Real,double *Res_Imag)
34.
35.{
36. *(Res_Real) = (a.Real_part)*(b.Real_part) - (a.Imag_Part)*(b.Imag_Part);
37. *(Res_Imag)= (a.Imag_Part)*(b.Real_part) + (a.Real_part)*(b.Imag_Part);
38.return (int)1;
39.}
40.
41.
42.int Buttord(double Cotoff,
43.double Stopband,
44.double Stopband_attenuation)
45.{
46.int N;
47.
48. printf("Wc = %lf [rad/sec] \n" ,Cotoff);
49. printf("Ws = %lf [rad/sec] \n" ,Stopband);
50. printf("As = %lf [dB] \n" ,Stopband_attenuation);
51. printf("--------------------------------------------------------\n" );
52.
53. N = Ceil(0.5*( log10 ( pow (10, Stopband_attenuation/10) - 1) /
54. log10 (Stopband/Cotoff) ));
55.
56.
57.return (int)N;
58.}
59.
60.
61.int Butter(int N, double Cotoff,
62.double *a,
63.double *b)
64.{
65.double dk = 0;
66.int k = 0;
67.int count = 0,count_1 = 0;
68. COMPLEX poles[N];
69. COMPLEX Res[N+1],Res_Save[N+1];
70.
71.if((N%2) == 0) dk = 0.5;
72.else dk = 0;
73.
74.for(k = 0;k <= ((2*N)-1) ; k++)
75. {
76.if(Cotoff*cos((k+dk)*(pi/N)) < 0)
77. {
78. poles[count].Real_part = -Cotoff*cos((k+dk)*(pi/N));
79. poles[count].Imag_Part= -Cotoff*sin((k+dk)*(pi/N));
80. count++;
81.if (count == N) break;
82. }
83. }
84.
85. printf("Pk = \n" );
86.for(count = 0;count < N ;count++)
87. {
88. printf("(%lf) + (%lf i) \n" ,-poles[count].Real_part
89. ,-poles[count].Imag_Part);
90. }
91. printf("--------------------------------------------------------\n" );
92.
93. Res[0].Real_part = poles[0].Real_part;
94. Res[0].Imag_Part= poles[0].Imag_Part;
95.
96. Res[1].Real_part = 1;
97. Res[1].Imag_Part= 0;
98.
99.for(count_1 = 0;count_1 < N-1;count_1++)
100. {
101.for(count = 0;count <= count_1 + 2;count++)
102. {
103.if(0 == count)
104. {
105. Complex_Multiple(Res[count], poles[count_1+1], 106. &(Res_Save[count].Real_part), 107. &(Res_Save[count].Imag_Part));
108.//printf( "Res_Save : (%lf) + (%lf i) \n" ,Res_Save[0].Real_part,Res_S ave[0].Imag_Part);
109. }
110.
111.else if((count_1 + 2) == count)
112. {
113. Res_Save[count].Real_part += Res[count - 1].Real_part;
114. Res_Save[count].Imag_Part += Res[count - 1].Imag_Part;
115. }
116.else
117. {
118. Complex_Multiple(Res[count], poles[count_1+1],
119. &(Res_Save[count].Real_part),
120. &(Res_Save[count].Imag_Part));
121.
122.//printf( "Res : (%lf) + (%lf i) \n" ,Res[count - 1].Real_part,Res[count - 1].Imag_Part);
123.//printf( "Res_Save : (%lf) + (%lf i) \n" ,Res_Save[count].Real_part, Res_Save[count].Imag_Part);
124.
125. Res_Save[count].Real_part += Res[count - 1].Real_part;
126. Res_Save[count].Imag_Part += Res[count - 1].Imag_Part;
127.
128.//printf( "Res_Save : (%lf) + (%lf i) \n" ,Res_Save[count].Real_part, Res_Save[count].Imag_Part);
129.
130. }
131.//printf("There \n" );
132. }
133.
134.for(count = 0;count <= N;count++)
135. {
136. Res[count].Real_part = Res_Save[count].Real_part;
137. Res[count].Imag_Part= Res_Save[count].Imag_Part;
138.
139. *(a + N - count) = Res[count].Real_part;
140. }
141.
142.//printf("There!! \n" );
143.
144. }
145.
146. *(b+N) = *(a+N);
147.
148.//------------------------display---------------------------------//
149. printf("bs = [" );
150.for(count = 0;count <= N ;count++)
151. {
152. printf("%lf ", *(b+count));
153. }
154. printf(" ] \n" );
155.
156. printf("as = [" );
157.for(count = 0;count <= N ;count++)
158. {
159. printf("%lf ", *(a+count));
160. }
161. printf(" ] \n" );
162.
163. printf("--------------------------------------------------------\n" );
164.
165.return (int) 1;
166.}
167.
168.
169.int Bilinear(int N,
170.double *as,double *bs,
171.double *az,double *bz)
172.{
173.int Count = 0,Count_1 = 0,Count_2 = 0,Count_Z = 0;
174.double Res[N+1];
175.double Res_Save[N+1];
176.
177.for(Count_Z = 0;Count_Z <= N;Count_Z++)
178. {
179. *(az+Count_Z) = 0;
180. *(bz+Count_Z) = 0;
181. }
182.
183.
184.for(Count = 0;Count<=N;Count++)
185. {
186.for(Count_Z = 0;Count_Z <= N;Count_Z++)
187. {
188. Res[Count_Z] = 0;
189. Res_Save[Count_Z] = 0;
190. }
191. Res_Save [0] = 1;
192.
193.for(Count_1 = 0; Count_1 < N-Count;Count_1++)
194. {
195.for(Count_2 = 0; Count_2 <= Count_1+1;Count_2++)
196. {
197.if(Count_2 == 0)
198. {
199. Res[Count_2] += Res_Save[Count_2];
200.//printf( "Res[%d] %lf \n" , Count_2 ,Res[Count_2]);
201. }
202.
203.else if((Count_2 == (Count_1+1))&&(Count_1 != 0))
204. {
205. Res[Count_2] += -Res_Save[Count_2 - 1];
206.//printf( "Res[%d] %lf \n" , Count_2 ,Res[Count_2]); 207. }
208.
209.else
210. {
211. Res[Count_2] += Res_Save[Count_2] - Res_Save[Count_2 - 1]; 212.//printf( "Res[%d] %lf \n" , Count_2 ,Res[Count_2]);
213. }
214. }
215.
216.//printf( "Res : ");
217.for(Count_Z = 0;Count_Z<= N;Count_Z++)
218. {
219. Res_Save[Count_Z] = Res[Count_Z] ;
220. Res[Count_Z] = 0;
221.//printf( "[%d] %lf " ,Count_Z, Res_Save[Count_Z]);
222. }
223.//printf(" \n" );
224.
225. }
226.
227.for(Count_1 = (N-Count); Count_1 < N;Count_1++)
228. {
229.for(Count_2 = 0; Count_2 <= Count_1+1;Count_2++)
230. {
231.if(Count_2 == 0)
232. {
233. Res[Count_2] += Res_Save[Count_2];
234.//printf( "Res[%d] %lf \n" , Count_2 ,Res[Count_2]);
235. }
236.
237.else if((Count_2 == (Count_1+1))&&(Count_1 != 0))
238. {
239. Res[Count_2] += Res_Save[Count_2 - 1];
240.//printf( "Res[%d] %lf \n" , Count_2 ,Res[Count_2]); 241. }
242.
243.else
244. {
245. Res[Count_2] += Res_Save[Count_2] + Res_Save[Count_2 - 1]; 246.//printf( "Res[%d] %lf \n" , Count_2 ,Res[Count_2]);
247. }
248. }
249.
250.// printf( "Res : ");
251.for(Count_Z = 0;Count_Z<= N;Count_Z++)
252. {
253. Res_Save[Count_Z] = Res[Count_Z] ;
254. Res[Count_Z] = 0;
255.//printf( "[%d] %lf " ,Count_Z, Res_Save[Count_Z]);
256. }
257.//printf(" \n" );
258. }
259.
260.
261.//printf( "Res : ");
262.for(Count_Z = 0;Count_Z<= N;Count_Z++)
263. {
264. *(az+Count_Z) += pow(2,N-
Count) * (*(as+Count)) * Res_Save[Count_Z];
265. *(bz+Count_Z) += (*(bs+Count)) * Res_Save[Count_Z];
266.//printf( " %lf " ,*(bz+Count_Z));
267. }
268.//printf(" \n" );
269.
270. }
271.
272.
273.
274.for(Count_Z = N;Count_Z >= 0;Count_Z--)
275. {
276. *(bz+Count_Z) = (*(bz+Count_Z))/(*(az+0));
277. *(az+Count_Z) = (*(az+Count_Z))/(*(az+0));
278. }
279.
280.
281.//------------------------display---------------------------------// 282. printf("bz = [" );
283.for(Count_Z= 0;Count_Z <= N ;Count_Z++)
284. {
285. printf("%lf ", *(bz+Count_Z));
286. }
287. printf(" ] \n" );
288. printf("az = [" );
289.for(Count_Z= 0;Count_Z <= N ;Count_Z++)
290. {
291. printf("%lf ", *(az+Count_Z));
292. }
293. printf(" ] \n" );
294. printf("--------------------------------------------------------\n" ); 295.
296.
297.
298.return (int) 1;
299.}
300.
301.
302.
303.
304.
305.int main(void)
306.{
307.int count;
308.
309.struct DESIGN_SPECIFICATION IIR_Filter;
310.
311. IIR_Filter.Cotoff = (double)(pi/2); //[red]
312. IIR_Filter.Stopband = (double)((pi*3)/4); //[red]
313. IIR_Filter.Stopband_attenuation = 30; //[dB]
314.
315.int N;
316.
数字图像处理_旋转与幅度谱(含MATLAB代码)
数字图像处理实验一 15生医 一、实验内容 产生右图所示图像 f1(m,n)，其中图像大小为256 ×256，中间亮条为128×32，暗处=0，亮处=100。 对其进行FFT： ①同屏显示原图f1(m,n)和FFT(f1)的幅度谱图； ②若令f2(m,n)=（-1）^（m+n）f1(m,n)，重复 以上过程，比较二者幅度谱的异同，简述理由； ③若将f2(m,n)顺时针旋转90度得到f3(m,n)，试显示FFT(f3)的 幅度谱，并与FFT(f2)的幅度谱进行比较； ④若将f1(m,n) 顺时针旋转90度得到f4(m,n)，令f5(m,n) = f1(m,n) + f4(m,n)，试显示FFT(f5)的幅度谱，指出其与 FFT(f1)和FFT(f4)的关系； ⑤若令f6(m,n)=f2(m,n)+f3(m,n)，试显示FFT(f6)的幅度谱，并指出其与 FFT(f2)和FFT(f3)的关系，比较FFT(f6)和FFT(f5)的幅度谱。 二、运行环境 MATLAB R2014a 三、运行结果及分析 1.同屏显示原图f1(m,n)和FFT(f1)的幅度谱图：
50100150200250 100150200250 50100150200250 100150200250 2.令f2(m,n)=（-1）^（m+n ）f1(m,n)，对其进行FFT ，比较f2与f1幅度谱的异同，简述理由： 50100150200250 100150200250 50100150200250 100150200250 异同及理由：①空域：f2由于前边乘了系数（-1）^（m+n ），导致灰度值有正有负，而在MATLAB 的imshow 函数中默认把负值变为0（有些情况是取反），所以形成了如左图所示的黑白花纹。②频域：FFT(2)
编译原理C语言词法分析器
编译原理 C语言词法分析器 一、实验题目 编制并调试C词法分析程序。 a.txt源代码: ?main() { int sum=0 ,it=1;/* Variable declaration*/ if (sum==1) it++; else it=it+2; }? 设计其词法分析程序,能识别出所有的关键字、标识符、常数、运算符(包括复合运算符,如++)、界符;能过滤掉源程序中的注释、空格、制表符、换行符;并且能够对一些词法规则的错误进行必要的处理,如:标识符只能由字母、数字与下划线组成,且第一个字符必须为字母或下划线。实验要求:要给出所分析语言的词法说明,相应的状态转换图,单词的种别编码方案,词法分析程序的主要算法思想等。 二、实验目的 1、理解词法分析在编译程序中的作用; 2、掌握词法分析程序的实现方法与技术; 3、加深对有穷自动机模型的理解。 三、主要函数 四、设计 1、主函数void main ( ) 2 3
4、整数类型判断函数 char *key1[]={" ","(",")","[","]","{","}",",",";","'"}; /*分隔符表*/
char *key2[]={" ","+","-","*","/","%","<",">","==",">=","<=","!=","!","&&","||","<<",">>","~","|","^","&","=","?:","->","++","--","、","+=","-=","*=","/="}; /*运算符表*/ int xx0[35],xx1[10],xx2[31]; int temp_key3=0,temp_c40=0,temp_c41=0,temp_c42=0,temp_c43=0; /******* 初始化函数*******/ void load() { int mm; for (mm=0;mm<=34;mm++) { xx0[mm]=0; } for (mm=0;mm<=9;mm++) { xx1[mm]=0; } for (mm=0;mm<=30;mm++) { xx2[mm]=0; } FILE *floading; if ((floading=fopen("key0、txt","w"))==NULL) { printf("Error! Can't create file : key0、txt"); return; } fclose (floading); /*建立保留字表文件:key0、txt*/ if ((floading=fopen("key1、txt","w"))==NULL) { printf("Error! Can't create file : key1、txt"); return; } /*建立分隔符表文件:key1、txt*/ if ((floading=fopen("key2、txt","w"))==NULL) { printf("Error! Can't create file : key2、txt"); return; } fclose(floading); /*建立运算符表文件:key2、txt*/ if ((floading=fopen("key3、txt","w"))==NULL) { printf("Error! Can't create file : key3、txt");
用MATLAB编程实现数字图像旋转
用MATLAB编程实现数字图像旋转 摘要:文章论述了用Matlab编程实现数字图像旋转的基本方法,从计算机几何坐标中的图像旋转矩阵表示着手,给出了图像旋转变换的推导过程,用简单综合插值方法,基本解决了数字图像旋转后出现的空洞问题,并通过Matlab编程工具进行实验验证。 关键词:数字图像旋转;移动变换;旋转矩阵变换;简单综合插值。 数字图像处理是指将图像信号转换成数字信号并利用计算机对其进行处理的过程。目前,数字图像处理的信息大多是二维信息。由于数据量大,因此对计算机的计算速度、存储容量等要求较高。随着微型计算机性能的提高,原来以大型机、小型机为主机的图像处理系统演变为以微机为主机的结构,其应用也迅速普及,当前图像处理技术在工业自动化、工业检测、遥感探测、军事、航空、生物医学等各个方面都发挥着十分重要的作用。 图像旋转是一种常用的数字图像处理技术,传统的图像旋转都是在二维空间中进行的,由于旋转后图像像素点坐标不再是整数,故旋转后必须对像素点灰度进行一维插值运算或二维插值运算,尤其是当对旋转后的图像质量要求较高时,需要采用高阶插值运算。 文章从通用的图像旋转矩阵着手,给出了图像旋转变及换简单综合插值的推导过程,并用Matlab编程工具进行实验验证图像旋转结果。 1Matlab简介 MATLAB是矩阵实验室(Matrix Laboratory)之意。除具备卓越的数值计算能力外,它还提供了专业水平的符号计算,可视化建模仿真和实时控制等功能。MATLAB的基本数据单位是矩阵,它的指令表达式与数学,工程中常用的形式十分相似,故用MATLAB来解算问题要比用C、C#等语言来解算相同的事情简捷得多。 2图像旋转矩阵
c语言语法分析器详解
#include
真正实现C语言绘制数学函数图像
用C语言画函数图像 横纵坐标单位长度比校正（3:5） 真正的余弦函数 #include
a[i] = a[i - 1] + 0.01; b[i] = cos(a[i]); } int A[500],B[500]; for (i = 0; i < n; i++) { //printf("sin(%f)=%f\n", a[i], b[i]); a[i] = 100 * a[i]; b[i] = 55 * b[i]; A[i] = sishewuru(a[i]); B[i] = sishewuru(b[i])+60; //printf("sin(%d)=%d\n", A[i], B[i]); } for ( i = 100; i >=0; i--) { for ( j = 0; j < n; j++) { if (i==B[j]) { printf("*"); } else { printf(" "); } } printf("\n"); } } int sishewuru(float a) { int m; if (a-floor(a)<0.5) { m = a; return m; } else { m = a + 1; return m; } }
1.调节输出框大小，字符显示大小 2.确定函数的定义域 3.确定定义域上的步长 4.计算函数值 5.确定函数值放大系数 6.确定定义域恰好落在显示的区间内 7.确定坐标的单位长度与字符实际长度之间的换算关系 8.确定打点的顺序与坐标的关系 定义域在），（ππ-的正弦函数图像 定义域在），（ππ-的正切函数图像
c语言字符串左旋转
假设原数组序列为abcd1234，要求变换成的数组序列为1234abcd，即循环右移了4 位。 比较之后，不难看出，其中有两段的顺序是不变的：1234 和abcd，可把这两段看成两个整 体。右移K 位的过程就是把数组的两部分交换一下。 变换的过程通过以下步骤完成： 逆序排列abcd：abcd1234 →dcba1234； 逆序排列1234：dcba1234 →dcba4321； 全部逆序：dcba4321 →1234abcd。 伪代码可以参考清单2-35。 //代码清单2-35 Reverse(int* arr, int b, int e) { for(; b < e; b++, e--) { int temp = arr[e]; arr[e] = arr[b]; arr[b] = temp; } } RightShift(int* arr, int N, int k) {
K %= N; Reverse(arr, 0, N – K - 1); Reverse(arr, N - K, N - 1); 8 Reverse(arr, 0, N - 1); } 这样，我们就可以在线性时间内实现右移操作了。 就拿abcdef 这个例子来说（非常简短的三句，请细看，一看就懂）： 1、首先分为俩部分，X:abc，Y:def； 2、X->X^T，abc->cba，Y->Y^T，def->fed。 3、(X^TY^T)^T=YX，cbafed->defabc，即整个翻转。 #include C语言编译器的设计与实现 01计算机4班18号任春妍2号陈俊我们设计的编译程序涉及到编译五个阶段中的三个，即词法分析器、语法分析器和中间代码生成器。编译程序的输出结果包括词法分析后的二元式序列、变量名表、状态栈分析过程显示及四元式序列程序，整个编译程序分为三部分： (1) 词法分析部分 (2) 语法分析处理及四元式生成部分 (3) 输出显示部分 一．词法分析器设计 由于我们规定的程序语句中涉及单词较少，故在词法分析阶段忽略了单词输入错误的检查，而将编译程序的重点放在中间代码生成阶段。词法分析器的功能是输入源程序，输出单词符号。我们规定输出的单词符号格式为如下的二元式：(单词种别，单词自身的值) #define ACC -2 #define syl_if 0 #define syl_else 1 #define syl_while 2 #define syl_begin 3 #define syl_end 4 #define a 5 #define semicolon 6 #define e 7 #define jinghao 8 #define s 9 #define L 10 #define tempsy 11 #define EA 12 #define EO 13 #define plus 14 #define times 15 #define becomes 16 #define op_and 17 #define op_or 18 #define op_not 19 #define rop 20 #define lparent 21 #define rparent 22 #define ident 23 #define intconst 24 这次作业的内容是要完成让图片绕任意一点旋转的效果，同时要了解图像旋转的原理。为了达到这一目的，我在老师的示例代码上进行了改进，并自己计算出新的变换矩阵，达到了作业中要求的效果。这里我们先来看一下旋转的效果。 旋转中心（0,0），旋转60°旋转中心（0,0），旋转120° 旋转中心（100,0），旋转120°旋转中心（0,600），旋转120° 图像的大小是690*728，旋转的角度为顺时针，因此可以看到四副图中的结果都是符合预期的。之后我们来通过代码，详细的分析这一变化实现的过程。代码如下： close all; f = imread('try.jpg'); theta = 2* pi / 3; x0=0; y0=600; T = [cos(theta) sin(theta) 0 -sin(theta) cos(theta) 0 0 0 1]; t1=[ 1 0 0 0 1 0 -x0 -y0 1]; t2=[1 0 0 0 1 0 x0 y0 1]; T=t1*T*t2; tform = maketform('affine',T); [g, xdata, ydata] = imtransform(f,tform, 'FillValue',255); imshow(g,'XData',xdata,'YData',ydata); hold on; imshow(f); axis auto; axis on; 读入图像后，先设定了三个参数，x0y0就是旋转中心的坐标，而theta就是旋转角（顺时针）。这里要详细说明一下这几个矩阵的作用，并且推导出其生成的过程。首先最主要的矩阵T，是负责旋转的矩阵。以下这个图片摘自网络，可以说较为完整的解释了这个矩阵的来历。 函数名: fillellipse 功能: 画出并填充一椭圆 用法: void far fillellipse(int x, int y, int xradius, int yradius); 程序例: #include Public NotInheritable Class Graphics Inherits MarshalByRefObject Implements IDeviceContext, IDisposable Visual Basic（用法） Dim instance As Graphics C# public sealed class Graphics : MarshalByRefObject, IDeviceContext, IDisposable C++ public ref class Graphics sealed : public MarshalByRefObject, IDeviceContext, IDisposable J# public final class Graphics extends MarshalByRefObject implements IDeviceContext, IDisposable JScript public final class Graphics extends MarshalByRefObject implements IDeviceContext, IDisposable 备注 Graphics类提供将对象绘制到显示设备的方法。Graphics与特定的设备上下文关联。 通过调用从System.Windows.Forms.Control继承的对象的Control.CreateGraphics方法，或通过处理控件的Control.Paint事件并访问System.Windows.Forms.PaintEventArgs类的Graphics属性，可以获取Graphics。 继承层次结构 System.Object System.MarshalByRefObject System.Drawing.Graphics 线程安全 此类型的任何公共静态（Visual Basic 中的Shared）成员都是线程安全的，但不保证所有实例成员都是线程安全的。 平台 Windows 98、Windows 2000 SP4、Windows CE、Windows Millennium Edition、Windows Mobile for Pocket PC、Windows Mobile for Smartphone、Windows Server 2003、Windows XP Media Center Edition、Windows XP Professional x64 Edition、Windows XP SP2、Windows XP Starter Edition opencv 图像翻转、旋转 转自： https://www.360docs.net/doc/1311173303.html,/watkinsong/article/details/9189649 1.图像左右翻转、翻转90度 opencv中并没有直接封装图像旋转任意角度的函数，一般我们可以使用仿射变换获得旋转后的图像，这时候可以进行任意角度的旋转，但是如果我们需要将图像旋转90度，例如只是对图像进行左右翻转，或者旋转90度将图像放倒，那么如果还使用仿射变换，显得有些不是很简单，有点过于复杂。实际上可以使用求转置矩阵的方式将图像旋转90度，然后可以沿着指定的坐标轴对旋转后的图像进行翻转变化。使用transpose(src, dst);对目标图像进行转置变换，可以将垂直的图像变为水平放置。然后使用flip()函数对图像进行翻转。整个过程非常简单，可以看下下面的代码就非常清晰的了解了。// ImageFlip.cpp : Defines the entry point for the console application. //#include "stdafx.h" #include "opencv/cv.h" #include "opencv/highgui.h" #include "stdio.h" #include "iostream"using namespace cv; using namespace std;int _tmain(int argc, _TCHAR* argv[]) { Mat src = imread("lena.jpg"); Mat dst; transpose(src, dst); Mat dst2; flip(dst, dst2, 1); // flip by y axis Mat dst3; flip(dst, dst3, 0); // flip by x axis Mat dst4; flip(dst, dst4, -1); // flip by both axises imshow("src", src); imshow("dst", dst); imshow("dst2", dst2); imshow("dst3", dst3); imshow("dst4", dst4); cvWaitKey(); return 0; } 实验结果：原始图像： 转置以后： flip(dst, dst2, 1); // flip by y axis2、任意角度旋转、同时缩放（输出图像大小与输入图像大小相同，容易造成图像不全）下面这份代码用于实现对图像的缩放与旋转。 课程设计任务书 学生姓名：专业班级：通信1003班 指导教师：郭志强工作单位：信息工程学院 题目: 通信工程应用技术 初始条件： （1）使用matlab软件进行操作 （2）选择一个图像进行处理 要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）（1）编程实现一幅图像的平移、镜像、旋转、缩小和放大。 （2）给出所用算法的理论依据和必要的推导过程，给出原始图像和处理后的图像。时间安排： 第15周：安排任务，布置题目； 第15—18周：设计仿真，撰写报告 第19周：完成设计，提交报告，答辩 指导教师签名：年月日 系主任（或责任教师）签名：年月日 目录 摘要.................................................................................................................................................................. I Abstract ........................................................................................................................................................... I I 1 MA TLAB简介 .. (1) 1.1 MA TLAB用途 (1) 2图像选择及变换 (4) 2.1 原始图像选择读取 (4) 2.2 图像放大和缩小 (6) 2.2.1 图像放大缩小的知识 (6) 2.2.2 函数说明及参数选择 (8) 2.2.3 源程序及运行结果 (8) 2.3 图像任意角度的旋转 (10) 2.3.1 函数说明及参数选择 (10) 2.3.2 源程序及运行结果 (10) 2.4 图像的平移 (12) 2.4.1 函数说明及参数选择 (12) 2.4.2 源程序及运行结果 (13) 2.5 图像经过镜像 (13) 3.5.1 函数说明及参数选择 (13) 2.5.2 源程序及运行结果 (14) 4 感悟体会小结 (17) 5 参考文献 (18) 附录 (19) 全部源程序代码： (19) #include } p=0; } } } } void delay(uchar n) { uchar i,j; for(i=0;i 编译原理课程设计报告 设计题目编译代码生成器设计 学生姓名 班级 学号 指导老师 成绩 一、课程设计的目的 编译原理课程兼有很强的理论性和实践性，是计算机专业的一门非常重要的专业基础课程，它在系统软件中占有十分重要的地位，是计算机专业学生的一门主修课。为了让学生能够更好地掌握编译原理的基本理论和编译程序构造的基本方法和技巧，融会贯通本课程所学专业理论知识，提高他们的软件设计能力，特设定该课程的课程设计，通过设计一个简单的PASCAL语言（EL语言）的编译程序，提高学生设计程序的能力，加深对编译理论知识的理解与应用。 二、课程设计的要求 1、明确课程设计任务，复习编译理论知识，查阅复印相关的编译资料。 2、按要求完成课程设计内容，课程设计报告要求文字和图表工整、思路清晰、算法正 确。 3、写出完整的算法框架。 4、编写完整的编译程序。 三、课程设计的内容 课程设计是一项综合性实践环节，是对平时实验的一个补充，课程设计内容包括课程的主要理论知识，但由于编译的知识量较复杂而且综合性较强，因而对一个完整的编译程序不适合平时实验。通过课程设计可以达到综合设计编译程序的目的。本课程的课程设计要求学生编写一个完整的编译程序，包括词法分析器、语法分析器以及实现对简单程序设计语言中的逻辑运算表达式、算术运算表达式、赋值语句、IF语句、While语句以及do…while语句进行编译，并生成中间代码和直接生汇编指令的代码生成器。 四、总体设计方案及详细设计 总体设计方案： 1.总体模块 主程序 词法分析程序语法分析 程序 中间代码 生成程序 2. 表2.1 各种单词符号对应的种别码 单词符号种别码单词符号种别码bgin 1 ：17 If 2 ：= 18 Then 3 < 20 wile 4 <> 21 do 5 <= 22 end 6 > 23 lettet（letter|digit）* 10 >= 24 dight dight* 11 = 25 + 13 ；26 —14 ( 27 * 15 ) 28 / 16 # 0 详细设计： 4.1界面导入设计 (1)一共三个选项： ①choice 1--------cifafenxi ②choice 2--------yufafenxi ③choice 3--------zhongjiandaima (2)界面演示 图一 用C++实现图像旋转变换 （代码较长， 本人使用C++实现了一个类似GDI+ Matrix的C++几何变换类TransformMatrix。 略，参见我的BLOG文章《实现完整的图像平面几何变换》）。 我所说的“实现完整的图像平面几何变换”，是指可以通过TransformMatrix::Multiply函数或者更直接的变换矩阵成员设置去实现“完整的”图像 几何变换，除非其不能使用平面几何变换矩阵进行描述（如梯形变换我就没想到怎么实现， 也许其超出了平面几何变换矩阵范畴？），或者不能进行实际的几何变换（不可逆）；“实现 完整的图像几何变换”的另一层含义是下面的图像变换执行函数可实现TransformMatrix 所能表示的任意图像几何变换，而不必去写一个个具体的，如缩放、旋转变换函数等。 C/C++ code // 获取子图数据 BOOL GetSubBitmapData(CONST BitmapData *data, INT x, INT y, INT width, INT height, BitmapDa { if (x < 0) { width += x; x = 0; } if (x + width > (INT)data->Width) width = (INT)data->Width - x; if (width <= 0) return FALSE; if (y < 0) { height += y; y = 0; } if (y + height > (INT)data->Height) height = (INT)data->Height - y; if (height <= 0) return FALSE; sub->Width = width; sub->Height = height; sub->Stride = data->Stride; sub->Scan0 = (CHAR*)data->Scan0 + y * data->Stride + (x << 2); return TRUE; } // 执行图像数据几何变换 VOID Transform(BitmapData *dest, INT x, INT y, CONST BitmapData *source, TransformMatrix *m { // 复制几何变换矩阵对象 TransformMatrix m(matrix); // 几何变换矩阵绝对增加平移量x, y m.GetElements().dx += x; m.GetElements().dy += y; 编译原理课程设计报告 课题名称：编译原理课程设计 C-语言词法与语法分析器的实现 C-词法与语法分析器的实现 1.课程设计目标 （1）题目实用性 C-语言拥有一个完整语言的基本属性，通过编写C-语言的词法分析和语法分析，对于理解编译原理的相关理论和知识有很大的作用。通过编写C-语言词法和语法分析程序，能够对编译原理的相关知识：正则表达式、有限自动机、语法分析等有一个比较清晰的了解和掌握。（2）C-语言的词法说明 ①语言的关键字： else if int return void while 所有的关键字都是保留字，并且必须是小写。 ②专用符号： + - * / < <= > >= == != = ; , ( ) [ ] { } /* */ ③其他标记是ID和NUM，通过下列正则表达式定义： ID = letter letter* NUM = digit digit* letter = a|..|z|A|..|Z digit = 0|..|9 注：ID表示标识符，NUM表示数字，letter表示一个字母，digit表示一个数字。 小写和大写字母是有区别的。 ④空格由空白、换行符和制表符组成。空格通常被忽略。 ⑤注释用通常的c语言符号/ * . . . * /围起来。注释可以放在任何空白出现的位置(即注释不能放在标记)上，且可以超过一行。注释不能嵌套。 （3）程序设计目标 能够对一个程序正确的进行词法及语法分析。 2.分析与设计 （1）设计思想 a.词法分析 词法分析的实现主要利用有穷自动机理论。有穷自动机可用作描述在输入串中识别模式的过程，因此也能用作构造扫描程序。通过有穷自动机理论能够容易的设计出词法分析器。b.语法分析 语法分析采用递归下降分析。递归下降法是语法分析中最易懂的一种方法。它的主要原理是，对每个非终结符按其产生式结构构造相应语法分析子程序，其中终结符产生匹配命令，而非终结符则产生过程调用命令。因为文法递归相应子程序也递归，所以称这种方法为递归子程序下降法或递归下降法。其中子程序的结构与产生式结构几乎是一致的。 （2）程序流程图 程序主流程图： 词法分析: 语法分析： 目录 一、题目 (2) 二、问题描述 (2) 三、程序设计说明 (2) 1、应用程序功能的详细说明 (2) 2、应用程序的功能模块描述，各模块间的层次结构以及模块之间的信息交换说明 (3) 3、算法设计 (3) 4、参考文献 (3) 四、程序流程图 (4) 五、源程序代码 (5) 六、运行结果 (7) 七、结束语 (8) 一、题目：在屏幕上画一个矩形要求：每按一次键盘，该矩形转动45度。矩形的大小和转动的方向有键盘输入，并将输入的数据送文件保存，按回车键程序结束（功能延伸：改变数据文件的内容后，再根据数据文件里的数据绘制矩形） 二、题目内容的描述： 1、在屏幕上画一个矩形。 2、每按一次键盘，该矩形转动45度。 3、矩形的大小和转动的方向有键盘输入，并将输入的数据送文件保存，按 回车键程序结束。 4、功能延伸：改变数据文件的内容后，再根据数据文件里的数据绘制矩形。 三、系统设计说明 1、系统用到的功能分析： 程序设计一般由两部分组成：算法设计和数据结构，合理地选择和实现一个程序结构和处理这些数据结构有同样的重要性，主要包括如下： #include 《编译原理课程设计》课程报告题目 C语言词法分析器和C-语言语法分析器 学生 学生学号 指导教师 提交报告时间 2019 年 6 月 8 日 C语言词法分析器 1 实验目的及意义 1.熟悉C语言词法 2.掌握构造DFA的过程 3.掌握利用DFA实现C语言的词法分析器 4.理解编译器词法分析的工作原理 2 词法特点及正则表达式 2.1词法特点 2.1.1 保留字 AUTO, BREAK , CASE , CHAR , CONST , CONTINUE , DEFAULT , DO , DOUBLE , ELSE, ENUM , EXTERN , FLOAT , FOR , GOTO, IF , INT , LONG , REGISTER , RETURN, SHORT , SIGNED , SIZEOF , STATIC , STRUCT , SWITCH , TYPEDEF , UNION , UNSIGNED , VOID, VOLATILE , WHILE, 2.1.2 符号 + - * / ++ -- += -= *= < <= > >= == != = ; , ( ) [ ] { } /* */ : 2.2 正则表达式 whitespace = (newline|blank|tab|comment)+ digit=0|..|9 nat=digit+ signedNat=(+|-)?nat NUM=signedNat(“.”nat)? letter = a|..|z|A|..|Z ID = letter(letter|digit|“_”)+ CHAR = 'other+' STRING = “other+” 图形旋转的C语言源程序 /*****************************************************************/ /* CONVOLVE.C - Turbo C 2.0 implementation of image convolution */ /* ---------- by Wesley G. Faler. All code is "as is". There */ /* is NO copyright. Use this code as you will, and if you make */ /* money at it, good for you. */ /*****************************************************************/ #includeC语言编译器的设计与实现.
数字图像处理9-图像的平移与旋转
C语言图形开发库函数graphics
opencv 图像翻转旋转
编程实现一幅图像的平移、镜像、旋转、缩小和放大
LED旋转显示屏C语言程序
编译原理课程设计 C语言编译器的实现
用C++实现图像旋转变换
编译原理课程设计报告C语言词法与语法分析器的实现
c语言,画矩形并使其旋转
C语言词法分析器和C语言语法分析器编译原理课程设计报告书
图形旋转的C语言源程序