智能车摄像头开源—3 图像基础处理、迭代优化与结果展示 ...

目次

一、媒介
二、摄像头采集与屏幕初始化
2.1 初始化摄像头和TFT180屏幕
2.2 初始化摄像头和IPS200屏幕
2.3 单独初始化摄像头
二、图像压缩
三、总初始化函数
四、图像补黑框
五、差比和
六、爬线算法找出发点
七、求取边线
八、二维边线提取一维边线
九、阈值处理与图像迭代
十、综合梳理
十一、结果展示
1、十字结果展示—正常灯光（有补线处理）
2、圆环结果展示—正常灯光（有单边巡线处理）
3、弯道结果展示—正常灯光
4、直线结果展示—正常灯光
5、实行室开灯，遇强光结果展示
6、实行室关灯，环岛遇强光结果展示
7、实行室关灯，由暗地区过渡到高亮地区结果展示
8、实行室关灯，由高亮地区过渡到暗地区结果展示
9、一张抽象的图片

---

一、媒介

        本文主要讲解一些基本的处理，如图像压缩、出发点找寻、阈值处理等。同时展示自顺应八向迷宫的运行结果。
        同时声明本文内容皆由作者实践得出，并不保证绝对正确，仅供入门者学习和参考
        本文处理的图像大小为 80 * 60
二、摄像头采集与屏幕初始化

2.1 初始化摄像头和TFT180屏幕

        直接调用逐飞库：

1. /**
2. * 函数功能：      初始化 TFT180 和 总钻风摄像头
3. * 特殊说明：      与 Cammer_Init_IPS200 函数只可调用其中一个，当都不调用时，默认开启摄像头初始化
4. * 形  参：        无
5. * 示例：          Cammer_Init_TFT180();
6. * 返回值：        无
7. */
8. void Cammer_Init_TFT180(void)                  //初始化摄像头和显示屏     *
9. {
10.     TFT180_Show_Init();
11.     tft180_show_string(0,0,"mt9v034 init.");
12.     while(1)
13.     {
14.         if(mt9v03x_init())      //摄像头初始化
15.         {
16.             tft180_show_string(0,16,"mt9v034 reinit.");
17.         }
18.         else
19.         {
20.             break;
21.         }
22.     }
23.     tft180_show_string(0,16,"init success.");
24.     tft180_clear();
26. }

复制代码

       
2.2 初始化摄像头和IPS200屏幕

        直接调用逐飞库函数：

1. /**
2. * 函数功能：      初始化 IPS200 和 总钻风摄像头
3. * 特殊说明：      与 Cammer_Init_TFT180 函数只可调用其中一个，当都不调用时，默认开启摄像头初始化
4. * 形  参：        无
5. * 示例：          Cammer_Init_IPS200();
6. * 返回值：        无
7. */
8. void Cammer_Init_IPS200(void)                  //初始化摄像头和显示屏         *
9. {
10.     IPS200_Show_Init();
11.     ips200_show_string(0,0,"mt9v034 init.");
12.     while(1)
13.     {
14.         if(mt9v03x_init())      //摄像头初始化
15.         {
16.             ips200_show_string(0,16,"mt9v034 reinit.");
17.         }
18.         else
19.         {
20.             break;
21.         }
22.     }
23.     ips200_show_string(0,16,"init success.");
24.     ips200_clear();
25. }

复制代码

2.3 单独初始化摄像头

        直接调用逐飞库函数：

1. /**
2. * 函数功能：      初始化总钻风摄像头
3. * 特殊说明：      当 Cammer_Init_TFT180 和 Cammer_Init_IPS200 都不调用时，默认开启摄像头初始化
4. * 形  参：        无
5. * 示例：          Cammer_Init();
6. * 返回值：        无
7. */
8. void Cammer_Init(void)                  //初始化摄像头和显示屏            *
9. {
10.     while(1)
11.     {
12.         if(mt9v03x_init())      //摄像头初始化
13.         {
14.         }
15.         else
16.         {
17.             break;
18.         }
19.     }
20. }

复制代码

2.4 屏幕初始化函数

         IPS200与TFT180同理：

