OpenCV 360度行车辅助系统——红绿灯智能预判

最新推荐文章于 2022-10-24 07:30:00 发布
最新推荐文章于 2022-10-24 07:30:00 发布
阅读量1.6k 收藏 8
点赞数 6
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sunny5106/article/details/119517209
版权

opencv
  1. AI学习红绿灯

此功能仅限前置摄像头。当视频刚开始播放时，通过自研AI算法学习红绿像素高频出现的位置，学习结束后根据学习结果判断是否使用AI红绿灯 区域，并在接下来的视频部分针对区域进行红绿灯识别。

检测到红灯则在视频底端显示“Red”字样，检测到绿灯则在视频底端显示“Green”字样。

 

 

1、收集前5%帧的红绿色素点

2、按照坐标大小排序，删掉前后10%，删掉异常大、小的值

3、筛选后判断结果数量是否充足，充足则开始使用，不足则用系统默认的区域

4、在应用的过程中持续监测红绿像素，如果出现大幅度像素密集点偏移，则重新学习

Mat player::RG_detector(Mat frame)
{
    Mat detected_frame = frame.clone();

    Mat roi(detected_frame, Rect(400,200,400,100));

    Rect detected_rect(400,200,400,100);
    //调整亮度
    frame.convertTo(img, img.type(), a, b);

    //转换为YCrCb颜色空间
    cvtColor(img, imgYCrCb, CV_BGR2YCrCb);

    imgRed.create(imgYCrCb.rows, imgYCrCb.cols, CV_8UC1);
    imgGreen.create(imgYCrCb.rows, imgYCrCb.cols, CV_8UC1);

    //分解YCrCb的三个成分
    vector<Mat> planes;
    split(imgYCrCb, planes);
    // 遍历以根据Cr分量拆分红色和绿色
    MatIterator_<uchar> it_Cr = planes[1].begin<uchar>(),
                        it_Cr_end = planes[1].end<uchar>();
    MatIterator_<uchar> it_Red = imgRed.begin<uchar>();
    MatIterator_<uchar> it_Green = imgGreen.begin<uchar>();

    for (; it_Cr != it_Cr_end; ++it_Cr, ++it_Red, ++it_Green)
    {
        // RED, 145<Cr<470
        if (*it_Cr > 145 && *it_Cr < 470)
            *it_Red = 255;
        else
            *it_Red = 0;

        // GREEN 95<Cr<110
        if (*it_Cr > 95 && *it_Cr < 110)
            *it_Green = 255;
        else
            *it_Green = 0;
    }

    redCount = processImgR(imgRed);
    greenCount = processImgG(imgGreen);
    cout << "red:" << redCount << ";  " << "green:" << greenCount << endl;

    if(currentFrameNumber < 50)
    {
        putText(frame, "AI learning", hintTextPoint, font_face, font_scale, Scalar(135, 74, 32), thickness, 8, 0);
    }
    else
    {
        if(redCount > greenCount )
        {
            putText(frame, "Red", hintTextPoint, font_face, font_scale, Scalar(41, 41, 239), thickness, 8, 0);
        }
        else if(redCount < greenCount )
        {
            putText(frame, "Green", hintTextPoint, font_face, font_scale, Scalar(22, 210, 115), thickness, 8, 0);
        }
    }
    return frame;
}


bool player::RGB_AI_learn_x_y(int x, int y)
{
    if(currentFrameNumber <= totalFrameNumber / 20)
    {
        if(y <= frame.cols/2)
        {
            RGB_learn_array_x.push_back(x);
            RGB_learn_array_y.push_back(y);
        }
    }

    else
    {
        sort(RGB_learn_array_x.begin(), RGB_learn_array_x.end());
        sort(RGB_learn_array_y.begin(), RGB_learn_array_y.end());

        if(int subArrayNum = RGB_learn_array_x.size() - RGB_learn_array_y.size() != 0)
        {
            //删除多余元素
            if(subArrayNum > 0)
            {
                for(int i=0; i<subArrayNum; i++)
                {
                    RGB_learn_array_x.pop_back();
                }
            }
            else if(subArrayNum < 0)
            {
                for(int i=0; i>subArrayNum; i--)
                {
                    RGB_learn_array_y.pop_back();
                }
            }
        }
        int delete_count = 0, delete_total = RGB_learn_array_x.size()/10;
        for(delete_count = 0; delete_count < delete_total; delete_count++)
        {
            //删除 10% 较大值
            RGB_learn_array_x.pop_back();
            RGB_learn_array_y.pop_back();
        }

        sort(RGB_learn_array_x.rbegin(), RGB_learn_array_x.rend());
        sort(RGB_learn_array_y.rbegin(), RGB_learn_array_y.rend());
        for(delete_count = 0; delete_count < delete_total; delete_count++)
        {
            //删除 10% 较小值
            RGB_learn_array_x.pop_back();
            RGB_learn_array_y.pop_back();
        }

        sort(RGB_learn_array_x.begin(), RGB_learn_array_x.end());
        sort(RGB_learn_array_y.begin(), RGB_learn_array_y.end());

        long long int sum_x, sum_y;
        sum_x = accumulate(begin(RGB_learn_array_x),end(RGB_learn_array_x), 0);
        sum_y = accumulate(begin(RGB_learn_array_y),end(RGB_learn_array_y), 0);

        //计算均值
        RGB_learn_x = (int)sum_x / RGB_learn_array_x.size();
        RGB_learn_y = (int)sum_y / RGB_learn_array_y.size();
        //计算范围
        RGB_learn_w = RGB_learn_array_x.end() - RGB_learn_array_x.begin();
        RGB_learn_h = RGB_learn_array_y.end() - RGB_learn_array_y.begin();

        if(RGB_learn_array_x.size()>50)
            return true;//如果学习到大量红绿灯，认为学习有效
        else return false;
    }
}

