智能车摄像头灰度处理高效算法（上）

已于 2024-03-17 22:54:17 修改
阅读量884 收藏 18
点赞数 20
分类专栏： 智能车竞赛 算法 文章标签： 算法 智能车 c语言
于 2024-03-17 22:46:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73931287/article/details/136792091
版权

本篇文章分享全国大学生智能车竞赛中常用的一些摄像头图像处理算法。

智能车摄像头灰度处理高效算法（下）-CSDN博客

一、大津法 

//-------------------------------------------------------------------------------------------------------------------
//  @brief      快速大津
//  @return     uint8
//  @since      v1.1
//  Sample usage:   OTSU_Threshold = otsuThreshold(mt9v03x_image_dvp[0]);//大津法阈值
//-------------------------------------------------------------------------------------------------------------------
uint8 otsuThreshold(uint8 *image)   //注意计算阈值的一定要是原图像
{
#define GrayScale 256
    int Pixel_Max=0;
    int Pixel_Min=255;
    uint16 width = MT9V03X_W;
    uint16 height = MT9V03X_H;
    int pixelCount[GrayScale];
    float pixelPro[GrayScale];
    int i, j, pixelSum = width * height/4;
    uint8 threshold = 0;
    uint8* data = image;  //指向像素数据的指针
    for (i = 0; i < GrayScale; i++)
    {
        pixelCount[i] = 0;
        pixelPro[i] = 0;
    }

    uint32 gray_sum=0;
    //统计灰度级中每个像素在整幅图像中的个数
    for (i = 0; i < height; i+=2)
    {
        for (j = 0; j < width; j+=2)
        {
            pixelCount[(int)data[i * width + j]]++;  //将当前的点的像素值作为计数数组的下标
            gray_sum+=(int)data[i * width + j];       //灰度值总和
            if(data[i * width + j]>Pixel_Max)   Pixel_Max=data[i * width + j];
            if(data[i * width + j]<Pixel_Min)   Pixel_Min=data[i * width + j];
        }
    }

    //计算每个像素值的点在整幅图像中的比例

    for (i = Pixel_Min; i < Pixel_Max; i++)
    {
        pixelPro[i] = (float)pixelCount[i] / pixelSum;

    }

    //遍历灰度级[0,255]
    float w0, w1, u0tmp, u1tmp, u0, u1, u, deltaTmp, deltaMax = 0;

    w0 = w1 = u0tmp = u1tmp = u0 = u1 = u = deltaTmp = 0;
    for (j = Pixel_Min; j < Pixel_Max; j++)
    {

        w0 += pixelPro[j];  //背景部分每个灰度值的像素点所占比例之和   即背景部分的比例
        u0tmp += j * pixelPro[j];  //背景部分 每个灰度值的点的比例 *灰度值

        w1=1-w0;
        u1tmp=gray_sum/pixelSum-u0tmp;

        u0 = u0tmp / w0;              //背景平均灰度
        u1 = u1tmp / w1;              //前景平均灰度
        u = u0tmp + u1tmp;            //全局平均灰度
        deltaTmp = (float)(w0 *w1* (u0 - u1)* (u0 - u1)) ;
        if (deltaTmp > deltaMax)
        {
            deltaMax = deltaTmp;
            threshold = j;
        }
        if (deltaTmp < deltaMax)
        {
            break;
        }

    }

    if(threshold>90 && threshold<130)
        last_threshold = threshold;
    else
        threshold = last_threshold;

    return threshold;
}

二、图像压缩

//-------------------------------------------------------------------------------------------------------------------
//  @brief      图像压缩
//  @return     void
//  @since      v2.0
//  Sample usage:   void compressimage();
//-------------------------------------------------------------------------------------------------------------------
#define IMAGE_H    50//图像高度
#define IMAGE_W    90//图像宽度
uint8 Image_use_zip[IMAGE_H][IMAGE_W];
void compressimage(void)
{
  int i, j, row, line;
  const float div_h = MT9V03X_H / IMAGE_H, div_w = MT9V03X_W / IMAGE_W;
  for (i = 0; i < IMAGE_H; i++)
  {
    row = i * div_h + 0.5;
    for (j = 0; j < IMAGE_W; j++)
    {
      line = j * div_w + 0.5;
      Image_use_zip[i][j] = mt9v03x_image[row][line];
    }
  }
}

三、 Soble固定阈值