1. void IPS200_Show_Init(void)
2. {
3.     ips200_set_color(RGB565_BLACK, RGB565_WHITE);    //设置颜色为彩色
4.     ips200_set_font(IPS200_6X8_FONT);    //设置字体大小为 6 * 8像素
5.     ips200_set_dir(IPS200_PORTAIT);    //设置显示方向，图像和字体可以在屏幕上横着或竖着显示
6.     ips200_init(IPS200_TYPE_SPI);    //选用SPI通信
7. }

复制代码

二、图像压缩

        得到摄像头的一帧图像后，复制图像是必须的，这样可以在处理图像时仍可吸收图像，即吸收图像和处理图像同时举行。
        压缩图像可以大幅缩减后续计算量，同时保存须要的细节，但是压缩不可过小，80 * 60已经很小了，建议不要再小于这个尺寸，当然求取边线的算法处理够快的话，可以直接处理188 * 120的图像，这样可以更好地顺应局部反光和留存细节。图像再大没有意义。此处算法无难度，不过多赘述：

1. /**
2. * 函数功能：      复制并压缩图像，将 188 * 120 图像压缩为 80 * 60 大小
3. * 特殊说明：      总钻风使用手册中说明：图像分辨率为  752 * 480， 376 * 240， 188 * 120 这三种分辨率视野是一样的，三者呈整数倍关系
4. *                其他分辨率是通过裁减得到的(这个裁减包含比188 * 120小的任何分辨率，如 94 * 60)，如376 * 240 的视野反而比752 * 400 的视野广
5. *                此处将总钻风传回图像 188 * 120 压缩为 80 * 60， 所以将 j 乘系数 2.35（188 / 80）
6. *                经实际测试，当设置图像大小为 94 * 60 时，传回的图像视野是 188 * 120 的四分之一，虽然也和 752 * 480 呈整数倍关系，但和上述情况不同
7. *
8. *                注意复制是必须的，这样在处理复制图像时，原图像变量就可以正常接收摄像头数据
9. * 形  参：        无
10. * 示例：          Copy_Zip_Image();
11. * 返回值：        无
12. */
14. void Copy_Zip_Image(void)               //*****
15. {
16.     uint8 i,j;
17.     if(mt9v03x_finish_flag == 1 && Inverse_Flag == 0)       //mt9v03x_finish_flag：逐飞库定义摄像头采集标志位，采集完一帧图像会挂1
18.                                                             //Inverse_Flag：自定义逆透视标志位，挂1时会得到一张逆透视图像，根据自己需求而定
19.     {
20.         for(i = 0; i < Image_Y; i++)
21.         {
22.             for(j = 0; j < Image_X; j++)
23.             {
24.                 Find_Line_Image[i][j] = mt9v03x_image[i * 2][(uint8)(j * 2.35)];    //将188 * 120图像压缩为 80 * 60大小，X轴比为2.35，Y轴比为2
25.             }
26.         }
27.         if(Image_Count_Flag == 1)                 //Image_Count_Flag：自定义开启图像计数标志位，挂1时开启图像计数，即每采集一张图像计数+1；挂0时图像计数清零
28.         {
29.             Image_Count ++;
30.         }
31.         else if(Image_Count_Flag == 0)
32.         {
33.             Image_Count = 0;
34.         }
35. //        Image_Num ++;
36.         mt9v03x_finish_flag = 0;    //注意清掉图像采集完成标志位
37.     }
38.     else if(mt9v03x_finish_flag == 1 && Inverse_Flag == 1)
39.     {
40.         for(i = 0; i < Image_Y; i++)
41.         {
42.             for(j = 0; j < Image_X; j++)
43.             {
44.                 Find_Line_Image[i][j] = mt9v03x_image[i * 2][(uint8)(j * 2.35f)];
45.             }
46.         }
47.         Get_Inverse_Perspective_Image(Find_Line_Image, I_Perspective_Image);    //逆透视处理函数，在另处详细说明
48.         if(Image_Count_Flag == 1)
49.         {
50.             Image_Count ++;
51.         }
52.         else if(Image_Count_Flag == 0)
53.         {
54.             Image_Count = 0;
55.         }
56. //        Image_Num ++;
57.         mt9v03x_finish_flag = 0;
58.     }
59. }

复制代码

注：图像大小是工程早期就要创建的，好比确定80 * 60的图像，那么整个比赛期间就不要再更改了，更改整个代码都要大动筋骨。同时，摄像头位对X，Y的坐标值应该很敏感，后期若该变图像大小，会导致写代码时会因固有的印象经常写出bug。

