智能车八邻域算法

最新推荐文章于 2024-01-13 15:06:15 发布
最新推荐文章于 2024-01-13 15:06:15 发布
阅读量2.7k 收藏 32
点赞数 3
文章标签： 智能车 八邻域搜索 图像处理 路径跟踪 边缘检测
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53079452/article/details/126055846
版权

做智能车比赛的时候学到的八邻域搜线，代码仅供参考学习，不能直接使用

         //八邻域搜线
         if(left_findflag)
         {
             L_edge[0].row = jilu_row_l;
             L_edge[0].col = jilu_col_l;
             L_edge[0].flag = 1;
             uint8 curr_row = jilu_row_l;
             uint8 curr_col = jilu_col_l;
             dire_left = 0; 
             center_turn_flag = 1;
           
             for(int i = 1;i < L_search_amount; i++)   
             {
               
                 if(curr_row < L_edge_end_row || curr_row>Image_H-1||curr_row+1<L_edge_end_row)  break;
                 if(curr_col > max_col || curr_col < min_col)
                 {
                     if(++L_search_edge_count == 3)
                         break;
                 }
                 else
                     L_search_edge_count = 0;
             
                 if(dire_left != 2&&black_(image[curr_row-1][curr_col-1])&&white_(image[curr_row-1][curr_col]))   
                 {
                     curr_row = curr_row -1;
                     curr_col = curr_col -1;
                     L_edge_count = L_edge_count +1;
                     dire_left = 7;
                     L_edge[i].row = curr_row;
                     L_edge[i].col = curr_col;
                     L_edge[i].flag = 1;
                 }
                 else if(dire_left!=3&&black_(image[curr_row-1][curr_col+1])&&white_(image[curr_row][curr_col+1]))   
                 {
                     curr_row = curr_row -1;
                     curr_col = curr_col + 1;
                     L_edge_count = L_edge_count + 1;
                     dire_left = 6;
                     L_edge[i].row = curr_row;
                     L_edge[i].col = curr_col;
                     L_edge[i].flag = 1;
                 }
                 else if(black_(image[curr_row-1][curr_col])&&white_(image[curr_row-1][curr_col+1]))                  
                 {
                     curr_row = curr_row - 1;
                     L_edge_count = L_edge_count + 1;
                     dire_left = 0;
                     L_edge[i].row = curr_row;
                     L_edge[i].col = curr_col;
                     L_edge[i].flag = 1;
                 }
                 else if(dire_left!=5&&black_(image[curr_row][curr_col-1])&&white_(image[curr_row-1][curr_col-1])) 
                 {
                     curr_col = curr_col - 1;
                     L_edge_count = L_edge_count +1;
                     dire_left = 4;
                     L_edge[i].row = curr_row;
                     L_edge[i].col = curr_col;
                     L_edge[i].flag = 1;
                 }
                 else if(dire_left!=4&&black_(image[curr_row][curr_col+1])&&white_(image[curr_row+1][curr_col+1]))  
                 {
                     curr_col = curr_col + 1;
                     L_edge_count = L_edge_count +1;
                     dire_left = 5;
                     L_edge[i].row = curr_row;
                     L_edge[i].col = curr_col;
                     L_edge[i].flag = 1;
                 }
                 else if(dire_left!=6&&black_(image[curr_row+1][curr_col-1])&&white_(image[curr_row][curr_col-1]))   
                 {
                     curr_row = curr_row + 1;
                     curr_col = curr_col -1;
                     L_edge_count = L_edge_count +1;
                     dire_left = 3;
                     L_edge[i].row = curr_row;
                     L_edge[i].col = curr_col;
                     L_edge[i].flag = 1;
                 }
                 else if(dire_left!=7&&black_(image[curr_row+1][curr_col+1])&&white_(image[curr_row+1][curr_col]))    
                 {
                     curr_row = curr_row + 1;
                     curr_col = curr_col + 1;
                     L_edge_count = L_edge_count +1;
                     dire_left = 2;
                     L_edge[i].row = curr_row;
                     L_edge[i].col = curr_col;
                     L_edge[i].flag = 1;
                 }
                 else
                     break;
             }
         }
         if(right_findflag)
         {
             R_edge[0].row = jilu_row_r;
             R_edge[0].col = jilu_col_r;
             R_edge[0].flag = 1;
             uint8 curr_row = jilu_row_r;
             uint8 curr_col = jilu_col_r;
             dire_right = 0;
             for(int i = 1;i<R_search_amount;i++)
             {
                 if(curr_row < L_edge_end_row ||curr_row>Image_H-1||curr_row+1<L_edge_end_row)  break;
                 if(curr_col > max_col || curr_col < min_col)
                 {
                     if(++R_search_edge_count == 3)
                         break;
                 }
                 else   R_search_edge_count = 0;

                 if(curr_col<Image_W&&dire_right!=3&&black_(image[curr_row-1][curr_col+1])&&white_(image[curr_row-1][curr_col])) 
                 {
                     curr_row = curr_row - 1;
                     curr_col = curr_col + 1;
                     R_edge_count = R_edge_count + 1;
                     dire_right = 6;
                     R_edge[i].row = curr_row;
                     R_edge[i].col = curr_col;
                     R_edge[i].flag = 1;
                 }
                 else if(dire_right!=2&&black_(image[curr_row-1][curr_col-1])&&white_(image[curr_row][curr_col-1])) 
                 {
                     curr_row = curr_row-1;
                     curr_col = curr_col-1;
                     R_edge_count = R_edge_count + 1;
                     dire_right = 7;
                     R_edge[i].row = curr_row;
                     R_edge[i].col = curr_col;
                     R_edge[i].flag = 1;
                 }
                 else if(black_(image[curr_row-1][curr_col])&&white_(image[curr_row-1][curr_col-1]))                  
                 {
                     curr_row = curr_row - 1;
                     R_edge_count = R_edge_count + 1;
                     dire_right = 0;
                     R_edge[i].row = curr_row;
                     R_edge[i].col = curr_col;
                     R_edge[i].flag = 1;
                 }
                 else if(dire_right!=5&&black_(image[curr_row][curr_col-1])&&white_(image[curr_row+1][curr_col-1]))
                 {
                     curr_col = curr_col-1;
                     R_edge_count = R_edge_count + 1;
                     dire_right = 4;
                     R_edge[i].row = curr_row;
                     R_edge[i].col = curr_col;
                     R_edge[i].flag = 1;
                 }

                 else if(dire_right!=4&&black_(image[curr_row][curr_col+1])&&white_(image[curr_row-1][curr_col+1]))
                 {
                     curr_col = curr_col + 1;
                     R_edge_count = R_edge_count + 1;
                     dire_right = 5;
                     R_edge[i].row = curr_row;
                     R_edge[i].col = curr_col;
                     R_edge[i].flag = 1;
                 }
                 else if(dire_right!=6&&black_(image[curr_row+1][curr_col-1])&&white_(image[curr_row+1][curr_col]))   
                 {
                     curr_row = curr_row + 1;
                     curr_col = curr_col - 1;
                     R_edge_count = R_edge_count + 1;
                     dire_right = 3;
                     R_edge[i].row = curr_row;
                     R_edge[i].col = curr_col;
                     R_edge[i].flag = 1;
                 }
                 else if(dire_right!=7&&black_(image[curr_row+1][curr_col+1])&&white_(image[curr_row][curr_col+1]))  
                 {
                     curr_row = curr_row + 1;
                     curr_col = curr_col + 1;
                     R_edge_count = R_edge_count + 1;
                     dire_right = 2;
                     R_edge[i].row = curr_row;
                     R_edge[i].col = curr_col;
                     R_edge[i].flag = 1;
                 }
                 else
                     break;
             }
         }
         if(left_findflag)
         {
             for(int i= 1;i<L_edge_count -1;i++)
             {
                 L_edge[i].row = (L_edge[i].row + L_edge[i+1].row)/2;
                 L_edge[i].col = (L_edge[i].col + L_edge[i+1].col)/2;
             }
             for(int i= L_edge_count-1;i>1;i--)
             {
                 L_edge[i].row = (L_edge[i].row + L_edge[i-1].row)/2;
                 L_edge[i].col = (L_edge[i].col + L_edge[i-1].col)/2;
             }
             edge_process_flag = 0; 
             if(L_edge_count >=70)
             {
                 num_cnt = 0;
                 L_count = L_edge_count/2;
                 while(L_count<L_edge_count)
                 {
                     if(L_edge[L_count].row == L_edge[L_count+1].row)
                         num_cnt = num_cnt +1;
                     else
                         num_cnt = 0;
                     if(num_cnt > 5)
                         break;
                     L_count = L_count +1;
                 }
                 L_edge_count = L_count;
             }
         }
         if(right_findflag)
         {
             for(int i = 1;i<R_edge_count-1;i++)
             {
                 R_edge[i].row = (R_edge[i].row + R_edge[i+1].row)/2;
                 R_edge[i].col = (R_edge[i].col + R_edge[i-1].col)/2;
             }
             for(int i = R_edge_count-1;i>1;i--)
             {
                 R_edge[i].row = (R_edge[i].row + R_edge[i+1].row)/2;
                 R_edge[i].col = (R_edge[i].col + R_edge[i-1].col)/2;
             }
             if(R_edge_count>=70)  
             {
                 num_cnt = 0;
                 R_count = R_edge_count/2;
                 while(R_count < R_edge_count)
                 {
                     if(R_edge[R_count].row == R_edge[R_count+1].row)
                         num_cnt = num_cnt + 1;
                     else
                         num_cnt = 0;
                     if(num_cnt > 5)
                         break;
                     R_count = R_count + 1;
                 }
                 R_edge_count = R_count;
             }
         }
         if(fabs(L_edge[0].col-L_edge[L_edge_count].col)>Image_W/2&&fabs(L_edge[0].col-L_edge[L_edge_count].col)>Image_W/2)
             enable_check_l_r_edge_same = 1;
         if(enable_check_l_r_edge_same)
         {
             uint8 i_left = L_edge_count - 1;
             uint8 chongdie_cnt = 0;
             for(int i = 0;i<R_edge_count;i++)
             {
                 if(fabs(R_edge[i].row-L_edge[i_left].row)<5&&fabs(R_edge[i].col-L_edge[i_left].col)<5)
                 {
                     chongdie_cnt = chongdie_cnt + 1;
                     i_left = i_left - 1;
                     if(chongdie_cnt > 3) break;
                     if(i_left<0)   break;
                 }
             }
             if(chongdie_cnt>=2)
             {
                 x2 = fabs(L_edge[0].row-R_edge[0].row);
                 if(fabs(L_edge[0].row-R_edge[0].row)>=15)
                 {
                     if(L_edge[0].row>R_edge[0].row)  
                         left_findflag = 0;
                     else if(R_edge[0].row>L_edge[0].row)   
                         right_findflag = 0;
                 }
                 else if(fabs(L_edge[0].row-R_edge[0].row)<15)
                 {

                 }
             }
         }
         if(L_edge_count <10)
             left_findflag = 0;
         if(R_edge_count <10)
             right_findflag = 0;
         if(left_findflag && right_findflag)
         {
             if(jilu_col_l>jilu_col_r)
             {
                 if(jilu_row_l>jilu_row_r)
                     left_findflag = 0;
                 else if(jilu_row_l<jilu_row_r)
                     right_findflag = 0;
             }
         }
         if(L_edge_count-R_edge_count>30&&right_findflag) 
         {
             right_findflag = 0;
             R_edge_count = 0;
         }
         if(R_edge_count-L_edge_count>30&&left_findflag)   
         {
             left_findflag = 0;
             L_edge_count = 0;
         }
         if(left_findflag&&right_findflag)
         {
             if(jilu_row_r-jilu_row_l>Image_H/2&&L_edge_count-R_edge_count>10)
             {
                 right_findflag = 0;
                 R_edge_count = 0;
             }
             else if(jilu_row_l-jilu_row_r>Image_H/2&&R_edge_count-L_edge_count>10)
             {
                 left_findflag = 0;
                 L_edge_count = 0;
             }
         }
         if(L_edge[L_edge_count-1].row - L_edge[1].row>-10) 
             left_findflag = 0;
         if(R_edge[R_edge_count-1].row - R_edge[1].row>-10)  
             right_findflag = 0;
         if(left_findflag || right_findflag)
             enable_midline = 1;
         else
             enable_midline = 0;
         if(enable_L_corner) 
         {
             if(L_edge_count > 9)
             {
                 for(int i = 0; i<L_edge_count-9;i++)
                 {
                     if(L_edge[i+4].row>5)
                     {
                         if((L_edge[i].col - L_edge[i + 4].col) * (L_edge[i + 8].col - L_edge[i + 4].col) +
                            (L_edge[i].row - L_edge[i + 4].row) * (L_edge[i + 8].row - L_edge[i + 4].row) > 0)
                         {
                             L_corner_angle = Get_angle(L_edge[i].row, L_edge[i].col, L_edge[i + 4].row, L_edge[i + 4].col, L_edge[i + 8].row, L_edge[i + 8].col);
                             if(L_edge[i+4].col>L_edge[i+8].col)  
                             {
                                 L_corner_flag = 1;
                                 L_corner_row = L_edge[i+4].row;
                                 L_corner_col = L_edge[i+4].col;
                                 break;
                             }
                         }
                     }
                 }
             }
         }
         if(enable_R_corner) 
         {
             if(R_edge_count > 9)
             {
                 for(int i = 0; i<R_edge_count-9;i++)
                 {
                     if(R_edge[i+4].row>5)
                     {
                         if((R_edge[i].col - R_edge[i + 4].col) * (R_edge[i + 8].col - R_edge[i + 4].col) +
                         (R_edge[i].row - R_edge[i + 4].row) * (R_edge[i + 8].row - R_edge[i + 4].row) > 0) 
                         {
                             R_corner_angle = Get_angle(R_edge[i].row, R_edge[i].col, R_edge[i + 4].row, R_edge[i + 4].col, R_edge[i + 8].row, R_edge[i + 8].col);
                             if(R_edge[i+8].col>R_edge[i+4].col) 
                             {
                                 R_corner_flag = 1;
                                 R_corner_row = R_edge[i+4].row;
                                 R_corner_col = R_edge[i+4].col;
                                 break;
                             }
                         }
                     }
                 }
             }
         }
     }