//-------------------------------------------------------------------------------------------------------------------
//  @brief      Soble固定阈值
//  @return     void
//  @since      v1.2
//  Sample usage:   sobel(Image_use_zip, Image_use, 60);
//-------------------------------------------------------------------------------------------------------------------
void sobel (uint8 imageIn[IMAGE_H][IMAGE_W], uint8 imageOut[IMAGE_H][IMAGE_W], uint8 Threshold)
{
    /** 卷积核大小 */
    short KERNEL_SIZE = 3;
    short xStart = KERNEL_SIZE / 2;
    short xEnd = IMAGE_W - KERNEL_SIZE / 2;
    short yStart = KERNEL_SIZE / 2;
    short yEnd = IMAGE_H - KERNEL_SIZE / 2;
    short i, j;
    short temp[2];
    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[0] = abs(temp[0]);
            temp[1] = abs(temp[1]);

            /* 找出梯度幅值最大值  */
            if (temp[0] < temp[1])
                temp[0] = temp[1];

            if (temp[0] > Threshold) imageOut[i][j] = 0;
            else    imageOut[i][j] = 255;
        }
    }
}

四、给图像画黑框为八邻域做准备


//-------------------------------------------------------------------------------------------------------------------
//  @brief      给图像画黑框为八邻域做准备
//  @return     void
//  @since      v1.0
//  Sample usage:   image_draw_rectan(Image_use);
//-------------------------------------------------------------------------------------------------------------------
void image_draw_rectan(uint8(*image)[IMAGE_W])
{
    uint8 i = 0;
    for (i = 0; i < IMAGE_H; i++)
    {
        image[i][0] = 0;
        image[i][1] = 0;
        image[i][IMAGE_W - 1] = 0;
        image[i][IMAGE_W - 2] = 0;
    }
    for (i = 0; i < IMAGE_W; i++)
    {
        image[0][i] = 0;
        image[1][i] = 0;
    }
}

五、八邻域找边界

/*---------------------------------------------------------------
 【函    数】search_neighborhood
 【功    能】八邻域找边界
 【参    数】无
 【返 回 值】无
 【注意事项】
 ----------------------------------------------------------------*/
struct LEFT_EDGE
{
    int16 row;  //行坐标
    int16 col;  //列坐标
    uint8 flag; //存在边界的标志
};
struct RIGHT_EDGE
{
    int16 row;  //行坐标
    int16 col;  //列坐标
    uint8 flag; //存在边界的标志
};