三、总初始化函数

        十分建议写一个总初始化函数，并把所有初始化丢进去，然后用标记位来开关这些初始化。这里给个例子：

1. uint8 Other_Show_Flag = 0;
2. uint8 Show_Flag = 0;
4. void All_Init(uint8 pit_flag, uint8 show_flag, uint8 other_show_flag, uint8 WiFi_send_flag, uint8 LED_screen_flag, uint8 TOF_flag)
5. {
6.     Other_Show_Flag = other_show_flag;      //自定义其余信息显示标志位，主要用于测试代码时，要在代码运行内部显示一些参数用于找出异常和错误
7.                                             //同时又要经常开启或关闭，不想一直注释或删掉，就可以if判断这个标志位是否为1，进而打开或关闭这些显示
8.     if(pit_flag == 1)       //中断初始化
9.     {
10.         pit_ms_init(CCU60_CH0, 10);
11.     }
13.     if(show_flag == 1)      //摄像头和图像初始化
14.     {
15. //        Cammer_Init();
17.         Cammer_Init_TFT180();
18.     }
19.     else if(show_flag == 2)
20.     {
21. //        Cammer_Init();
23.         Cammer_Init_IPS200();
24.     }
25.     else
26.     {
27.         Cammer_Init();
28.     }
30.     if(WiFi_send_flag == 1)     //WiFi图传初始化
31.     {
32.         WiFi_Send_Init();
33.     }
35.     if(LED_screen_flag == 1)    //灯光秀初始化
36.     {
37.         LED_Screen_Init();
38.     }
40.     if(TOF_flag == 1)       //TOF测距模块初始化
41.     {
42.         TOF_Init();
43.     }
45. //    wireless_uart_init();
46. }

复制代码

        而后在主函数中如下调用：

1.     All_Init( 0,            //是否开启中断标志位            //0：关闭       1：开启
2.               2,            //是否开启屏幕显示标志位        //0：关闭        1：TFT180显示      2:IPS200显示    （默认开启摄像头初始化）
3.               0,            //是否开启其余显示标志位        //0：关闭        1：开启
4.               0,            //WiFi图传初始化标志位         //0：关闭        1：开启
5.               0,            //LED点阵屏初始化标志位        //0：关闭        1：开启
6.               0);           //TOF模块初始化标志位          //0: 关闭        1：开启

复制代码

        这样通过0，1赋值即可开关控制所有初始化，对于后期调试代码，或是比赛时暂时更改都非常方便明了。

四、图像补黑框

        对于爬线算法，不论是迷宫照旧八邻域，当碰到十字或弯道时，会有一侧或两侧丢线（即图像内没有赛道边线），这个时候爬线算法该怎么处理处理呢？答案是在爬线前补黑框，对于八邻域或常规的迷宫算法，只需在图像的    上、左、右    边缘补一格宽度的黑框即可。
        那么黑框怎么补？将指定的图像行或列原灰度值更改为指定的灰度值（对于二值化图像来说，指定灰度值为0；对于灰度图像来说，为了更好地融入配景环境，灰度值就得通过算法求取了，算法在下方会讲解）。
        但对于上交自顺应迷宫，或本人优化后的自顺应八向迷宫来说，黑框就不能在图像最边缘补了，而是要间隔一行取补黑框。由于计算阈值是 5 * 5 大小，对于每一次的中心点，上下左右最少得有两格像素宽度。（未利用此算法的直接看代码就可以）
        对于算法可看我之前的文章：智能车摄像头开源—1.2 核默算法：自顺应八向迷宫（下）
        实际结果如图：（这里用高斯暗昧处理了赛道边线，但对黑框无影响，大概应该称之为灰框）

（黑框灰度值经过算法处理，与配景融合度较高，但想来不难分辨，相必看懂这张图像就可以明白怎样在最边缘补黑框了）
        云云以后黑框就可牢牢锁住边线。那对于自顺应迷宫算法为什么不直接补灰度值为0的黑框呢？
        在小车运行时，会碰到环岛、十字、弯道等导致赛道边线丢失的情况，此时，爬线算法由原先沿着赛道边线爬取转为沿着黑框爬取，那么不可避免的会经过黑框与赛道边线的交接地区。在交接地区，若黑框的灰度值为0，当 5 * 5 区间计算阈值时，由于黑框的缘故原由，会导致阈值被大幅拉低，直接将赛道边线判断为白，意味着交接失败，导致后续爬线紊乱。
        至于为什么补一格宽，而不补两格宽，是为了更好地保存原图像信息，进而使算法更准确。
        上代码，初始第一张图像黑框利用固定的灰度值，后续由算法处理得到：