``
12橙色风暴
关注
8邻域算法边缘跟踪
08-29
图像边缘获取，自己实现的基于matlab的8邻域算法，获取图像的边缘。需要手动设置阈值对图像进行二值化。包涵实现程序和测试程序
四邻域规则和八邻域的规则边界跟踪的源程序
07-04
本文将深入探讨四邻域规则和八邻域规则在边界跟踪中的应用，并结合MATLAB代码进行解析。 四邻域规则和八邻域规则是数字图像处理中定义像素相邻性的两种基本方法。在二维图像中，每个像素都有其相邻像素，这些相邻...
智能车八邻域扫线
qq_52496822的博客
03-22 1139
做个搬运工
智能车八邻域图像算法
技术缝合怪的博客
01-18 3万+
智能车八邻域图像算法
智能车八邻域图像算法_二
技术缝合怪的博客
04-09 1万+
智能车八邻域图像算法 文章目录智能车八邻域图像算法前言一、一些想法二、生长方向的使用1.点的生长方向的表示2. 用点的生长方向来做初步判断1.引入库2.读入数据总结 前言 上一篇里面讲过用八邻域来获得赛道边界：智能车八邻域图像算法 当已经能稳定获得赛道边界时，就可以进行元素识别，获得偏差了。 这里就介绍一下我的一些思路。 早在前两年，CSDN上就有一篇关于八邻域如何处理元素的文章第十五届全国大学生智能汽车竞赛-双车组三轮图像处理总结，写得很好，我当时也参考了这篇文章，但是我觉得不是很详细，所以我这里想写得
智能车图像处理(六)八邻域-1
weixin_50567482的博客
09-03 9277
题外话：在比赛前看过很多篇国赛技术报告，一些强校在处理图像时都会简单讲解四邻域，八领域，种子填充法，博主作为一个第一年做车的小白，当时觉得这些算法十分的高级，虽然也想在巡线方面用到这些算法，但奈何当时自己的能力有限，且比赛留给我学习这些算法的时间太短，所以在比赛时就决定放弃这些，选择了另外的算法，虽然可以实现巡线目的，但内心还是对强校算法十分的好奇，最近在看完16届智能车的技术报告后，觉得对于一些元素的判断方面，基于连通域的算法有着一些得天独厚的优势，趁着还在暑期，将这个算法搞懂，文章若有错误或不足的地方，
八邻域跟踪算法理解
YYYuuuz的博客
10-10 1万+
八邻域跟踪算法基本思想是，遍历图像找到第一个非零像素点，那么这个点一定是边界点。设这个点为起始点x，顺时针查找该点八邻域内遇到的第一个非零像素点x'（点x'也为边界点）。令x=x'，再进行邻域内的顺时针查找，查找的起点为刚刚x到x'过程中x'前一个零点。 ...
基于邻域系统的智能车辆最优轨迹规划方法.pdf
12-16
2. 轨迹规划算法：轨迹规划算法是指基于邻域系统理论的智能车辆轨迹规划算法，通过对邻域内的最优轨迹曲线进行选取，采用曲率的积分定义了曲线的弯阻指数，并以此为基础给出了邻域内的最优轨迹曲线评判模型和求解...
论文研究-基于矩形安全邻域的智能车移动仿真研究 .pdf
08-17
综上所述，基于矩形安全邻域的智能车移动仿真方法的研究，涉及智能车辆系统设计、传感器技术、非线性规划算法、系统仿真技术等多个领域，对智能交通系统的发展和智能车辆技术的进步具有重要的意义。通过深入研究和...
基于8邻域的区域增长算法 matlab实现
12-22
实现种子点的动态选取， dicom图片的读取和保存，基于8邻域的区域增长算法，可以直接运行。（运行前需要修改自己要处理的图片目录）
数字图像处理 邻域平均法 C语言
03-19
数字图像处理 邻域平均法 C语言 数字图像处理 邻域平均法 C语言
An-Improved-A--Star-Algorithm.zip_A star算法_matlab 智能车辆_改进a_无人驾驶车
07-15
该算法被应用于自主研发的“智能先锋”号系列无人驾驶车辆上，实车试验以及它们在“中国智能车未来挑战赛”中的优异表现证明该方法能够在栅格地图中求解出一条更优的可行驶路径，可以显著提升无人驾驶车辆行驶的效率...
【OpenCV入门教程之八】线性邻域滤波专场：方框滤波、均值滤波与高斯滤波
热门推荐
【浅墨的游戏编程Blog】毛星云（浅墨）的专栏
04-01 12万+
本系列文章由@浅墨_毛星云 出品，转载请注明出处。   文章链接： http://blog.csdn.net/poem_qianmo/article/details/22745559 作者：毛星云（浅墨）    邮箱： happylifemxy@163.com  写作当前博文时配套使用的OpenCV版本： 2.4.8本篇文章中，我们一起仔细探讨了OpenCV图像处理技术中比较热门的图像滤波操作。图
智能车摄像头边界跟踪（八近邻）
Jackson的博客
07-30 2572
下面展示一些 内联代码片。 // 智能车摄像头边界跟踪 // 边界跟踪 #include "boundary_following.h" void boundary_following(uint8*image,uint8*image_border) //image为二值化后图像，image_border为计算后得到图像64*94 { int i=63,j,dir_left=2,dir_right=2; int x,y; int border_left,border_right;
图像处理（五）：八邻域边缘跟踪与区域生长算法
sinat_31425585的博客
11-17 5万+
通常在进行边缘检测之后，需要通过边缘跟踪来将离散的边缘串接起来，常使用的方法为：边缘跟踪和区域生长两种方法。边缘跟踪又分为八邻域和四邻域两种，具体原理可以参考残影、的博客。 实现步骤： 1、灰度化并进行Canny边缘检测 2、按照预先设定的跟踪方向（顺时针）进行边缘跟踪 3、每次跟踪的终止条件为：8邻域都不存在轮廓 这里需要理解的点： 代码中为什么更新当前方向时，需要curr_d -=...
TC264芯片-摄像头循迹处理之八邻域法，逐行遍历判别法提取赛道边界
最新发布
Youngmember的博客
01-13 1838
当你看完这个代码其实就明白了，其实它找边界的方法就是每一行遍历，然后判别是不是边界的方法也很简单，就是看当前这一行，比如左边界就是看当前点是黑色并且左边点是黑色，然后右边的两个点是白色。其中判别是否是赛道边界的起点的条件是，拿左起点举例，如果有一个点的左边是黑色，自己本身是黑色，它的右边两个点都是白色。然后再根据这个边界点进行边界的爬取。结语：提取赛道边界的方法有很多，我这边只介绍了最经典的八邻域法，和我自己写的遍历判别法，当然方法之间各有好坏，各位根据实际情况自己选择。这个方法的好处就是非常的简单易懂。
智能车图像处理(七)八邻域-2
weixin_50567482的博客
09-04 5520
题外话：在上一章我们介绍了一些关于连通域的基础概念，这一章我介绍一下上一章中关于种子填充算法的一些基础算法理解，便于之后更加透彻的理解。这章主要介绍广度优先搜索（BFS），深度优先搜索（DFS）算法。说实话，这两个算法在大二学数据结构时老师讲解过，但当时只是用来应付考试，并没有想到可以用到之后的比赛中，所以希望大家在学习一些知识时，可以将该知识点发散到一些自己感兴趣的地方，或许对此会有更深的影响。 在介绍广度优先搜索（BFS），深度优先搜索（DFS）算法前，首先介绍一下数据结构的图，具体的一些基础概念就不
八邻域 python 巡线
08-17
如果您想使用八邻域来进行巡线，您可以使用OpenCV和Python来实现。下面是一个示例代码，展示了如何使用八邻域进行巡线： ```python import cv2 import numpy as np # 读取图像 image = cv2.imread("line_image.jpg") # 转换为灰度图像 gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # 二值化图像 ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY) # 提取边缘 edges = cv2.Canny(binary,50, 150) # 获取图像尺寸 height, width = edges.shape # 定义八个方向的像素位移 dx = [-1, -1, 0, 1, 1, 1, 0, -1] dy = [0, 1, 1, 1, 0, -1, -1, -1] # 初始化起始位置 start_x = int(width / 2) start_y = height - 1 # 巡线过程 current_x = start_x current_y = start_y path = [(current_x, current_y)] while current_y > 0: max_intensity = 0 next_x = current_x next_y = current_y for i in range(8): new_x = current_x + dx[i] new_y = current_y + dy[i] if new_x >= 0 and new_x < width and new_y >= 0 and new_y < height: intensity = edges[new_y, new_x] if intensity > max_intensity: max_intensity = intensity next_x = new_x next_y = new_y current_x = next_x current_y = next_y path.append((current_x, current_y)) # 绘制巡线路径 for point in path: cv2.circle(image, point, 1, (0, 0, 255), -1) # 显示结果 cv2.imshow("Line Following", image) cv2.waitKey(0) cv2.destroyAllWindows() ``` 在上述代码中，我们首先读取图像并将其转换为灰度图像。然后，对图像进行二值化处理，并使用Canny边缘检测算法提取边缘。接下来，我们定义了八个方向的像素位移，并初始化起始位置为图像底部中间位置。然后，我们通过选择具有最大边缘强度的相邻像素来进行巡线，并将路径上的像素保存在`path`列表中。最后，我们将巡线路径绘制在原始图像上，并显示结果。 请注意，上述代码仅是一个简单的示例，您可能需要根据您的实际应用进行适当的调整和优化。 希望这可以帮助到您！如果您有任何进一步的问题，请随时提问。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值