int player::processImgR(Mat src)
{
    Mat tmp;

    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;
    vector<Point> hull;

    CvPoint2D32f tempNode;
    CvMemStorage* storage = cvCreateMemStorage();
    CvSeq* pointSeq = cvCreateSeq(CV_32FC2, sizeof(CvSeq), sizeof(CvPoint2D32f), storage);

    Rect* trackBox;
    Rect* result;
    int resultNum = 0;

    int area = 0;

    src.copyTo(tmp);
    //提取轮廓
    findContours(tmp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);

    if (contours.size() > 0)
    {
        trackBox = new Rect[contours.size()];
        result = new Rect[contours.size()];

        //确定要跟踪的区域
        for (int i = 0; i < contours.size(); i++)
        {
            cvClearSeq(pointSeq);
            // 获取凸包的点集
            convexHull(Mat(contours[i]), hull, true);
            int hullcount = (int)hull.size();
            // 凸包的保存点
            for (int j = 0; j < hullcount - 1; j++)
            {
                //if(HoughCircle_detector(src) > 1)
                {
                    bool final_learn_result;
                    if(currentFrameNumber <= totalFrameNumber / 20)
                    {

                        //前面 5% 帧用来学习红绿灯位置
                        final_learn_result = RGB_AI_learn_x_y(hull[j].x, hull[j].y);
                    }
                    else
                    {
                        if(final_learn_result == true)
                        {
                            //学习有效，使用AI识别红绿灯
                            if(hull[j].x >= RGB_learn_x-RGB_learn_w/2 && hull[j].x <= RGB_learn_x+RGB_learn_w/2 &&
                               hull[j].y >= RGB_learn_y-RGB_learn_h/2 && hull[j].y <= RGB_learn_y+RGB_learn_h/2)
                            {
                                //cout<<"AI success!"<<endl;
                                tempNode.x = hull[j].x;
                                tempNode.y = hull[j].y;
                                cvSeqPush(pointSeq, &tempNode);
                            }
                        }
                        else
                        {
                            if(hull[j].x >= 400 && hull[j].x <= 800 &&
                               hull[j].y >= 400 && hull[j].y <= 550)
                            {
                                tempNode.x = hull[j].x;
                                tempNode.y = hull[j].y;
                                cvSeqPush(pointSeq, &tempNode);
                            }
                        }
                    }

                }
            }

            trackBox[i] = cvBoundingRect(pointSeq);
        }

        if (isFirstDetectedR)
        {
            lastTrackBoxR = new Rect[contours.size()];
            for (int i = 0; i < contours.size(); i++)
                lastTrackBoxR[i] = trackBox[i];
            lastTrackNumR = contours.size();
            isFirstDetectedR = false;
        }
        else
        {
            for (int i = 0; i < contours.size(); i++)
            {
                for (int j = 0; j < lastTrackNumR; j++)
                {
                    if (isIntersected(trackBox[i], lastTrackBoxR[j]))
                    {
                        result[resultNum] = trackBox[i];
                        break;
                    }
                }
                resultNum++;
            }
            delete[] lastTrackBoxR;
            lastTrackBoxR = new Rect[contours.size()];
            for (int i = 0; i < contours.size(); i++)
            {
                lastTrackBoxR[i] = trackBox[i];
            }
            lastTrackNumR = contours.size();
        }

        delete[] trackBox;
    }
    else
    {
        isFirstDetectedR = true;
        result = NULL;
    }
    cvReleaseMemStorage(&storage);

    if (result != NULL)
    {
        for (int i = 0; i < resultNum; i++)
        {
            area += result[i].area();
        }
    }
    delete[] result;

    return area;
}