1. uint8 Black_Box_Value_FFF = 50;
2. uint8 Black_Box_Value_FF = 50;
3. uint8 Black_Box_Value_F = 50;
4. //画黑框（必须为一个像素宽度，边界务必空出一格）
5. /**
6. * 函数功能：      图像补黑框
7. * 特殊说明：      注意黑框与边界间隔一格像素宽度
8. * 形  参：        uint8 black_box_value            黑框的灰度值
9. *                uint8(*image)[Image_X]            要补黑框的图像
10. *
11. * 示例：          Draw_Black_Box(Black_Box_Value, Find_Line_Image);；
12. * 返回值：        无
13. */
14. void Draw_Black_Box(uint8 black_box_value, uint8(*image)[Image_X])         
15. {
16.     uint8 i,j;
18.     Black_Box_Value_FFF = Black_Box_Value_FF;
19.     Black_Box_Value_FF = Black_Box_Value_F;
20.     Black_Box_Value_F = black_box_value;
21.     black_box_value = 0.5 * Black_Box_Value_F + 0.3 * Black_Box_Value_FF + 0.2 * Black_Box_Value_FFF;        //滤波
22.     Black_Box_Value = black_box_value;
23.     for(i = 1; i < 60; i++)
24.     {
25.         image[i][Image_X - 2] = black_box_value;
26.         image[i][1] = black_box_value;
27.     }
28.     for(j = 1; j < Image_X - 2; j++)
29.     {
30.         image[1][j] = black_box_value;
31.     }
32. }

复制代码

五、差比和

        差比和原理是利用两个像素点灰度值（分别设值为 a 和 b），利用式子 （a - b) / (a + b)，将比值左移七位（乘128倍放大，移位运算速度比直接乘更快，故不乘100），末了得到的值可以反应两个像素点灰度值的差异。当两者灰度值相差越大，结果便越大。末了将结果与阈值相比力，大于阈值时即可判断出现了灰度值快速变化，这也是爬线算法找出发点的关键所在。

1. /**
2. * 函数功能：      差比和
3. * 特殊说明：      用于爬线算法找起点
4. * 形  参：        int16 a                  数值较大的灰度值
5. *                int16 b                   数值较小的灰度值
6. *                uint8 compare_value       差比和阈值
7. *
8. * 示例：          Compare_Num(image[start_row][i + 5], image[start_row][i], Compare_Value)；
9. * 返回值：        大于阈值返回1，否则返回0.
10. */
11. int16 Compare_Num(int16 a, int16 b, uint8 compare_value)               //****
12. {
13.     if((((a - b) << 7) / (a + b)) > compare_value)
14.     {
15.         return 1;
16.     }
17.     else
18.     {
19.         return 0;
20.     }
21. }

复制代码

六、爬线算法找出发点

        爬线算法又称生长算法，那么“生长”，就肯定有种子，这个种子就是出发点。车赛常用的生长算法为八邻域和迷宫巡线。
        算法原理为从选定的一行图像中间开始（如我的图像宽度为80，那么就从 X = 40 开始），先向左，将每个点与其坐标 X + 5 的点举行差比和比力，当大于阈值时，就可判断为找到了左侧赛道边线。对于右侧，向右将每个点与其坐标 X - 5 的点举行差比和处理，当大于阈值时，就可判断为找到了右侧出发点。