struct LEFT_EDGE  L_edge[140];     //左边界结构体
struct RIGHT_EDGE R_edge[140];    //右边界结构体
uint8 L_edge_count=0, R_edge_count = 0;                     //左右边点的个数
uint8 dire_left,dire_right;                                 //记录上一个点的相对位置
uint8 L_search_amount = 140, R_search_amount = 140;  //左右边界搜点时最多允许的点
void search_neighborhood(void)
{
    L_edge_count = 0;//左边点个数清0
    R_edge_count = 0;//右边点个数清0

    if(left_findflag)//如果左边界点存在并找到,则开始爬线
    {
        //变量声明
        L_edge[0].row = L_start_y;
        L_edge[0].col = L_start_x;
        L_edge[0].flag = 1;
        int16 curr_row = L_start_y;//初始化行坐标
        int16 curr_col = L_start_x;//初始化列坐标
        dire_left = 0; //初始化上个边界点的来向
        //开始搜线，最多取150个点，不会往下搜，共7个方位
        for(int i = 1;i < L_search_amount; i++)    //最多搜索150个点
        {
            越界退出 行越界和列越界（向上向下向左向右）
            if(curr_row+1 < Boundary_search_end || curr_row>IMAGE_H-1)  break;
            //搜线过程
            if(dire_left != 2&&image_use[curr_row-1][curr_col-1]==BLACK&&image_use[curr_row-1][curr_col]==WHITE)   //左上黑，2，右边白
            {
                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&&image_use[curr_row-1][curr_col+1]==BLACK&&image_use[curr_row][curr_col+1]==WHITE)    //右上黑，3，下边白
            {
                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(image_use[curr_row-1][curr_col]==BLACK&&image_use[curr_row-1][curr_col+1]==WHITE)                  //正上黑，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&&image_use[curr_row][curr_col-1]==BLACK&&image_use[curr_row-1][curr_col-1]==WHITE)     //正左黑，5，上白
            {
                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&&image_use[curr_row][curr_col+1]==BLACK&&image_use[curr_row+1][curr_col+1]==WHITE)  //正右黑，4，下白
            {
                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&&image_use[curr_row+1][curr_col-1]==BLACK&&image_use[curr_row][curr_col-1]==WHITE)    //左下黑，6，上白
            {
                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&&image_use[curr_row+1][curr_col+1]==BLACK&&image_use[curr_row+1][curr_col]==WHITE)    //右下黑，7，左白
            {
                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 = R_start_y;
                 R_edge[0].col = R_start_x;
                 R_edge[0].flag = 1;
                 int16 curr_row = R_start_y;
                 int16 curr_col = R_start_x;
                 dire_right = 0;
                 for(int i = 1;i<R_search_amount;i++)
                 {
		越界退出 行越界和列越界（向上向下向左向右）
                     if(curr_row < Boundary_search_end || curr_row>IMAGE_H-1||curr_row+1<Boundary_search_end)  break;
                     //爬线过程
                     if(curr_col<IMAGE_W&&dire_right!=3&&image_use[curr_row-1][curr_col+1]==BLACK&&image_use[curr_row-1][curr_col]==WHITE)    //右上黑，3，左白
                     {
                         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&&image_use[curr_row-1][curr_col-1]==BLACK&&image_use[curr_row][curr_col-1]==WHITE) //左上黑，2，下白
                     {
                         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(image_use[curr_row-1][curr_col]==BLACK&&image_use[curr_row-1][curr_col-1]==WHITE)                  //正上黑，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!=4&&image_use[curr_row][curr_col+1]==BLACK&&image_use[curr_row-1][curr_col+1]==WHITE)   //正右黑，4，上白
                     {
                         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!=5&&image_use[curr_row][curr_col-1]==BLACK&&image_use[curr_row+1][curr_col-1]==WHITE)   //正左黑，5，下白
                     {
                         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!=6&&image_use[curr_row+1][curr_col-1]==BLACK&&image_use[curr_row+1][curr_col]==WHITE)   //左下黑，6，右白
                     {
                         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&&image_use[curr_row+1][curr_col+1]==BLACK&&image_use[curr_row][curr_col+1]==WHITE)   //右下黑，7，上白
                     {
                         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;
                 }
             }
}

小小_扫地僧
关注
  • 20
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
十四届全国大学生智能汽车竞赛“恩智浦杯”国二代码开源
11-03
获得国家二等奖，采用自主设计的图像处理方案，使得图像处理更高效，赛道识别率更准，内部有阳光算法，抗阴影抗阳光性能强，使用灰度摄像头，图像处理也是基于灰度图像处理配和LCD屏幕显示，在车辆运行时可关闭图像显示减少任务量、多路电感识别圆环，对圆环大小适应性强、串口超声波实现避障效果、编码器、PID控制、大津法
智能车图像处理-阳光算法
qq_42295125的博客
02-15 1万+
阳光算法见仁见智，多阈值OSTU和模糊OSTU是我参考论文进行改进的，整篇都放在了我的毕业论文中，毕业前不会把程序粘在这里，请读者见谅。
智能车图像处理—阳光算法
小白学视觉
03-27 294
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达阳光算法，其实应该叫灰度图像处理算法才对。灰度图像转二值化图像，具体步骤什么的，不再介绍，不懂得可以去自学《数字图像处理》和matlab。OV7725硬件二值化与MT9V034比较1.OV7725硬件二值化摄像头(1)基本原理:当扫描到某点时，该点处图像的灰度值被摄像头中的图像传感芯片换成与灰度值对应的电压值,不同的电压值经过硬...
智能车摄像头灰度处理高效算法（下）
m0_73931287的博客
03-17 644
智能车竞赛摄像头处理高效算法（下）、八邻域边界初始化、差比和、拐点检测、逆透视知三点求形成的角度(以左上角为原点形成坐标系)
基于OPENCV和CVui的智能车图像处理
最新发布
04-16
本项目使用基于OPENCV和CVui的智能车图像处理视觉化，使用C++语言和C语言混合编程，旨在方便智能车图像的处理与图像处理算法的开发。 图像文件通过自己开发的C#上位机接收，为188*120的灰度图像并保存为bmp文件 本项目通过OPENCV读取bmp文件为mat数据，并利用mat数据进行显示和存储 在imageDeal和imagePreDeal文件中，对由mat结构数据转换而来的二值化数组进行访问和处理。这些文件全部使用C语言编程，其中的程序可以直接拷贝到智能车的单片机项目中运行
智能车浅谈——图像篇
热门推荐
qq_41954556的博客
01-28 5万+
智能车浅谈 ——图像处理篇，解析总钻风和神眼这类灰度摄像头的使用原理，结合OPENCV来梳理整个图像获取、二值化、压缩、巡线原理。
智能车图像处理
weixin_50567482的博客
08-02 8611
本人大二时参加了16届华东赛区智能车竞赛，虽然结果没有达到自己预期的成绩，但依旧收获了很多，在这里写一些自己关于智能车图像处理的方法和思路，为自己未来可能参加的17届智能车做准备，也为实验室后来的学弟学妹们提供学习的方法，不至于和我一样一切从零开始。 首先，在讲图像处理前，简单谈一下我为什么在摄像头和电磁两者之间选择了摄像头，在我看来，电磁相对于摄像头来说，它比较简单，上手快，再加上外界环境对于电磁的影响较小，所以对一些新手或时间比较短的选手来说来说，电磁是一种很不错的选择。但也正因为它简单，决定了电磁的
十六届智能车全向组算法开源（一）
qq_43488141的博客
08-29 6294
系列文章目录 之前也把自己做的全向所有电路都开源了，内容也包含完整的原理图PDF，想了解的可以看看往期博客。 硬件开源第一章 硬件开源第二章 文章目录 目录 系列文章目录 文章目录 前言 一、智能车比赛常用的赛道检测方法 二、电磁信号预处理 1.ADC采集 二.图像的预处理 1.图像压缩 2.大津法 总结 前言 算法开源系列估计会比较多，自己做车大概是电磁和摄像头两种方案都用过。但随着这几年的规则改变，智能车也不像前几年那样按照传感器分类了。随...
智能车比赛图像处理代码
09-12
2018年第十三届智能车竞赛代码，使用MFC作为界面结合OPenCV3.2.0库，用SVM进行数据的训练然后再视频中实时的检测，可以检测数字，旗子和障碍物。并且有串口部分的代码可以直接把处理好的数据或者其他指令发送给下位机，结合底盘小车的代码进行策略的行走完成比赛。
智能车图像的一些事情...
ecbd2010的专栏
03-08 3350
(去年十月份,参加了学校的校内赛,,,虽然说最后的成绩不理想, 不过, 嗯, 真的学到了很多~) 一篇写给那些奋斗在智能车,以及图像处理界的同仁们的：(献丑了...) 对于智能车说来, 首先重要的应该是整体的机械的结构的：车的重心位置、舵机中值、车的前轮的两个参数的调节(一般说来, “外八字”有利于车的高速转弯, 也就是说可以在转弯的时候提供更大的转向力; 不过, 这样的代价就是使得轮胎的磨损
飞思卡尔智能车摄像头串口调试软件
03-19
用于飞思卡尔智能车摄像头查看图像显示 非常方便 只需串口
灰度图像_图像处理_阈值计算.pdf
08-07
MT9v032灰度图像_二值化所需的阈值计算
智能车竞赛 摄像头组.zip
01-01
智能汽车算法，比赛，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ 智能汽车算法，比赛，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ 智能汽车算法，比赛，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ 智能汽车算法，比赛，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！
智能车摄像头调试上位机
02-13
能够通过这个上位机在线的导入图片，对图片进行图像处理。
十四届恩智浦智能车摄像头组国二完整代码
07-26
该代码为恩智浦智能车大赛第十四届摄像头组国赛一等奖代码，完整的代码工程，无保留。希望可以给需要的人一点帮助。里面处理赛道的思想大家可以取其精华弃其糟粕。
省赛最终版_省码_智能车比赛灰度摄像头_
10-01
该代码采用pid算法速度闭环，引入了CANNY边沿追踪算法，使用10CM灰度摄像头采集赛道信息，对于参加智能车比赛或者开发智能小车有极大的借鉴和参考价值。
国赛精品——智能车硬件二值化摄像头超核OV7725（摄像头驱动程序+用户手册+原理图等）-电路方案
04-22
超核OV7725 硬件二值化摄像头专门为飞思卡尔智能车比赛设计，快速图像采集、硬件二值化。使用RTL 级电路进行图像数据采集和二值化处理，（8 根数据线每次采集一字节信号，其中每一位代表图像中的每一个点，0 代表亮...
基于STM32智能小车视觉控制导航的设计
01-27
该系统使用USB摄像头采集周围环境信息，视频通过编码后由无线路由传送到上位机，在上位机的MATLAB中利用现有的灰度和二值化的方法对图像进行处理，以及在Keil软件平台上进行编程，小车采用PID控制算法控制电机的速度...
智能车摄像头灰度算法
12-06
智能车摄像头灰度算法是一种图像处理算法，用于将彩色图像转换为灰度图像。该算法将每个像素的红、绿、蓝三个通道的值加权平均，得到一个灰度值，用于表示该像素的亮度。在智能车比赛中，灰度算法常用于图像处理中的边缘检测和图像分割等任务。 以下是一个简单的Python代码示例，用于将彩色图像转换为灰度图像： ```python import cv2 # 读取彩色图像 img = cv2.imread('color_image.jpg') # 将彩色图像转换为灰度图像 gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 显示灰度图像 cv2.imshow('Gray Image', gray_img) cv2.waitKey(0) cv2.destroyAllWindows() ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小_扫地僧

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值