0
0

【OpenCV】 红绿灯识别检测

一：红绿灯识别检测效果展示

使用到了OpenCV轮廓识别

如上图 轮廓识别 分别检测识别出红灯 绿灯 [检测出来的红灯轮廓和绿灯轮廓如下图所示]

在红绿灯都亮时，可以检测到数值

当红灯不亮 绿灯亮时，红灯没有数值 绿灯显示数值

当拍摄车辆通行，也就是红绿灯都不亮的时候，红灯绿灯都没有数值

二：红绿灯识别检测具体步骤

1.初始化设置，对亮度设置 视频路径 进行初始化设置

  1.     int redCount = 0;
  2.     int greenCount = 0;
  4.     Mat frame;
  5.     Mat img;
  6.     Mat imgYCrCb;
  7.     Mat imgGreen;
  8.     Mat imgRed;
  10.     // 亮度参数
  11.     double a = 0.3;
  12.     double b = (1 - a) * 125;
  14.     VideoCapture capture("D:/00000000000003jieduanshipincailliao/123.mp4");//导入视频的路径
  15.     if (!capture.isOpened())
  16.     {
  17.         cout << "Start device failed!\n" << endl;//启动设备失败！
  18.         return -1;
  19.     }

2.帧处理，调整视频亮度，分解YCrCb的三个成分，拆分红和绿，对这两种颜色进行特征提取

  1.     // 帧处理
  2.     while (1)
  3.     {
  4.         capture >> frame;
  5.         //调整亮度
  6.         frame.convertTo(img, img.type(), a, b);
  8.         //转换为YCrCb颜色空间
  9.         cvtColor(img, imgYCrCb, CV_BGR2YCrCb);
  11.         imgRed.create(imgYCrCb.rows, imgYCrCb.cols, CV_8UC1);
  12.         imgGreen.create(imgYCrCb.rows, imgYCrCb.cols, CV_8UC1);
  14.         //分解YCrCb的三个成分
  15.         vector<Mat> planes;
  16.         split(imgYCrCb, planes);
  17.         // 遍历以根据Cr分量拆分红色和绿色
  18.         MatIterator_<uchar> it_Cr = planes[1].begin<uchar>(),
  19.                 it_Cr_end = planes[1].end<uchar>();
  20.         MatIterator_<uchar> it_Red = imgRed.begin<uchar>();
  21.         MatIterator_<uchar> it_Green = imgGreen.begin<uchar>();
  23.         for (; it_Cr != it_Cr_end; ++it_Cr, ++it_Red, ++it_Green)
  24.         {
  25.             // RED, 145<Cr<470 红色
  26.             if (*it_Cr > 145 && *it_Cr < 470)
  27.                 *it_Red = 255;
  28.             else
  29.                 *it_Red = 0;
  31.             // GREEN 95<Cr<110 绿色
  32.             if (*it_Cr > 95 && *it_Cr < 110)
  33.                 *it_Green = 255;
  34.             else
  35.                 *it_Green = 0;
  36.         }

3.腐蚀膨胀处理，去除其他噪点，提高红绿灯提取特征

  1.         //膨胀和腐蚀
  2.         dilate(imgRed, imgRed, Mat(15, 15, CV_8UC1), Point(-1, -1));
  3.         erode(imgRed, imgRed, Mat(1, 1, CV_8UC1), Point(-1, -1));
  4.         dilate(imgGreen, imgGreen, Mat(15, 15, CV_8UC1), Point(-1, -1));
  5.         erode(imgGreen, imgGreen, Mat(1, 1, CV_8UC1), Point(-1, -1));
  7.         redCount = processImgR(imgRed);
  8.         greenCount = processImgG(imgGreen);
  9.         cout << "red:" << redCount << ";  " << "green:" << greenCount << endl;

4.红绿灯识别检测，给出识别结果显示

  1.         if(redCount == 0 && greenCount == 0)
  2.         {
  3.             cv::putText(frame, "lights out", Point(40, 150), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(255, 255, 255), 8, 8, 0);
  4.         }else if(redCount > greenCount)
  5.         {
  6.             cv::putText(frame, "red light", Point(40, 150), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(0, 0, 255), 8, 8, 0);
  7.         }else{
  8.             cv::putText(frame, "green light", Point(40, 150), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(0, 255, 0), 8, 8, 0);
  9.         }

5.对红灯和绿灯进行轮廓提取

  1. int processImgR(Mat src)
  2. {
  3.     Mat tmp;
  5.     vector<vector<Point>> contours;
  6.     vector<Vec4i> hierarchy;
  7.     vector<Point> hull;
  9.     CvPoint2D32f tempNode;
  10.     CvMemStorage* storage = cvCreateMemStorage();
  11.     CvSeq* pointSeq = cvCreateSeq(CV_32FC2, sizeof(CvSeq), sizeof(CvPoint2D32f), storage);
  13.     Rect* trackBox;
  14.     Rect* result;
  15.     int resultNum = 0;
  17.     int area = 0;
  18.     src.copyTo(tmp);
  20.     //提取轮廓
  21.     findContours(tmp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
  23.     if (contours.size() > 0)
  24.     {
  25.         trackBox = new Rect[contours.size()];
  26.         result = new Rect[contours.size()];
  28.         //确定要跟踪的区域
  29.         for (int i = 0; i < contours.size(); i++)
  30.         {
  31.             cvClearSeq(pointSeq);
  32.             // 获取凸包的点集
  33.             convexHull(Mat(contours[i]), hull, true);
  34.             int hullcount = (int)hull.size();
  35.             // 凸包的保存点
  36.             for (int j = 0; j < hullcount - 1; j++)
  37.             {
  38.                 tempNode.x = hull[j].x;
  39.                 tempNode.y = hull[j].y;
  40.                 cvSeqPush(pointSeq, &tempNode);
  41.             }
  43.             trackBox[i] = cvBoundingRect(pointSeq);
  44.         }
  46.         if (isFirstDetectedR)
  47.         {
  48.             lastTrackBoxR = new Rect[contours.size()];
  49.             for (int i = 0; i < contours.size(); i++)
  50.                 lastTrackBoxR[i] = trackBox[i];
  51.             lastTrackNumR = contours.size();
  52.             isFirstDetectedR = false;
  53.         }
  54.         else
  55.         {
  56.             for (int i = 0; i < contours.size(); i++)
  57.             {
  58.                 for (int j = 0; j < lastTrackNumR; j++)
  59.                 {
  60.                     if (isIntersected(trackBox[i], lastTrackBoxR[j]))
  61.                     {
  62.                         result[resultNum] = trackBox[i];
  63.                         break;
  64.                     }
  65.                 }
  66.                 resultNum++;
  67.             }
  68.             delete[] lastTrackBoxR;
  69.             lastTrackBoxR = new Rect[contours.size()];
  70.             for (int i = 0; i < contours.size(); i++)
  71.             {
  72.                 lastTrackBoxR[i] = trackBox[i];
  73.             }
  74.             lastTrackNumR = contours.size();
  75.         }
  77.         delete[] trackBox;
  78.     }
  79.     else
  80.     {
  81.         isFirstDetectedR = true;
  82.         result = NULL;
  83.     }
  84.     cvReleaseMemStorage(&storage);
  86.     if (result != NULL)
  87.     {
  88.         for (int i = 0; i < resultNum; i++)
  89.         {
  90.             area += result[i].area();
  91.         }
  92.     }
  93.     delete[] result;
  95.     return area;
  96. }
  98. int processImgG(Mat src)
  99. {
  100.     Mat tmp;
  102.     vector<vector<Point> > contours;
  103.     vector<Vec4i> hierarchy;
  104.     vector< Point > hull;
  106.     CvPoint2D32f tempNode;
  107.     CvMemStorage* storage = cvCreateMemStorage();
  108.     CvSeq* pointSeq = cvCreateSeq(CV_32FC2, sizeof(CvSeq), sizeof(CvPoint2D32f), storage);
  110.     Rect* trackBox;
  111.     Rect* result;
  112.     int resultNum = 0;
  114.     int area = 0;
  116.     src.copyTo(tmp);
  117.     //提取轮廓
  118.     findContours(tmp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
  120.     if (contours.size() > 0)
  121.     {
  122.         trackBox = new Rect[contours.size()];
  123.         result = new Rect[contours.size()];
  125.         // 确定要跟踪的区域
  126.         for (int i = 0; i < contours.size(); i++)
  127.         {
  128.             cvClearSeq(pointSeq);
  129.             // 获取凸包的点集
  130.             convexHull(Mat(contours[i]), hull, true);
  131.             int hullcount = (int)hull.size();
  132.             // 保存凸包的点
  133.             for (int j = 0; j < hullcount - 1; j++)
  134.             {
  135.                 tempNode.x = hull[j].x;
  136.                 tempNode.y = hull[j].y;
  137.                 cvSeqPush(pointSeq, &tempNode);
  138.             }
  140.             trackBox[i] = cvBoundingRect(pointSeq);
  141.         }
  143.         if (isFirstDetectedG)
  144.         {
  145.             lastTrackBoxG = new Rect[contours.size()];
  146.             for (int i = 0; i < contours.size(); i++)
  147.                 lastTrackBoxG[i] = trackBox[i];
  148.             lastTrackNumG = contours.size();
  149.             isFirstDetectedG = false;
  150.         }
  151.         else
  152.         {
  153.             for (int i = 0; i < contours.size(); i++)
  154.             {
  155.                 for (int j = 0; j < lastTrackNumG; j++)
  156.                 {
  157.                     if (isIntersected(trackBox[i], lastTrackBoxG[j]))
  158.                     {
  159.                         result[resultNum] = trackBox[i];
  160.                         break;
  161.                     }
  162.                 }
  163.                 resultNum++;
  164.             }
  165.             delete[] lastTrackBoxG;
  166.             lastTrackBoxG = new Rect[contours.size()];
  167.             for (int i = 0; i < contours.size(); i++)
  168.             {
  169.                 lastTrackBoxG[i] = trackBox[i];
  170.             }
  171.             lastTrackNumG = contours.size();
  172.         }
  174.         delete[] trackBox;
  175.     }
  176.     else
  177.     {
  178.         isFirstDetectedG = true;
  179.         result = NULL;
  180.     }
  181.     cvReleaseMemStorage(&storage);
  183.     if (result != NULL)
  184.     {
  185.         for (int i = 0; i < resultNum; i++)
  186.         {
  187.             area += result[i].area();
  188.         }
  189.     }
  190.     delete[] result;
  192.     return area;
  193. }

6.确定两个矩形区域是否相交

  1. //确定两个矩形区域是否相交
  2. bool isIntersected(Rect r1, Rect r2)
  3. {
  4.     int minX = max(r1.x, r2.x);
  5.     int minY = max(r1.y, r2.y);
  6.     int maxX = min(r1.x + r1.width, r2.x + r2.width);
  7.     int maxY = min(r1.y + r1.height, r2.y + r2.height);
  9.     if (minX < maxX && minY < maxY)
  10.         return true;
  11.     else
  12.         return false;
  13. }

三： 红绿灯识别检测源码分享

  1. #include "opencv2/opencv.hpp"
  2. #include "opencv2/imgproc.hpp"
  3. #include <windows.h>
  4. #include <iostream>
  6. using namespace std;
  7. using namespace cv;
  9. // Function headers
  10. int processImgR(Mat);
  11. int processImgG(Mat);
  12. bool isIntersected(Rect, Rect);
  14. // Global variables
  15. bool isFirstDetectedR = true;
  16. bool isFirstDetectedG = true;
  17. Rect* lastTrackBoxR;
  18. Rect* lastTrackBoxG;
  19. int lastTrackNumR;
  20. int lastTrackNumG;
  22. //主函数
  23. int main()
  24. {
  25.     int redCount = 0;
  26.     int greenCount = 0;
  28.     Mat frame;
  29.     Mat img;
  30.     Mat imgYCrCb;
  31.     Mat imgGreen;
  32.     Mat imgRed;
  34.     // 亮度参数
  35.     double a = 0.3;
  36.     double b = (1 - a) * 125;
  38.     VideoCapture capture("D:/00000000000003jieduanshipincailliao/123.mp4");//导入视频的路径
  39.     if (!capture.isOpened())
  40.     {
  41.         cout << "Start device failed!\n" << endl;//启动设备失败！
  42.         return -1;
  43.     }
  45.     // 帧处理
  46.     while (1)
  47.     {
  48.         capture >> frame;
  49.         //调整亮度
  50.         frame.convertTo(img, img.type(), a, b);
  52.         //转换为YCrCb颜色空间
  53.         cvtColor(img, imgYCrCb, CV_BGR2YCrCb);
  55.         imgRed.create(imgYCrCb.rows, imgYCrCb.cols, CV_8UC1);
  56.         imgGreen.create(imgYCrCb.rows, imgYCrCb.cols, CV_8UC1);
  58.         //分解YCrCb的三个成分
  59.         vector<Mat> planes;
  60.         split(imgYCrCb, planes);
  61.         // 遍历以根据Cr分量拆分红色和绿色
  62.         MatIterator_<uchar> it_Cr = planes[1].begin<uchar>(),
  63.                 it_Cr_end = planes[1].end<uchar>();
  64.         MatIterator_<uchar> it_Red = imgRed.begin<uchar>();
  65.         MatIterator_<uchar> it_Green = imgGreen.begin<uchar>();
  67.         for (; it_Cr != it_Cr_end; ++it_Cr, ++it_Red, ++it_Green)
  68.         {
  69.             // RED, 145<Cr<470 红色
  70.             if (*it_Cr > 145 && *it_Cr < 470)
  71.                 *it_Red = 255;
  72.             else
  73.                 *it_Red = 0;
  75.             // GREEN 95<Cr<110 绿色
  76.             if (*it_Cr > 95 && *it_Cr < 110)
  77.                 *it_Green = 255;
  78.             else
  79.                 *it_Green = 0;
  80.         }
  82.         //膨胀和腐蚀
  83.         dilate(imgRed, imgRed, Mat(15, 15, CV_8UC1), Point(-1, -1));
  84.         erode(imgRed, imgRed, Mat(1, 1, CV_8UC1), Point(-1, -1));
  85.         dilate(imgGreen, imgGreen, Mat(15, 15, CV_8UC1), Point(-1, -1));
  86.         erode(imgGreen, imgGreen, Mat(1, 1, CV_8UC1), Point(-1, -1));
  88.         redCount = processImgR(imgRed);
  89.         greenCount = processImgG(imgGreen);
  90.         cout << "red:" << redCount << ";  " << "green:" << greenCount << endl;
  92.         if(redCount == 0 && greenCount == 0)
  93.         {
  94.             cv::putText(frame, "lights out", Point(40, 150), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(255, 255, 255), 8, 8, 0);
  95.         }else if(redCount > greenCount)
  96.         {
  97.             cv::putText(frame, "red light", Point(40, 150), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(0, 0, 255), 8, 8, 0);
  98.         }else{
  99.             cv::putText(frame, "green light", Point(40, 150), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(0, 255, 0), 8, 8, 0);
  100.         }
  102.         imshow("video", frame);
  103.         imshow("Red", imgRed);
  104.         imshow("Green", imgGreen);
  106.         // Handle with the keyboard input
  107.         if (cvWaitKey(20) == 'q')
  108.             break;
  109.     }
  111.     return 0;
  112. }
  114. int processImgR(Mat src)
  115. {
  116.     Mat tmp;
  118.     vector<vector<Point>> contours;
  119.     vector<Vec4i> hierarchy;
  120.     vector<Point> hull;
  122.     CvPoint2D32f tempNode;
  123.     CvMemStorage* storage = cvCreateMemStorage();
  124.     CvSeq* pointSeq = cvCreateSeq(CV_32FC2, sizeof(CvSeq), sizeof(CvPoint2D32f), storage);
  126.     Rect* trackBox;
  127.     Rect* result;
  128.     int resultNum = 0;
  130.     int area = 0;
  131.     src.copyTo(tmp);
  133.     //提取轮廓
  134.     findContours(tmp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
  136.     if (contours.size() > 0)
  137.     {
  138.         trackBox = new Rect[contours.size()];
  139.         result = new Rect[contours.size()];
  141.         //确定要跟踪的区域
  142.         for (int i = 0; i < contours.size(); i++)
  143.         {
  144.             cvClearSeq(pointSeq);
  145.             // 获取凸包的点集
  146.             convexHull(Mat(contours[i]), hull, true);
  147.             int hullcount = (int)hull.size();
  148.             // 凸包的保存点
  149.             for (int j = 0; j < hullcount - 1; j++)
  150.             {
  151.                 tempNode.x = hull[j].x;
  152.                 tempNode.y = hull[j].y;
  153.                 cvSeqPush(pointSeq, &tempNode);
  154.             }
  156.             trackBox[i] = cvBoundingRect(pointSeq);
  157.         }
  159.         if (isFirstDetectedR)
  160.         {
  161.             lastTrackBoxR = new Rect[contours.size()];
  162.             for (int i = 0; i < contours.size(); i++)
  163.                 lastTrackBoxR[i] = trackBox[i];
  164.             lastTrackNumR = contours.size();
  165.             isFirstDetectedR = false;
  166.         }
  167.         else
  168.         {
  169.             for (int i = 0; i < contours.size(); i++)
  170.             {
  171.                 for (int j = 0; j < lastTrackNumR; j++)
  172.                 {
  173.                     if (isIntersected(trackBox[i], lastTrackBoxR[j]))
  174.                     {
  175.                         result[resultNum] = trackBox[i];
  176.                         break;
  177.                     }
  178.                 }
  179.                 resultNum++;
  180.             }
  181.             delete[] lastTrackBoxR;
  182.             lastTrackBoxR = new Rect[contours.size()];
  183.             for (int i = 0; i < contours.size(); i++)
  184.             {
  185.                 lastTrackBoxR[i] = trackBox[i];
  186.             }
  187.             lastTrackNumR = contours.size();
  188.         }
  190.         delete[] trackBox;
  191.     }
  192.     else
  193.     {
  194.         isFirstDetectedR = true;
  195.         result = NULL;
  196.     }
  197.     cvReleaseMemStorage(&storage);
  199.     if (result != NULL)
  200.     {
  201.         for (int i = 0; i < resultNum; i++)
  202.         {
  203.             area += result[i].area();
  204.         }
  205.     }
  206.     delete[] result;
  208.     return area;
  209. }
  211. int processImgG(Mat src)
  212. {
  213.     Mat tmp;
  215.     vector<vector<Point> > contours;
  216.     vector<Vec4i> hierarchy;
  217.     vector< Point > hull;
  219.     CvPoint2D32f tempNode;
  220.     CvMemStorage* storage = cvCreateMemStorage();
  221.     CvSeq* pointSeq = cvCreateSeq(CV_32FC2, sizeof(CvSeq), sizeof(CvPoint2D32f), storage);
  223.     Rect* trackBox;
  224.     Rect* result;
  225.     int resultNum = 0;
  227.     int area = 0;
  229.     src.copyTo(tmp);
  230.     //提取轮廓
  231.     findContours(tmp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
  233.     if (contours.size() > 0)
  234.     {
  235.         trackBox = new Rect[contours.size()];
  236.         result = new Rect[contours.size()];
  238.         // 确定要跟踪的区域
  239.         for (int i = 0; i < contours.size(); i++)
  240.         {
  241.             cvClearSeq(pointSeq);
  242.             // 获取凸包的点集
  243.             convexHull(Mat(contours[i]), hull, true);
  244.             int hullcount = (int)hull.size();
  245.             // 保存凸包的点
  246.             for (int j = 0; j < hullcount - 1; j++)
  247.             {
  248.                 tempNode.x = hull[j].x;
  249.                 tempNode.y = hull[j].y;
  250.                 cvSeqPush(pointSeq, &tempNode);
  251.             }
  253.             trackBox[i] = cvBoundingRect(pointSeq);
  254.         }
  256.         if (isFirstDetectedG)
  257.         {
  258.             lastTrackBoxG = new Rect[contours.size()];
  259.             for (int i = 0; i < contours.size(); i++)
  260.                 lastTrackBoxG[i] = trackBox[i];
  261.             lastTrackNumG = contours.size();
  262.             isFirstDetectedG = false;
  263.         }
  264.         else
  265.         {
  266.             for (int i = 0; i < contours.size(); i++)
  267.             {
  268.                 for (int j = 0; j < lastTrackNumG; j++)
  269.                 {
  270.                     if (isIntersected(trackBox[i], lastTrackBoxG[j]))
  271.                     {
  272.                         result[resultNum] = trackBox[i];
  273.                         break;
  274.                     }
  275.                 }
  276.                 resultNum++;
  277.             }
  278.             delete[] lastTrackBoxG;
  279.             lastTrackBoxG = new Rect[contours.size()];
  280.             for (int i = 0; i < contours.size(); i++)
  281.             {
  282.                 lastTrackBoxG[i] = trackBox[i];
  283.             }
  284.             lastTrackNumG = contours.size();
  285.         }
  287.         delete[] trackBox;
  288.     }
  289.     else
  290.     {
  291.         isFirstDetectedG = true;
  292.         result = NULL;
  293.     }
  294.     cvReleaseMemStorage(&storage);
  296.     if (result != NULL)
  297.     {
  298.         for (int i = 0; i < resultNum; i++)
  299.         {
  300.             area += result[i].area();
  301.         }
  302.     }
  303.     delete[] result;
  305.     return area;
  306. }
  308. //确定两个矩形区域是否相交
  309. bool isIntersected(Rect r1, Rect r2)
  310. {
  311.     int minX = max(r1.x, r2.x);
  312.     int minY = max(r1.y, r2.y);
  313.     int maxX = min(r1.x + r1.width, r2.x + r2.width);
  314.     int maxY = min(r1.y + r1.height, r2.y + r2.height);
  316.     if (minX < maxX && minY < maxY)
  317.         return true;
  318.     else
  319.         return false;
  320. }
标签： opencv 人工智能 c++
本文转载自: https://blog.csdn.net/m0_56051805/article/details/126286905
版权归原作者 顾城沐心 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【OpenCV】 红绿灯识别检测”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？