1. /**
2. * 函数功能：      爬线算法找起点
3. * 特殊说明：      无
4. * 形  参：        uint8 start_row              找起点的图像行Y坐标
5. *                uint8(*image)[Image_X]        要处理的图像
6. *                uint8 *l_start_point          存储左侧起始点的数组（全局变量）
7. *                uint8 *r_start_point          存储右侧起始点的数组（全局变量）
8. *                uint8 l_border_x              向左找起点的截止点，最远找到这里就停止
9. *                uint8 r_border_x              向右找起点的截止点，最远找到这里就停止
10. *
11. * 示例：          Get_Start_Point(Image_Y - 3, Find_Line_Image, Adaptive_L_Start_Point, Adaptive_R_Start_Point, 1, 78)
12. * 返回值：        两边都找到返回1，否则返回0.
13. */
14. uint8 Get_Start_Point(uint8 start_row, uint8(*image)[Image_X], uint8 *l_start_point, uint8 *r_start_point, uint8 l_border_x, uint8 r_border_x)          //*****
15. {
16.     uint8 i = 0, j = 0;
17.     uint8 L_Is_Found = 0, R_Is_Found = 0;   //找到起点时挂出对应标志位
18.     uint8 Start_X  = 0;                     //起始X坐标，第一张图像取图像的行中点，后续图像用上一次图像左右两侧起始点的中间值
19.     uint8 Start_Row_0 = 0;                  //起始Y坐标
21.     Start_Row_0 = start_row;
22.     Start_X = Image_X / 2;
23.     //从中间往左边，先找起点
24.     for(j = 0; j < 10; j ++)        //指定的行没找到起点时，向上走一行继续找，最多找十行
25.     {
26.         l_start_point[1] = start_row;//y
27.         r_start_point[1] = start_row;//y
29.         if(Start_Flag == 0 || Element_State == Zebra)       //第一张图像和遇到斑马线时，起始X坐标选用图像的行中点
30.         {
31.             Start_X = Image_X / 2;
32.         }
33.         else
34.         {
35.             Start_X = (l_start_point[0] + r_start_point[0]) / 2;    //否则起始X坐标用上一次图像左右两侧起始点的中间值
36.         }
38.         {
39.             for (i = Start_X; i > l_border_x - 1; i--)      //向左找起始点
40.             {
41.                 if (Compare_Num(image[start_row][i + 5], image[start_row][i], Compare_Value))//差比和为真
42.                 {
43.                     {
44.                         l_start_point[0] = i;   //找到后记录X坐标
45.                         L_Is_Found = 1;         //挂出找见标志位
46.                         break;
47.                     }
48.                 }
49.             }
51.             for (i = Start_X; i < r_border_x + 1; i++)      //向右找起始点
52.             {
53.                 if (Compare_Num(image[start_row][i - 5], image[start_row][i], Compare_Value))//差比和为真
54.                 {
55.                     {
56.                         r_start_point[0] = i;
57.                         R_Is_Found = 1;
58.                         break;
59.                     }
60.                 }
61.             }
62.             if(L_Is_Found && R_Is_Found)
63.             {
64.                 Start_Flag = 1;    //是否为第一张图像标志位
65.                 return 1;
66.             }
67.             else
68.             {
69.                 start_row = start_row - 1;      //当此行有一侧没找到，就向上移动一行重新找
70.             }
71.         }
72.     }
73. }

复制代码

七、求取边线

        前面的文章中讲过，就不过多赘述，这里给到链接：
        智能车摄像头开源—1.2 核默算法：自顺应八向迷宫（下）

八、二维边线提取一维边线

        爬线算法得到的是二维数组边线，即存储了每个点的横坐标和纵坐标，每行可以有多个点。但一维边线是只存储X坐标，Y坐标来自于图像的行，即每行只可以有一个点。即一维数组的下标为Y坐标，而对应下标的值为X坐标。
        二维边线信息量丰富，但不相宜中线的提取，因此一般会利用算法从二维边线提取出一维边线。同时一维边线还可以用于元素判断和处理的特殊场景，后续文案讲解。

