// 清除摄像头采集完成标志位 如果不清除，则不会再次采集数据
信标车，摄像头处理部分
技术报告–摄像头处理
(2条消息) 智能车竞赛技术报告 | 节能信标组组 - 大连民族大学 - 粉红靓车队_卓晴的博客-CSDN博客_智能车信标灯算法
红外光虽然不可见，但却是最稳定的光源，除了受到自然光中红外光的干扰，不会受到其他光源的干扰，于是我们选择了通红外的170°广角摄像头。在国赛的比赛规则中，两个信标灯之间的距离最远有4.61米，本着减少算法复杂度的原则，我们通过加长摄像头支架的高度来解决视野问题，摄像头支撑加到了45cm
智能车竞赛技术报告 | 节能信标组-哈尔滨工业大学紫丁香五队-面包板社区 (eet-china.com)
本智能车采用的是2个逐飞的170度红外摄像头，前后分别一个。在单片机采集图像后需要对其进行处理，以提取主要的图像信息。对于节能信标组，需要提取的就是亮着的信标灯的坐标。十六届信标灯的灯罩是扁平的，距离较远时，接收到的光较弱，而且由于场地灯光和太阳光的存在，会存在杂点、光斑，对信标灯的识别有着很大的影响。因此，在软件上必须排除干扰因素，对图像进行精准识别，并尽可能提取出更多的信息以供控制使用。
在图像处理中，我们提取的信息主要包括：信标灯的坐标、信标灯的长、宽、面积、周长，以及信标灯距离。由于信标灯为扁平状，当距离较远时，接收到的光比较少，提取到的信标灯仅为一个像素点；距离较近时，形状近似为一个椭圆。
当场地光线足够理想时，通过固定阈值二值化，便可将场地与信标灯区分开，再通过连通域提取，即可精确地收集到信标灯的所有信息。当场地光线不够理想时，当信标灯的距离较近时，由于图像画面中信标灯占了很大一部分，所以直接提取面积最大的连通域作为信标灯即可；当信标灯距离较远时，由于信标灯在画面上仅为一个像素点，所以杂光会对信标灯的提取造成很大的困难，甚至一些杂光的亮度大于信标灯的亮度，仅通过固定阈值很难提取出真正的信标灯位置。我们尝试过了许多二值化方法，大津法、平均值法等等，但是效果都比较一般，因为较远处的信标灯只有一个像素点，全局二值化显然不太合适。最后还是采取了分段固定阈值法，主要思想就是距离远的部分给低阈值，距离近的部分给高阈值，这样通过二值化，即可滤掉比信标灯暗的部分。剩下来的就是在图像中滤除杂光干扰，我们采用的方法是通过计算信标灯的坐标和形状，来去除一些形状不可能是信标灯的连通域，通过这种方法，可以排除大部分干扰。剩下满足条件的连通域中，我们选取与上一张图信标灯最近的连通域作为信标灯的位置，来计算其各个信息。
上位机：
上位机指可以直接发送操作指令的计算机或单片机，一般提供用户操作交互界面并向用户展示反馈数据。
典型设备类型：电脑，手机，平板，面板，触摸屏
下位机：
下位机指直接与机器相连接的计算机或单片机，一般用于接收和反馈上位机的指令，并且根据指令控制机器执行动作以及从机器传感器读取数据。
典型设备类型：PLC，STM32，51，FPGA，ARM等各类可编程芯片
信标位置提取
首先通过前摄像头采集的图像进行图像处理，来判断前方是否有信标灯。如果正前方采集到了信标灯的信息，那么便通过这个信息提取出其坐标，以坐标为基础来控制车的运动。如果前摄像头采集到的图片中没有信标灯的信息，那么这时候对后摄像头进行图像处理，来判断信标灯和车的相对位置，从而确定转向方向。整体逻辑在状态机中体现。
智能车竞赛技术报告 | 节能信标组 - 兰州交通大学 - 先锋队_卓晴的博客-程序员宝宝_智能车信标组 - 程序员宝宝 (cxybb.com)
摄像头处理算法
我们采用总钻风摄像头来识别场地中的信标和障碍,总钻风摄像头采集回来 的图像是大小是188*120，以左上角为坐标原点向右下方为图像坐标正方向。在理想的图像中，应该只存在信标，但是由于环境光线，杂点，远处图像太小等因素干扰，图像效果难免会不理想。所以我们不仅通过调节、镜头焦距等方式来获得识别效果最佳的图像。通过图像膨胀对远处的图像进行膨胀操作；采用均值滤波，采用动态阈值二值化，忽略无效点等手段排除干扰因素，对赛场信息进行有效的识别。
寻灯算法实现
由于摄像头采集到的是一个188*120的图像矩阵，首先通过均值滤波对图像进行二值化，同时对图像图像有效像素点进行计数，如果有效点数过少则对图像进行膨胀操作，之后对于信标灯进行每一个像素点横坐标及纵坐标进行累加，以及像素点的个数进行累加，之后通过横纵坐标累加和除以像素点个数，即可得到信标灯的坐标。其中纵坐标为当前车模的方向，用信标灯的纵坐标与图像画面中轴线的纵坐标做差，得到小车车头朝向与信标灯方向的偏差，用此偏差放入PD控制器来控制舵机打角即可。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
| ■ 附录 程序源代码
void Get_Bin_Image (unsigned char mode)
{
unsigned short i = 0, j = 0;
unsigned long tv = 0;
if (mode == 0)
{
Threshold = GetOSTU(mt9v03x_image);
}
else if (mode == 1)
{
for (i = 33; i < MT9V03X_H; i++)
{
for (j = 0 ; j < Image_W; j++)
{
tv += mt9v03x_image[i][j];
}
}
Threshold =(unsigned short)(tv / 87 / 120);
Threshold = Threshold + lqv;
}
else if (mode == 2)
{
for (i = 0; i < MT9V03X_H; i++)
{
for (j = 0; j < MT9V03X_W; j++)
{
tv += mt9v03x_image[i][j];
}
}
Threshold =(unsigned short)(tv / MT9V03X_H / MT9V03X_W);
Threshold = Threshold + lqv;
lq_sobel(mt9v03x_image, Bin_Image, (unsigned char) Threshold);
return;
}
else if (mode == 3)
{
lq_sobelAutoThreshold(mt9v03x_image, Bin_Image);
return;
}
white_1 = 0;
for (i = 33; i < MT9V03X_H; i++)
{
for (j = 0; j < Image_W; j++)
{
if (mt9v03x_image[i][j] > Threshold)
{
Bin_Image[i][j] = 255;
white_1++;
}
else
Bin_Image[i][j] = 0;
}
}
}
short GetOSTU (unsigned char tmImage[MT9V03X_H][MT9V03X_W])
{
signed short i, j;
unsigned long Amount = 0;
unsigned long PixelBack = 0;
unsigned long PixelshortegralBack = 0;
unsigned long Pixelshortegral = 0;
signed long PixelshortegralFore = 0;
signed long PixelFore = 0;
float OmegaBack, OmegaFore, MicroBack, MicroFore, SigmaB, Sigma;
signed short MinValue, MaxValue;
signed short Threshold = 0;
unsigned char HistoGram[256];
for (j = 0; j < 256; j++)
HistoGram[j] = 0;
for (j = 0; j < MT9V03X_H; j++)
{
for (i = 0; i < MT9V03X_W; i++)
{
HistoGram[tmImage[j][i]]++;
}
}
for (MinValue = 0; MinValue < 256 && HistoGram[MinValue] == 0; MinValue++);
for (MaxValue = 255; MaxValue > MinValue && HistoGram[MinValue] == 0; MaxValue--);
if (MaxValue == MinValue)
return MaxValue;
if (MinValue + 1 == MaxValue)
return MinValue;
for (j = MinValue; j <= MaxValue; j++)
Amount += HistoGram[j];
Pixelshortegral = 0;
for (j = MinValue; j <= MaxValue; j++)
{
Pixelshortegral += HistoGram[j] * j;
}
SigmaB = -1;
for (j = MinValue; j < MaxValue; j++)
{
PixelBack = PixelBack + HistoGram[j];
PixelFore = Amount - PixelBack;
OmegaBack = (float) PixelBack / Amount;
OmegaFore = (float) PixelFore / Amount;
PixelshortegralBack += HistoGram[j] * j;
PixelshortegralFore = Pixelshortegral - PixelshortegralBack;
MicroBack = (float) PixelshortegralBack / PixelBack;
MicroFore = (float) PixelshortegralFore / PixelFore;
Sigma = OmegaBack * OmegaFore * (MicroBack - MicroFore) * (MicroBack - MicroFore);
if (Sigma > SigmaB)
{
SigmaB = Sigma;
Threshold = j;
}
}
return Threshold;
}
void lq_sobel (unsigned char imageIn[MT9V03X_H][MT9V03X_W], unsigned char imageOut[MT9V03X_H][MT9V03X_W], unsigned char Threshold)
{
short KERNEL_SIZE = 3;
short xStart = KERNEL_SIZE / 2;
short xEnd = MT9V03X_W - KERNEL_SIZE / 2;
short yStart = KERNEL_SIZE / 2;
short yEnd = MT9V03X_H - KERNEL_SIZE / 2;
short i, j, k;
short temp[4];
for (i = yStart; i < yEnd; i++)
{
for (j = xStart; j < xEnd; j++)
{
temp[0] = -(short) imageIn[i - 1][j - 1] + (short) imageIn[i - 1][j + 1]
{
-1, 0, 1},
- (short) imageIn[i][j - 1] + (short) imageIn[i][j + 1]
-1, 0, 1},
- (short) imageIn[i + 1][j - 1] + (short) imageIn[i + 1][j + 1];
-1, 0, 1}};
temp[1] = -(short) imageIn[i - 1][j - 1] + (short) imageIn[i + 1][j - 1]
{
-1, -1, -1},
- (short) imageIn[i - 1][j] + (short) imageIn[i + 1][j]
0, 0, 0},
- (short) imageIn[i - 1][j + 1] + (short) imageIn[i + 1][j + 1];
1, 1, 1}};
temp[2] = -(short) imageIn[i - 1][j] + (short) imageIn[i][j - 1]
- (short) imageIn[i][j + 1] + (short) imageIn[i + 1][j]
- (short) imageIn[i - 1][j + 1] + (short) imageIn[i + 1][j - 1];
temp[3] = -(short) imageIn[i - 1][j] + (short) imageIn[i][j + 1]
- (short) imageIn[i][j - 1] + (short) imageIn[i + 1][j]
- (short) imageIn[i - 1][j - 1] + (short) imageIn[i + 1][j + 1];
temp[0] = abs(temp[0]);
temp[1] = abs(temp[1]);
temp[2] = abs(temp[2]);
temp[3] = abs(temp[3]);
for (k = 1; k < 4; k++)
{
if (temp[0] < temp[k])
{
temp[0] = temp[k];
}
}
if (temp[0] > Threshold)
{
imageOut[i][j] = 255;
}
else
{
imageOut[i][j] = 0;
}
}
}
}
void lq_sobelAutoThreshold (unsigned char imageIn[MT9V03X_H][MT9V03X_W], unsigned char imageOut[MT9V03X_H][MT9V03X_W])
{
short KERNEL_SIZE = 3;
short xStart = KERNEL_SIZE / 2;
short xEnd = MT9V03X_W - KERNEL_SIZE / 2;
short yStart = KERNEL_SIZE / 2;
short yEnd = MT9V03X_H - KERNEL_SIZE / 2;
short i, j, k;
short temp[4];
for (i = yStart; i < yEnd; i++)
{
for (j = xStart; j < xEnd; j++)
{
temp[0] = -(short) imageIn[i - 1][j - 1] + (short) imageIn[i - 1][j + 1]
{
-1, 0, 1},
- (short) imageIn[i][j - 1] + (short) imageIn[i][j + 1]
-1, 0, 1},
- (short) imageIn[i + 1][j - 1] + (short) imageIn[i + 1][j + 1];
-1, 0, 1}};
temp[1] = -(short) imageIn[i - 1][j - 1] + (short) imageIn[i + 1][j - 1]
{
-1, -1, -1},
- (short) imageIn[i - 1][j] + (short) imageIn[i + 1][j]
0, 0, 0},
- (short) imageIn[i - 1][j + 1] + (short) imageIn[i + 1][j + 1];
1, 1, 1}};
temp[2] = -(short) imageIn[i - 1][j] + (short) imageIn[i][j - 1]
- (short) imageIn[i][j + 1] + (short) imageIn[i + 1][j]
- (short) imageIn[i - 1][j + 1] + (short) imageIn[i + 1][j - 1];
temp[3] = -(short) imageIn[i - 1][j] + (short) imageIn[i][j + 1]
- (short) imageIn[i][j - 1] + (short) imageIn[i + 1][j]
- (short) imageIn[i - 1][j - 1] + (short) imageIn[i + 1][j + 1];
temp[0] = abs(temp[0]);
temp[1] = abs(temp[1]);
temp[2] = abs(temp[2]);
temp[3] = abs(temp[3]);
for (k = 1; k < 4; k++)
{
if (temp[0] < temp[k])
{
temp[0] = temp[k];
}
}
temp[3] = (short) imageIn[i - 1][j - 1] + (short) imageIn[i - 1][j] + (short) imageIn[i - 1][j + 1]
+ (short) imageIn[i][j - 1] + (short) imageIn[i][j] + (short) imageIn[i][j + 1]
+ (short) imageIn[i + 1][j - 1] + (short) imageIn[i + 1][j] + (short) imageIn[i + 1][j + 1];
if (temp[0] > temp[3] / 12.0f)
{
imageOut[i][j] = 255;
}
else
{
imageOut[i][j] = 0;
}
}
}
}
void Bin_Image_Filter (void)
{
sint16 nr;
sint16 nc;
for (nr = 33; nr < MT9V03X_H - 1; nr++)
{
for (nc = 1; nc < Image_W - 1; nc = nc + 1)
{
if ((Bin_Image[nr][nc] == 0)
&& (Bin_Image[nr - 1][nc] + Bin_Image[nr + 1][nc] + Bin_Image[nr][nc + 1] + Bin_Image[nr][nc - 1] > (2*255)))
{
Bin_Image[nr][nc] = 255;
}
else if ((Bin_Image[nr][nc] == 255)
&& (Bin_Image[nr - 1][nc] + Bin_Image[nr + 1][nc] + Bin_Image[nr][nc + 1] + Bin_Image[nr][nc - 1] < (2*255)))
{
Bin_Image[nr][nc] = 0;
}
}
}
}
void Bin_Image_Filter_peng(void)
{
sint16 nr;
sint16 nc;
for (nr = 33; nr < MT9V03X_H - 1; nr++)
{
for (nc = 31; nc < Image_W - 1; nc = nc + 1)
{
if ((dilation_Image[nr][nc] == 0)
&& (dilation_Image[nr - 1][nc] + dilation_Image[nr + 1][nc] + dilation_Image[nr][nc + 1] + dilation_Image[nr][nc - 1] > (2*255)))
{
dilation_Image[nr][nc] = 255;
}
else if ((dilation_Image[nr][nc] == 255)
&& (dilation_Image[nr - 1][nc] + dilation_Image[nr + 1][nc] + dilation_Image[nr][nc + 1] + dilation_Image[nr][nc - 1] < (2*255)))
{
dilation_Image[nr][nc] = 0;
}
}
}
}
void Seek_Road (void)
{
sint16 nr;
sint16 nc;
sint16 temp = 0;
temp = 0;
for (nr = 8; nr < 24; nr++)
{
for (nc = MAX_COL / 2; nc < MAX_COL; nc = nc + 1)
{
if (Bin_Image[nr][nc])
{
++temp;
}
}
for (nc = 0; nc < MAX_COL / 2; nc = nc + 1)
{
if (Bin_Image[nr][nc])
{
--temp;
}
}
}
OFFSET0 = temp;
temp = 0;
for (nr = 24; nr < 40; nr++)
{
for (nc = MAX_COL / 2; nc < MAX_COL; nc = nc + 1)
{
if (Bin_Image[nr][nc])
{
++temp;
}
}
for (nc = 0; nc < MAX_COL / 2; nc = nc + 1)
{
if (Bin_Image[nr][nc])
{
--temp;
}
}
}
OFFSET1 = temp;
temp = 0;
for (nr = 40; nr < 56; nr++)
{
for (nc = MAX_COL / 2; nc < MAX_COL; nc = nc + 1)
{
if (Bin_Image[nr][nc])
{
++temp;
}
}
for (nc = 0; nc < MAX_COL / 2; nc = nc + 1)
{
if (Bin_Image[nr][nc])
{
--temp;
}
}
}
OFFSET2 = temp;
return;
}
void Seek_Beacon(void)
{
uint8 nr=0;
uint8 nc=0;
dotcnt=0;
y_sum = 0;
x_sum = 0;
for (nr = x_zuobiao; nr < MT9V03X_H - 1; nr++)
{
for (nc = 1; nc <Image_W - 1; nc++)
{
if ((Bin_Image[nr - 1][nc] + Bin_Image[nr + 1][nc] + Bin_Image[nr][nc + 1] + Bin_Image[nr][nc - 1] > 255))
{
y_sum += nc;
x_sum += nr;
dotcnt++;
}
}
}
dotcnt_new = dotcnt;
x_sum_new = x_sum;
y_sum_new = y_sum;
}
void Seek_Beacon_peng (void)
{
uint8 nr=0;
uint8 nc=0;
dotcnt=0;
y_sum = 0;
x_sum = 0;
for (nr = 33; nr < MT9V03X_H - 1; nr++)
{
for (nc = 0; nc < Image_W - 1; nc++)
{
if(dilation_Image[nr][nc])
{
y_sum += nc;
x_sum += nr;
dotcnt++;
}
}
}
dotcnt_new = dotcnt;
x_sum_new = x_sum;
y_sum_new = y_sum;
return;
}
void dilation(unsigned char *data, uint8 width, uint8 height)
{
uint8 i, j, flag;
for(i = 1;i < height - 1;i++)
{
for(j = 1;j < width - 1;j++)
{
flag = 1;
for(int m = i - 1;m < i + 2;m++)
{
for(int n = j - 1; n < j + 2;n++)
{
if(data[i * width + j] == 255 || data[m * width + n] == 255)
{
flag = 0;
break;
}
}
if(flag == 0)
{
break;
}
}
if(flag == 0)
{
dilation_Image[i][j] = 255;
}
else
{
dilation_Image[i][j] = 0;
}
}
}
}
void select_pengzhang(void)
{
if(white_1 >= 0 && white_1 < 35)
{
dilation(&Bin_Image[0][0], MT9V03X_W, MT9V03X_H);
Bin_Image_Filter_peng();
Seek_Beacon_peng ();
}
if(white_1 >= 35)
{
Bin_Image_Filter();
Seek_Beacon();
}
}
void getspeed(void)
{
Pulses_l = gpt12_get(GPT12_T2);
Pulses_r = -gpt12_get(GPT12_T6);
gpt12_clear(GPT12_T2);
gpt12_clear(GPT12_T6);
speed_ave_now = (Pulses_l + Pulses_r) / 2;
}
float pid_pos(float *err, float *PID_pos, float now, float target)
{
float pe, ie, de;
float out;
err[1] = err[0];
err[0] = target - now;
if(err[0] < 10)
err[2] += err[0] * PID_pos[1];
err[2] = (err[2] > PID_pos[3]) ? PID_pos[3] : err[2];
err[2] = (err[2] < -PID_pos[3]) ? -PID_pos[3] : err[2];
pe = err[0];
ie = err[2];
de = err[0] - err[1];
out = pe * PID_pos[0] + de * PID_pos[2] + ie;
return out;
}
float pid_increase(float *err, float *PID_inc, float now, float target)
{
float pe, ie, de;
float out;
err[2] = err[1];
err[1] = err[0];
err[0] = target - now;
pe = err[0] - err[1];
ie = err[0];
de = err[0] - 2 * err[1] + err[2];
out = pe * PID_inc[0] + ie * PID_inc[1] + de * PID_inc[2];
return out;
}
|
csdn-- 摄像头处理
(1条消息) 节能信标组：让我们一起来内卷_卓晴的博客-CSDN博客
(1条消息) 十三届智能汽车竞赛 信标对抗组 思路参考 程序参考（二）图像处理_ZZM丶的博客-CSDN博客
有了图像矩阵之后，就可以进行处理了，最终找出信标灯中心在画面中的坐标。信标灯在亮起时会以一定频率闪烁，发出一定频率范围的红光和红外光。摄像头镜头使用了红外滤光片，环境光线比较好的情况下，当信标灯亮起时，其红外光能够很明显在图像上显示为一个光斑，我们则通过逐行扫描图像矩阵的方式来求出这个光斑在画面中的像素坐标，具体操作如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
void find_LR(void)
{
unsigned int i,j;
unsigned char lside=80,rside=0;
for(i=0;i<DATALINE;i++)
{
lside=80,rside=0;
for(j=0;j<80-1;j++)
{
if(!image_dec[i][j]&&!image_dec[i][j+1])
{
if(lside==80) lside=j;
rside=j+1;
}
}
if(lside<rside) PianCha[i]=(lside+rside)/2;
else PianCha[i]=0xff;
}
}
void find_XY(void)
{
int i=0,k=0,p=0,g=0,m=0,q=0;
float Xx=0;
for(i=0;i<DATALINE-1;i++)
{
if((PianCha[i]!=0xff)&&(PianCha[i+1]!=0xff))
{
if(g==0)
{
k=i;
g=1;
}
if(m==0) p++;
}
else if(g==1) m=1;
}
for(q=0;q<p-1;q++) Xx+=PianCha[k+q];
x_MID=Xx/(p-1);
y_MID=(k+(p>>1));
}
|
在某些光线条件比较差（比如存在阳光、带红外光的灯管等）的情况下，阳光中有红外光的分量，带红外光的灯管直接发出红外光。图像中的光斑就不仅仅是信标灯发出的红外光了了，恶劣时甚至被大片的光干扰淹没，此时想要克服或者减弱这个影响，就需要利用到一个点：信标灯的红外光是以一定频率闪烁的而其他的红外光是常亮的。利用这个特性，可以对相邻的或一定帧间隔内的两张或多张图像之间做 差 或者做 异或 操作，能将常亮的红外光滤除掉，信标灯又能清晰的出现在图像中了：
在某些光线条件比较差（比如存在阳光、带红外光的灯管等）的情况下，阳光中有红外光的分量，带红外光的灯管直接发出红外光。图像中的光斑就不仅仅是信标灯发出的红外光了了，恶劣时甚至被大片的光干扰淹没，此时想要克服或者减弱这个影响，就需要利用到一个点：信标灯的红外光是以一定频率闪烁的而其他的红外光是常亮的。利用这个特性，可以对相邻的或一定帧间隔内的两张或多张图像之间做 差 或者做 异或 操作，能将常亮的红外光滤除掉，信标灯又能清晰的出现在图像中了：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
void SHANSHUOSHIBIE(void)
{
int q,w;
Image_Decompression((uint8 *)ADdata,(uint8 *)image_dec[0]);
if(shan>0)
{
shan=0;
for(q=0;q<60;q++)
{
for(w=0;w<80;w++)
{
shanshuo[q][w]=copy[q][w]^image_dec[q][w];
copy[q][w]=image_dec[q][w];
}
}
}
shan++;
}
|
(1条消息) 十六届智能车信标组的浅析_wuxing4550的博客-CSDN博客_智能车信标
(1条消息) 浅谈全国大学生智能车竞赛-摄像头组图像处理及控制算法_Q792499178的博客-CSDN博客_智能车摄像头图像处理
初学图像处理的人，一般首先熟悉图像格式，图像存储方式，8位灰度图，24位彩色图等基础知识，然后接触到的图像算法一般都是图像直方图、图像二值化处理等基础算法。二值化算法作为图像处理入门级算法，在很多场合都有应用。常用的二值化算法是固定阈值二值化，算法本身很简单，机器视觉处理的很多都是8位灰度图像，灰度值从0到255,。所谓二值化就是给定一个阈值，让小于这个阈值的灰度值为0，大于等于这个阈值的设为255，这样在图像上显示出来就是一幅黑白图像。
threshold(src, dst, 100, 255, 0);
第一个参数是输入图像，第二个是输出图像，第三个是阈值，第四个是指将大于等于阈值的灰度值设置为多大的值，最后一个参数是二值化方式
如果直接用大律法进行二值化，实际效果并不是很好，因为这是全局阈值，比较好的二值化方法应该用局部阈值，毕竟图像上每个地方的灰度值差别是比较大的。所以，opencv里面有提供了一个局部自适应二值化函数adaptiveThreshold。这个函数的效果比较好，但是，很多人用这个函数的时候，却不知道参数怎么设置比较好，结果往往出来的效果不理想，反而认为算法不好。其实，就算固定阈值二值化算法，在很多时候都能得到很好的效果，只不过我们很多人不是很清楚算法怎么配合使用而已。
(2条消息) 二值化_初探图像二值化_twxy的博客-CSDN博客
二值图像即为每个像素只有两个可能值的数字图像，常出现在图像掩码，图像分割，二值化和dithering。
其将大于某个临界灰度值的像素灰度设为灰度极大值，小于这个值的为灰度极小值，从而实现二值化
根据域值，二值化分为固定阈值和自适应阈值。比较常用的二值化方法有：双峰法，P参数法，迭代法和OTSU法等。
直方图是图像的重要特质，它可以帮助我们分析图像中的灰度变化。因此，如果物体与背景的灰度值对比明显，直方图就会包含双峰(bimodal histogram)，它们分别为图像的前景和背景。而它们之间的谷底即为边缘附近相对较少数目的像素点，一般来讲，这个最小值就为最优二值化的分界点，通过这个点可以把前景和背景很好地分开。
算法
中值滤波
(4条消息) 图像处理——中值滤波_lixiao0314的博客-CSDN博客_图像中值滤波
(4条消息) 数字图像处理------中值滤波_ranjiewen的博客-CSDN博客_数字图像处理中值滤波算法
突变的噪声
核心思路：
当数据出现很大的跳变时，均值滤波会有很大的影响，中值滤波没有，消去阶跃性噪声
中位数更加能反应数据所处的位置
原图：
进入干扰数据：
均值滤波能反映数据的变化
可以适应数据整体上升，也随之上升
(7条消息) 节能信标组：让我们一起来内卷_卓晴的博客-CSDN博客
(7条消息) 智能车图像处理-阳光算法_长风弦歌的博客-CSDN博客_阳光算法
最后还是采取了分段固定阈值法，主要思想就是距离远的部分给低阈值，距离近的部分给高阈值，这样通过二值化，即可滤掉比信标灯暗的部分。剩下来的就是在图像中滤除杂光干扰，我们采用的方法是通过计算信标灯的坐标和形状，来去除一些形状不可能是信标灯的连通域，通过这种方法，可以排除大部分干扰。剩下满足条件的连通域中，我们选取与上一张图信标灯最近的连通域作为信标灯的位置，来计算其各个信息。