int player::processImgG(Mat src)
{
    Mat tmp;

    vector<vector<Point> > contours;
    vector<Vec4i> hierarchy;
    vector< Point > hull;

    CvPoint2D32f tempNode;
    CvMemStorage* storage = cvCreateMemStorage();
    CvSeq* pointSeq = cvCreateSeq(CV_32FC2, sizeof(CvSeq), sizeof(CvPoint2D32f), storage);

    Rect* trackBox;
    Rect* result;
    int resultNum = 0;

    int area = 0;

    src.copyTo(tmp);
    // Extract the contour
    findContours(tmp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);

    if (contours.size() > 0)
    {
        trackBox = new Rect[contours.size()];
        result = new Rect[contours.size()];

        // Determine the area to track
        for (int i = 0; i < contours.size(); i++)
        {
            cvClearSeq(pointSeq);
            // Get the point set of the convex hull
            convexHull(Mat(contours[i]), hull, true);
            int hullcount = (int)hull.size();
            // Save points of the convex hull
            for (int j = 0; j < hullcount - 1; j++)
            {
                //if(HoughCircle_detector(src) > 1)
                {
                    bool final_learn_result;
                    if(currentFrameNumber <= totalFrameNumber / 20)
                    {
                        //前面 5% 帧用来学习红绿灯位置
                        final_learn_result = RGB_AI_learn_x_y(hull[j].x, hull[j].y);
                    }
                    else
                    {
                        if(final_learn_result == true)
                        {
                            //学习有效，使用AI识别红绿灯
                            if(hull[j].x >= RGB_learn_x-RGB_learn_w/2 && hull[j].x <= RGB_learn_x+RGB_learn_w/2 &&
                               hull[j].y >= RGB_learn_y-RGB_learn_h/2 && hull[j].y <= RGB_learn_y+RGB_learn_h/2)
                            {
                                //cout<<"AI success!"<<endl;
                                tempNode.x = hull[j].x;
                                tempNode.y = hull[j].y;
                                cvSeqPush(pointSeq, &tempNode);
                            }
                        }
                        else
                        {
                            if(hull[j].x >= 400 && hull[j].x <= 800 &&
                               hull[j].y >= 400 && hull[j].y <= 550)
                            {
                                tempNode.x = hull[j].x;
                                tempNode.y = hull[j].y;
                                cvSeqPush(pointSeq, &tempNode);
                            }
                        }
                    }

                }

            }

            trackBox[i] = cvBoundingRect(pointSeq);
        }

        if (isFirstDetectedG)
        {
            lastTrackBoxG = new Rect[contours.size()];
            for (int i = 0; i < contours.size(); i++)
                lastTrackBoxG[i] = trackBox[i];
            lastTrackNumG = contours.size();
            isFirstDetectedG = false;
        }
        else
        {
            for (int i = 0; i < contours.size(); i++)
            {
                for (int j = 0; j < lastTrackNumG; j++)
                {
                    if (isIntersected(trackBox[i], lastTrackBoxG[j]))
                    {
                        result[resultNum] = trackBox[i];
                        break;
                    }
                }
                resultNum++;
            }
            delete[] lastTrackBoxG;
            lastTrackBoxG = new Rect[contours.size()];
            for (int i = 0; i < contours.size(); i++)
            {
                lastTrackBoxG[i] = trackBox[i];
            }
            lastTrackNumG = contours.size();
        }

        delete[] trackBox;
    }
    else
    {
        isFirstDetectedG = true;
        result = NULL;
    }
    cvReleaseMemStorage(&storage);

    if (result != NULL)
    {
        for (int i = 0; i < resultNum; i++)
        {
            area += result[i].area();
        }
    }
    delete[] result;

    return area;
}