1. /**
2. * 函数功能：      由二维边线数组提取一维边线
3. * 特殊说明：      无
4. * 形  参：        uint16 l_total       //左侧二维边线点的个数
5. *                 uint16 r_total      //右侧二维边线点的个数
6. *                 uint8 start         //起始行（图像底部）
7. *                 uint8 end           //截止行（图像顶部）
8. *                 uint8 *l_border     //存储左侧一维边线的数组
9. *                 uint8 *r_border     //存储右侧一维边线的数组
10. *                 uint8(*l_line)[2]   //存储左侧二维边线的数组
11. *                 uint8(*r_line)[2]   //存储右侧二维边线的数组
12. *
13. * 示例：          Get_Border(L_Statics, R_Statics, Image_Y - 3, 2, L_Border, R_Border, L_Line, R_Line);
14. * 返回值：        无
15. */
16. void Get_Border(uint16 l_total, uint16 r_total, uint8 start, uint8 end, uint8 *l_border, uint8 *r_border, uint8(*l_line)[2], uint8(*r_line)[2])
17. {
18.     uint8 i = 0;
19.     uint16 j = 0;
20.     uint8 h = 0;
21.     for (i = 0; i < Image_Y; i++)
22.     {
23.         l_border[i] = X_Border_Min;
24.         r_border[i] = X_Border_Max;     //右边线初始化放到最右边，左边线放到最左边，这样闭合区域外的中线就会在中间，不会干扰得到的数据
25.     }
26.     h = start;
27.     //右边
28.     for (j = 0; j < r_total; j++)
29.     {
30.         if (r_line[j][1] == h)
31.         {
32.             r_border[h] = r_line[j][0];
33.         }
34.         else
35.         {
36.             continue;//每行只取一个点，没到下一行就不记录
37.         }
38.         h--;
39.         if (h == end)
40.         {
41.             break;//到最后一行退出
42.         }
43.     }
44.     h = start;
45.     for (j = 0; j < l_total; j++)
46.     {
47.         if (l_line[j][1] == h)
48.         {
49.             l_border[h] = l_line[j][0];
50.         }
51.         else
52.         {
53.             continue;//每行只取一个点，没到下一行就不记录
54.         }
55.         h--;
56.         if (h == end)
57.         {
58.             break;//到最后一行退出
59.         }
60.     }
61. }

复制代码

九、阈值处理与图像迭代

        此到处理只针对于自顺应（八向）迷宫，未利用此算法的可以略过。
        相必 1 + 1 = 2 都会吧，那就放心往下看。
        在利用算法求取边线时，我们记录了每个中心点的阈值，将些阈值举行特殊处理，可以得到判断斑马线的阈值，下张图像差比和找出发点的阈值和补黑框的灰度值。实现真正意义上的图像迭代。（变量名应该已经很明了了）

