• 【OpenCV】红绿灯识别 轮廓识别 C++ OpenCV 案例实现

    目录

    前言

    一、轮廓识别相关原理

    什么是轮廓检测？ 

    轮廓提取函数  findContours

    二、案例实现

    Step1：初始化配置

    Step2：进行帧处理

    Step3：膨胀腐蚀处理

    Step4：红绿灯提示判断

    Step5：轮廓提取

    Step4：判断是否相交

    🚀案例效果

    💡完整代码

    三、总结

    前言

    本文以实现行车过程当中的红绿灯识别为目标，核心的内容包括：OpenCV轮廓识别原理以及OpenCV红绿灯识别的实现具体步骤

    一、轮廓识别相关原理

    什么是轮廓检测？ 

    • 目前轮廓检测方法有两类，一类是利用传统的边缘检测算子检测目标轮廓，另一类是从人类视觉系统中提取可以使用的数学模型完成目标轮廓检测

     

    轮廓提取函数  findContours

    📍函数原型: findContours( InputOutputArray image, OutputArrayOfArrays contours,
                                  OutputArray hierarchy, int mode,
                                  int method, Point offset=Point());

    📍参数：

    1️⃣image：单通道图像矩阵，可以是灰度图，但更常用的是二值图像，一般是经过Canny、拉普拉斯等边缘检测算子处理过的二值图像

    2️⃣contours:  定义为“vector> contours”，是一个向量，并且是一个双重向量，向量内每个元素保存了一组由连续的Point点构成的点的集合的向量，每一组Point点集就是一个轮廓。有多少轮廓，向量contours就有多少元素

    3️⃣hierarchy:  也是一个向量，向量内每个元素保存了一个包含4个int整型的数组。向量内的元素和轮廓向量contours内的元素是一一对应的，向量的容量相同

    4️⃣int mode: 

    取值一：CV_CHAIN_APPROX_NONE 保存物体边界上所有连续的轮廓点到 contours向量内

    取值二：CV_CHAIN_APPROX_SIMPLE 仅保存轮廓的拐点信息，把所有轮廓拐点处的点保存入contours向量内，拐点与拐点之间直线段上的信息点不予保留

    取值三和四：CV_CHAIN_APPROX_TC89_L1，CV_CHAIN_APPROX_TC89_KCOS使用teh-Chinl chain 近似算法

    5️⃣Point： Point偏移量，所有的轮廓信息相对于原始图像对应点的偏移量，相当于在每一个检测出的轮廓点上加上该偏移量，并且Point还可以是负值！

    参数详解引用出处：findContours函数参数详解_-牧野-的博客-CSDN博客_findcontours函数 

     

    二、案例实现

    • 这是本案例所用到的素材，如下图所示： 

    PS：视频的效果比较好，如果方便的话可以自行外出拍摄取材

     

    Step1：初始化配置

    • 做好准备工作，创建我们需要的内容，设置亮度参数，以及我们导入的视频路径
    1.     int redCount = 0;
    2.     int greenCount = 0;
    3.  
    4.     Mat frame;
    5.     Mat img;
    6.     Mat imgYCrCb;
    7.     Mat imgGreen;
    8.     Mat imgRed;
    9.  
    10.     // 亮度参数
    11.     double a = 0.3;
    12.     double b = (1 - a) * 125;
    13.  
    14.     VideoCapture capture("C:/Users/86177/Desktop/image/123.mp4");//导入视频的路径
    15.     if (!capture.isOpened())
    16.     {
    17.         cout << "Start device failed!\n" << endl;//启动设备失败！
    18.         return -1;
    19.     }

    Step2：进行帧处理

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

    Step3：膨胀腐蚀处理

    • 去除其他噪点，提高我们需要的红绿灯的特征
    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));
    6.  
    7.         redCount = processImgR(imgRed);
    8.         greenCount = processImgG(imgGreen);
    9.         cout << "red:" << redCount << ";  " << "green:" << greenCount << endl;

    Step4：红绿灯提示判断

    • 加入红绿灯识别结果显示，方便我们查看效果
    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.         }

     

    Step5：轮廓提取

    • 分别对红灯和绿灯进行轮廓特征提取，提高辨识度
    1. int processImgR(Mat src)
    2. {
    3.     Mat tmp;
    4.  
    5.     vector> contours;
    6.     vector hierarchy;
    7.     vector hull;
    8.  
    9.     CvPoint2D32f tempNode;
    10.     CvMemStorage* storage = cvCreateMemStorage();
    11.     CvSeq* pointSeq = cvCreateSeq(CV_32FC2, sizeof(CvSeq), sizeof(CvPoint2D32f), storage);
    12.  
    13.     Rect* trackBox;
    14.     Rect* result;
    15.     int resultNum = 0;
    16.  
    17.     int area = 0;
    18.     src.copyTo(tmp);
    19.  
    20.     //提取轮廓
    21.     findContours(tmp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
    22.  
    23.     if (contours.size() > 0)
    24.     {
    25.         trackBox = new Rect[contours.size()];
    26.         result = new Rect[contours.size()];
    27.  
    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.             }
    42.  
    43.             trackBox[i] = cvBoundingRect(pointSeq);
    44.         }
    45.  
    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.         }
    76.  
    77.         delete[] trackBox;
    78.     }
    79.     else
    80.     {
    81.         isFirstDetectedR = true;
    82.         result = NULL;
    83.     }
    84.     cvReleaseMemStorage(&storage);
    85.  
    86.     if (result != NULL)
    87.     {
    88.         for (int i = 0; i < resultNum; i++)
    89.         {
    90.             area += result[i].area();
    91.         }
    92.     }
    93.     delete[] result;
    94.  
    95.     return area;
    96. }
    97.  
    98. int processImgG(Mat src)
    99. {
    100.     Mat tmp;
    101.  
    102.     vector > contours;
    103.     vector hierarchy;
    104.     vector< Point > hull;
    105.  
    106.     CvPoint2D32f tempNode;
    107.     CvMemStorage* storage = cvCreateMemStorage();
    108.     CvSeq* pointSeq = cvCreateSeq(CV_32FC2, sizeof(CvSeq), sizeof(CvPoint2D32f), storage);
    109.  
    110.     Rect* trackBox;
    111.     Rect* result;
    112.     int resultNum = 0;
    113.  
    114.     int area = 0;
    115.  
    116.     src.copyTo(tmp);
    117.     //提取轮廓
    118.     findContours(tmp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
    119.  
    120.     if (contours.size() > 0)
    121.     {
    122.         trackBox = new Rect[contours.size()];
    123.         result = new Rect[contours.size()];
    124.  
    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.             }
    139.  
    140.             trackBox[i] = cvBoundingRect(pointSeq);
    141.         }
    142.  
    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.         }
    173.  
    174.         delete[] trackBox;
    175.     }
    176.     else
    177.     {
    178.         isFirstDetectedG = true;
    179.         result = NULL;
    180.     }
    181.     cvReleaseMemStorage(&storage);
    182.  
    183.     if (result != NULL)
    184.     {
    185.         for (int i = 0; i < resultNum; i++)
    186.         {
    187.             area += result[i].area();
    188.         }
    189.     }
    190.     delete[] result;
    191.  
    192.     return area;
    193. }

     

    Step4：判断是否相交

    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);
    8.  
    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 
    4. #include 
    5.  
    6. using namespace std;
    7. using namespace cv;
    8.  
    9. // Function headers
    10. int processImgR(Mat);
    11. int processImgG(Mat);
    12. bool isIntersected(Rect, Rect);
    13.  
    14. // Global variables
    15. bool isFirstDetectedR = true;
    16. bool isFirstDetectedG = true;
    17. Rect* lastTrackBoxR;
    18. Rect* lastTrackBoxG;
    19. int lastTrackNumR;
    20. int lastTrackNumG;
    21.  
    22. //主函数
    23. int main()
    24. {
    25.     int redCount = 0;
    26.     int greenCount = 0;
    27.  
    28.     Mat frame;
    29.     Mat img;
    30.     Mat imgYCrCb;
    31.     Mat imgGreen;
    32.     Mat imgRed;
    33.  
    34.     // 亮度参数
    35.     double a = 0.3;
    36.     double b = (1 - a) * 125;
    37.  
    38.     VideoCapture capture("C:/Users/86177/Desktop/image/123.mp4");//导入视频的路径
    39.     if (!capture.isOpened())
    40.     {
    41.         cout << "Start device failed!\n" << endl;//启动设备失败！
    42.         return -1;
    43.     }
    44.  
    45.     // 帧处理
    46.     while (1)
    47.     {
    48.         capture >> frame;
    49.         //调整亮度
    50.         frame.convertTo(img, img.type(), a, b);
    51.  
    52.         //转换为YCrCb颜色空间
    53.         cvtColor(img, imgYCrCb, CV_BGR2YCrCb);
    54.  
    55.         imgRed.create(imgYCrCb.rows, imgYCrCb.cols, CV_8UC1);
    56.         imgGreen.create(imgYCrCb.rows, imgYCrCb.cols, CV_8UC1);
    57.  
    58.         //分解YCrCb的三个成分
    59.         vector planes;
    60.         split(imgYCrCb, planes);
    61.         // 遍历以根据Cr分量拆分红色和绿色
    62.         MatIterator_ it_Cr = planes[1].begin(),
    63.                 it_Cr_end = planes[1].end();
    64.         MatIterator_ it_Red = imgRed.begin();
    65.         MatIterator_ it_Green = imgGreen.begin();
    66.  
    67.         for (; it_Cr != it_Cr_end; ++it_Cr, ++it_Red, ++it_Green)
    68.         {
    69.             // RED, 145
    70.             if (*it_Cr > 145 && *it_Cr < 470)
    71.                 *it_Red = 255;
    72.             else
    73.                 *it_Red = 0;
    74.  
    75.             // GREEN 95
    76.             if (*it_Cr > 95 && *it_Cr < 110)
    77.                 *it_Green = 255;
    78.             else
    79.                 *it_Green = 0;
    80.         }
    81.  
    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));
    87.  
    88.         redCount = processImgR(imgRed);
    89.         greenCount = processImgG(imgGreen);
    90.         cout << "red:" << redCount << ";  " << "green:" << greenCount << endl;
    91.  
    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.         }
    101.  
    102.         imshow("video", frame);
    103.         imshow("Red", imgRed);
    104.         imshow("Green", imgGreen);
    105.  
    106.         // Handle with the keyboard input
    107.         if (cvWaitKey(20) == 'q')
    108.             break;
    109.     }
    110.  
    111.     return 0;
    112. }
    113.  
    114. int processImgR(Mat src)
    115. {
    116.     Mat tmp;
    117.  
    118.     vector> contours;
    119.     vector hierarchy;
    120.     vector hull;
    121.  
    122.     CvPoint2D32f tempNode;
    123.     CvMemStorage* storage = cvCreateMemStorage();
    124.     CvSeq* pointSeq = cvCreateSeq(CV_32FC2, sizeof(CvSeq), sizeof(CvPoint2D32f), storage);
    125.  
    126.     Rect* trackBox;
    127.     Rect* result;
    128.     int resultNum = 0;
    129.  
    130.     int area = 0;
    131.     src.copyTo(tmp);
    132.  
    133.     //提取轮廓
    134.     findContours(tmp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
    135.  
    136.     if (contours.size() > 0)
    137.     {
    138.         trackBox = new Rect[contours.size()];
    139.         result = new Rect[contours.size()];
    140.  
    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.             }
    155.  
    156.             trackBox[i] = cvBoundingRect(pointSeq);
    157.         }
    158.  
    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.         }
    189.  
    190.         delete[] trackBox;
    191.     }
    192.     else
    193.     {
    194.         isFirstDetectedR = true;
    195.         result = NULL;
    196.     }
    197.     cvReleaseMemStorage(&storage);
    198.  
    199.     if (result != NULL)
    200.     {
    201.         for (int i = 0; i < resultNum; i++)
    202.         {
    203.             area += result[i].area();
    204.         }
    205.     }
    206.     delete[] result;
    207.  
    208.     return area;
    209. }
    210.  
    211. int processImgG(Mat src)
    212. {
    213.     Mat tmp;
    214.  
    215.     vector > contours;
    216.     vector hierarchy;
    217.     vector< Point > hull;
    218.  
    219.     CvPoint2D32f tempNode;
    220.     CvMemStorage* storage = cvCreateMemStorage();
    221.     CvSeq* pointSeq = cvCreateSeq(CV_32FC2, sizeof(CvSeq), sizeof(CvPoint2D32f), storage);
    222.  
    223.     Rect* trackBox;
    224.     Rect* result;
    225.     int resultNum = 0;
    226.  
    227.     int area = 0;
    228.  
    229.     src.copyTo(tmp);
    230.     //提取轮廓
    231.     findContours(tmp, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
    232.  
    233.     if (contours.size() > 0)
    234.     {
    235.         trackBox = new Rect[contours.size()];
    236.         result = new Rect[contours.size()];
    237.  
    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.             }
    252.  
    253.             trackBox[i] = cvBoundingRect(pointSeq);
    254.         }
    255.  
    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.         }
    286.  
    287.         delete[] trackBox;
    288.     }
    289.     else
    290.     {
    291.         isFirstDetectedG = true;
    292.         result = NULL;
    293.     }
    294.     cvReleaseMemStorage(&storage);
    295.  
    296.     if (result != NULL)
    297.     {
    298.         for (int i = 0; i < resultNum; i++)
    299.         {
    300.             area += result[i].area();
    301.         }
    302.     }
    303.     delete[] result;
    304.  
    305.     return area;
    306. }
    307.  
    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);
    315.  
    316.     if (minX < maxX && minY < maxY)
    317.         return true;
    318.     else
    319.         return false;
    320. }

    三、总结

    • 本文主要讲解OpenCV轮廓识别原理以及OpenCV红绿灯识别的实现具体步骤
    • OpenCV还是有很多识别的库函数可以用，接下来继续探索，结合生活实际继续做一些有意思的案例

    以上就是本文的全部内容啦！如果对您有帮助，麻烦点赞啦！收藏啦！欢迎各位评论区留言！！ ! 

     

  • 相关阅读:
    Mac 打开 MySQL
    Spring boot与Spring cloud 之间的关系
    Alibaba官方上线，SpringBoot+SpringCloud全彩指南（第五版）
    前端进击笔记第二十五节 通过前端工程化提升团队开发效率
    数字信号处理-8-自相关
    Java Maven POM配置参考
    关于CW32单片机pack包安装 KEIL IAR
    Gem5 Fullsystem，Spec2017
    HTML+CSS+JS制作一个迅雷看看电影网页设计实例 ，排版整洁，内容丰富，主题鲜明，简单的网页制作期末作业
    【车联网应用笔记】OTA从理论到落地
  • 原文地址：https://blog.csdn.net/m0_61745661/article/details/126102217