皮皮熊计算机
关注
计算机视觉实战--OpenCV进行红绿灯识别
Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！交流学习、商务合作：https://bbs.csdn.net/topics/614347534
05-30 6万+
Hello大家好，我是Dream。 OpenCV是一个开源的计算机视觉库，可以用于实现各种图像和视频处理任务，包括红绿灯识别。可以帮助自动驾驶汽车、智能交通系统等设备准确地识别红绿灯的状态，以便做出正确的决策。今天，就有Dream带领大家复盘一下计算机视觉中最经典的实验：OpenCV进行红绿灯识别，一起来看看吧~
OpenCV-Python实战（1）——OpenCV简介与图像处理基础
热门推荐
盼小辉丶的博客
08-10 22万+
OpenCV 是一个的跨平台计算机视觉库，可以运行在 Linux、Windows 和 Mac OS 操作系统上。它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时也提供了 Python 接口，实现了图像处理和计算机视觉方面的很多通用算法。在本文中，将介绍 OpenCV 库，包括它的主要模块和典型应用场景，同时使用 OpenCV-Python 实战讲解图像处理基础要点。
基于OpenCV的红绿灯识别
11-01
基于OpenCV的红绿灯识别系统，能通过图像识别裁剪出图片中的红绿灯状态。
opencv 红绿灯识别 运动物体识别
05-26
红绿灯识别 opencv 运动物体识别
opencv简单方式红绿灯状态识别
m0_73697585的博客
09-19 1909
前言：代码用于识别一个固定视角下的视频中的红绿灯的状态。 做法：先将原视频转为灰度视频，这样就不用区分颜色，划定出需要的感兴趣区域，判断感兴趣区域的值，得出那个区域的灯在量，得出此时红绿灯的实时状态。
【OpenCV】 红绿灯识别检测
m0_56051805的博客
08-11 1万+
【OpenCV】 红绿灯识别检测 手把手教学
基于VS2019 C++的跨平台（Linux）开发的项目——360 度智能行车辅助系统
05-29
基于 Socket 网络通讯技术，使用Qt5进行GUI编程，结合OpenCV图像处理，采用Sqlite3数据库，实现的 360 度智能行车辅助系统。该种智能驾驶辅助系统能够通过安装在车身前后左右的 2~4 个摄像头，同时采集车辆四周的...
OpenCV实战（1）——OpenCV与图像处理基础
最新发布
盼小辉丶的博客
10-24 6万+
OpenCV 是一个跨平台计算机视觉和机器学习库，实现了图像处理和计算机视觉方面的很多通用算法。本节将介绍 OpenCV 的基础知识，以及如何编译运行 OpenCV 程序，并介绍如何完成最基本的图像处理任务——读取、显示和保存图像。除此之外，鼠标事件和图形绘制也是 OpenCV 计算机视觉项目中常用的基本功能，本节介绍了如何使用这两个重要的 OpenCV 功能。
运用OpenCV视频识别 红绿灯
new_moths的博客
09-19 416
python 运用OpenCV视频识别
红绿灯识别程序
05-26
主要是针对已经定位的红绿灯进行识别的程序，通过MATLAB实现！
红绿灯自动识别
12-23
可以用来识别自然环境中的交通灯，标注出其位置和灯的颜色，对于不同的红绿灯图片可能因为各种原因稍有问题，可通过调节HSV的选择范围来使其选择准确
Opencv 识别红绿灯
Xxx_aq的博客
09-19 1100
import numpy as np
opencv识别红绿灯
m0_63376358的博客
09-19 1176
ret, RedFinnal = cv.threshold(RedRoi, 65, 255, cv.THRESH_BINARY) # 对所选择的灯进行阈值处理转换为二值图。ret, Finnal = cv.threshold(IpRoi, 65, 255, cv.THRESH_BINARY) # 对所选择的灯进行阈值处理转换为二值图。ret, Finnal = cv.threshold(IpRoi, 65, 255, cv.THRESH_BINARY) # 对所选择的灯进行阈值处理转换为二值图。
基于OpenCV的红绿灯识别代码解析
小小何先生的学习之旅
11-06 1万+
  红绿灯分为导向灯和圆形灯。一般圆形灯在路口只有一盏灯，红灯亮时禁止直行和左转，可以右转弯。导向灯市带有箭头的，可以有两个或三个，分别指示不同方向的行车和停车。按指示的灯即可，没有右转向导向灯的情况下可以视为可以右转。   RGB颜色空间以R(Red:红）、G(Green:绿色)、 B(Blue:蓝）三种基本色为基础，进行不同程度的叠加，产生丰富而广泛的颜色，所以俗称三基色模式。在大自然中有无穷...
基于Opencv的红绿灯 交通信号检测（图像分类算法）
Tertullianus的博客
06-27 4306
红绿灯检测
opencv 红绿灯检测
jacke121的专栏
03-18 3668
import cv2 import numpy as np font = cv2.FONT_HERSHEY_SIMPLEX img = cv2.imread(r"E:\jinji\20210315\xiangdui\100cm\rgb\0010.jpg") cv2.imshow("ooo",img) cv2.waitKey() cimg = img hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) # color range lower_red1 = np.a...
Python+OpenCV构建机器视觉辅助系统源码及文档
资源摘要信息: "本项目是一个基于Python语言和OpenCV库的机器视觉柔性加工辅助系统。机器视觉是指用机器代替人眼进行测量和判断的技术，是工业自动化和智能检测中的重要技术之一。在智能制造和柔性加工中，机器视觉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值