1. uint8 Adaptive_L_Thres_Max = 0;     //左侧阈值最大值
2. uint8 Adaptive_R_Thres_Max = 0;     //右侧阈值最大值
3. uint8 Adaptive_L_Thres_Min = 0;     //左侧阈值最小值
4. uint8 Adaptive_R_Thres_Min = 0;     //右侧阈值最小值
5. uint8 Adaptive_Thres_Average = 0;   //阈值均值
6. uint8 Last_Adaptive_Thres_Average = 0;  //用于阈值均值滤波
7. /**
8. * 函数功能：      提取阈值中的最大最小值,并求出阈值均值
9. * 特殊说明：      计算时间小于5us
10. * 形  参：        无
11. *
12. * 示例：          Thres_Record_Process（）；
13. * 返回值：        无
14. */
15. void Thres_Record_Process(void)
16. {
17.     uint8 i = 0;
18.     uint8 Left_Temp_Value_1 = 0;
19.     uint32 Left_Temp_Value_2 = 0;
20.     uint8 Right_Temp_Value_1 = 0;
21.     uint32 Right_Temp_Value_2 = 0;
22.     uint8 L_Average_Thres = 0;
23.     uint8 R_Average_Thres = 0;
25.     Adaptive_L_Thres_Max = 0;
26.     Adaptive_R_Thres_Max = 0;
27.     Adaptive_L_Thres_Min = 0;
28.     Adaptive_R_Thres_Min = 0;
30.     Adaptive_L_Thres_Max = L_Thres_Record[0];
31.     Adaptive_L_Thres_Min = L_Thres_Record[0];
32.     Adaptive_R_Thres_Max = R_Thres_Record[0];
33.     Adaptive_R_Thres_Min = R_Thres_Record[0];
35.     for(i = 0; i < Adaptive_L_Statics; i += 2)      //间隔取值即可，减少计算量
36.     {
37.         if(L_Line[i][0] != 2 && L_Line[i][1] != 2)      //舍去位于黑框上的边线点阈值，“2”即左边线位于黑框上时的X坐标
38.         {
39.             if(L_Thres_Record[i] < Adaptive_L_Thres_Min)
40.             {
41.                 Adaptive_L_Thres_Min = L_Thres_Record[i];
42.             }
43.             if(L_Thres_Record[i] > Adaptive_L_Thres_Max)
44.             {
45.                 Adaptive_L_Thres_Max = L_Thres_Record[i];
46.             }
47.             Left_Temp_Value_1 ++;
48.             Left_Temp_Value_2 += L_Thres_Record[i];
49.         }
50.     }
51.     for(i = 0; i < Adaptive_R_Statics; i += 2)
52.     {
53.         if(Adaptive_R_Line[i][0] != 77 && Adaptive_R_Line[i][1] != 2)       //与左侧同理
54.         {
55.             if(R_Thres_Record[i] < Adaptive_R_Thres_Min)
56.             {
57.                 Adaptive_R_Thres_Min = R_Thres_Record[i];
58.             }
59.             if(R_Thres_Record[i] > Adaptive_R_Thres_Max)
60.             {
61.                 Adaptive_R_Thres_Max = R_Thres_Record[i];
62.             }
63.             Right_Temp_Value_1 ++;
64.             Right_Temp_Value_2 += R_Thres_Record[i];
65.         }
66.     }
68.     if(Left_Temp_Value_1 == 0)      //当左侧边线全部位于边界上时，直接将阈值均值取0
69.     {
70.         L_Average_Thres = 0;
71.     }
72.     else        //求出左侧阈值均值
73.     {
74.         L_Average_Thres = (uint8)(Left_Temp_Value_2 / Left_Temp_Value_1);
75.     }
77.     if(Right_Temp_Value_1 == 0)     //与左侧同理
78.     {
79.         R_Average_Thres = 0;
80.     }
81.     else
82.     {
83.         R_Average_Thres = (uint8)(Right_Temp_Value_2 / Right_Temp_Value_1);
84.     }
86.     if(Image_Num <= 1)      //前两张图像直接求均值
87.     {
88.         Last_Adaptive_Thres_Average = (uint8)((L_Average_Thres + R_Average_Thres) / 2);
89.     }
90.     else
91.     {
92.         if(My_ABS_uint8(L_Average_Thres - R_Average_Thres) >= 40)       //当两侧边线的阈值均值相差过大时，进一步处理
93.         {
94.             if(My_ABS_uint8(L_Average_Thres - Last_Adaptive_Thres_Average) <= My_ABS_uint8(R_Average_Thres - Last_Adaptive_Thres_Average))      //选取两侧阈值均值最接近上次图像阈值均值的值作为此次的值
95.             {
96.                 Adaptive_Thres_Average = (uint8)((Last_Adaptive_Thres_Average + L_Average_Thres) / 2);
97.                 Last_Adaptive_Thres_Average = Adaptive_Thres_Average;
98.             }
99.             else
100.             {
101.                 Adaptive_Thres_Average = (uint8)((Last_Adaptive_Thres_Average + R_Average_Thres) / 2);
102.                 Last_Adaptive_Thres_Average = Adaptive_Thres_Average;
103.             }
104.         }
105.         else    //当两侧阈值均值相差不大时，直接求三者均值
106.         {
107.             Adaptive_Thres_Average = (uint8)((Last_Adaptive_Thres_Average + L_Average_Thres + R_Average_Thres) / 3);
108.             Last_Adaptive_Thres_Average = Adaptive_Thres_Average;
109.         }
110.     }
112.     //获得判断斑马线的阈值
113.     Zbra_Thres = Adaptive_Thres_Average - 10;
115.     //获得起始点差比和的阈值
116.     if(Adaptive_Thres_Average >= 100 && Adaptive_Thres_Average <= 140)      //阈值均值落在100 - 140之间，说明图像亮度很合适，此时将差比和阈值设为20即可
117.     {
118.         Compare_Value = 20;
119.     }
120.     else if(Adaptive_Thres_Average < 100)
121.     {
122.         Compare_Value = 20 - (uint8)(((float)(100 - Adaptive_Thres_Average) / 60.0f) * 10.0f);      //当小于100时，适当拉低差比和阈值，使其在图像较暗的情况下更容易找出赛道边线
123.     }
124.     else if(Adaptive_Thres_Average > 140)
125.     {
126.         Compare_Value = 20 - (uint8)(((float)(Adaptive_Thres_Average - 140) / 60.0f) * 10.0f);      //当大于140时，适当拉低差比和阈值，使其在图像较亮的情况下更容易找出赛道边线
127.     }
129.     //求黑框灰度值
130.     Black_Box_Value = (uint8)(0.45f * (float)sqrt(Adaptive_L_Thres_Min * Adaptive_L_Thres_Min + Adaptive_R_Thres_Min * Adaptive_R_Thres_Min)) + (uint8)(0.1f * (float)Black_Box_Value_1);      
131.     //0.45f即0.9 * 0.5，0.9为权重，0.5可自己调节。Black_Box_Value_1为两侧爬线起点的灰度值均值（起点值灰度值为图像中赛道黑线的灰度值，不可为黑框灰度值，可以自己写算法处理下）
132.     //或者Black_Box_Value_1直接丢20 ~ 50之间的值即可
133. }

复制代码

        至于差比和阈值、斑马线阈值、黑框灰度值的计算公式是怎么得到的，只能说是恣意丢的，但是实际测试结果很好，可根据自己需求去调解。黑框灰度值与赛道蓝布配景的融合度越高越好。
        至此，整个代码和算法处理就真正活了起来，算法可以自己优化参数，以增强其顺应性。这也是我比力推荐的代码方式，怎样让代码活起来、动起来，是很烧脑，同时也很风趣的一件事。
        至于得到的边线阈值均值，可以直接拿这个参数来二值化图像，是的，你没有看错，就是二值化图像。我之前做过测试，结果照旧非常好的，但是没什么须要。由于已经得到了边线。
        同时边线阈值均值打在屏幕上，可以在比赛时，不看图像直接调曝光值，由于阈值均值就反映了图像的亮暗程度。均值阈值在60 ~ 150 之间为宜，范围也是比力宽泛，上场打开摄像头，一看值比力公道，直接上去跑就完事。个人实测结果黑白常好的。至于摄像头参数设置，可以参考我这篇文案：智能车摄像头开源—2 摄像头参数设置经验分享。

十、综合梳理

这里举行归纳总结，实际利用时代码按以下流程：

• 所有设备初始化
  
• 读取图像并压缩复制
  
• 图像补黑框
  
• 差比和找爬线起始点
  
• 自顺应八向迷宫爬取二维边线
  
• 二维边线提取一维边线
  
• 阈值处理与迭代参数计算
  

        至此，摄像头图像基础处理与边线提取（底层）部分就已讲解完毕。建议写一个函数，直接将上述流程丢入函数内，就可一键调用提取出边线信息。

十一、结果展示

展示均为一维边线
1、十字结果展示—正常灯光（有补线处理）


        

2、圆环结果展示—正常灯光（有单边巡线处理）

3、弯道结果展示—正常灯光

4、直线结果展示—正常灯光

5、实行室开灯，遇强光结果展示

   

     手机俯拍   
   

     手机位于摄像头视角   

   

     算法运行结果   
         可以看出近端的强光对算法来说险些没有难度
6、实行室关灯，环岛遇强光结果展示

   

     手机俯拍   
   

     手机位于摄像头视角   
   

     算法运行结果   
7、实行室关灯，由暗地区过渡到高亮地区结果展示

   

     手机俯拍   
   

     手机位于摄像头视角      

     算法运行结果   
        显然有很大难度，左侧出现了部分边线紊乱，但算法依然抗住了。

8、实行室关灯，由高亮地区过渡到暗地区结果展示

   

     手机俯拍   
   

     算法运行结果   
        可以看出远端出现了部分紊乱，但仍能保证车正常通过。

9、一张抽象的图片

        当时拿起车模偶然保存到的一张图片，可以看到在很恶劣的情况下仍能保证正常运行。所以说算法的上限照旧很高的。
        上述处理的都是80 * 60的图像，但显然188 * 120的图像会对光线敏感不均的图像能表现出更好的顺应性，假如选取我的算法，照旧建议处理188 * 120图像，一张图下来也不会凌驾1ms。


智能车摄像头开源—1.1 核默算法：自顺应八向迷宫（上）
智能车摄像头开源—1.2 核默算法：自顺应八向迷宫（下）
智能车摄像头开源—2 摄像头基础参数设置经验分享
智能车摄像头开源—3 图像基础处理、迭代优化与结果展示

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。