【C++&&OpenCv】道路交通标线之白色虚线和鱼骨线检测

最新推荐文章于 2023-05-24 17:10:08 发布
原创 最新推荐文章于 2023-05-24 17:10:08 发布 · 794 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#opencv #c++

道路交通标线之白色虚线和鱼骨线检测

流程图

代码思路完全按照流程图实现，其中的参数可以根据实际要处理的环境调整
检测白色虚线流程图

检测白色虚线流程图

检测鱼骨线流程图

检测鱼骨线流程图

代码

#include <iostream>
#include "opencv2/opencv.hpp"
#include "opencv2/highgui.hpp"
#include "math.h"
using namespace std;
using namespace cv;


double getLineLength(Point p1,Point p2){
    return sqrt(pow(p1.x-p2.x,2)+pow(p1.y-p2.y,2));
}
double getLineGradient(Point p1,Point p2){
    if(p1.x==p2.x||p1.x-p2.x==0){
        p1.x = p1.x + 1;
    }
    return (p1.y-p2.y)/(p1.x-p2.x);
}
//处理离群直线
void handlingOutlierLines(vector<Vec4i> &Lines,size_t threshold){
    double maxLength,minLength;
    maxLength = getLineLength(Point(Lines[0][0],Lines[0][1]),Point(Lines[0][2], Lines[0][3]));
    minLength = getLineLength(Point(Lines[0][0],Lines[0][1]),Point(Lines[0][2], Lines[0][3]));
    cout<<"enter handlingOutlierLines"<<endl;
    int number = Lines.size();
    while(number>threshold){
        double mean = 0.0;
        double sum = 0.0;
        for(size_t i=0;i<number;i++){
            if(getLineLength(Point(Lines[i][0],Lines[i][1]),Point(Lines[i][2], Lines[i][3]))>maxLength){
                maxLength = getLineLength(Point(Lines[i][0],Lines[i][1]),Point(Lines[i][2], Lines[i][3]));
            }
            if(getLineLength(Point(Lines[i][0],Lines[i][1]),Point(Lines[i][2], Lines[i][3]))<minLength){
                minLength = getLineLength(Point(Lines[i][0],Lines[i][1]),Point(Lines[i][2], Lines[i][3]));
            }
            sum += getLineGradient(Point(Lines[i][0],Lines[i][1]),Point(Lines[i][2], Lines[i][3]));
        }
        mean = sum/number;
        cout<<"mean: "<<mean<<endl;
        vector<Vec4i>::iterator it = Lines.begin();
        while(it!=Lines.end()){
            Vec4i vec = *it;
            double gradient = getLineGradient(Point(vec[0],vec[1]),Point(vec[2], vec[3]));
            if(fabs(gradient-mean)>fabs(20*mean)){
               it = Lines.erase(it);
            }else{
                ++it;
            }
        }
        number = Lines.size();
    }
    cout<<"maxLength: "<<maxLength<<" minLength: "<<minLength<<"lineNumber: "<<Lines.size()<<endl;
};
//检测空洞
Mat connected_components_stat(Mat& image) {

    // 二值化
    Mat gray, binary;
    cvtColor(image, gray, COLOR_BGR2GRAY);
    threshold(gray, binary, 200, 255, THRESH_BINARY);

    //开运算、闭运算
    Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3), Point(-1, -1));
    //morphologyEx(binary, binary, MORPH_DILATE, kernel);
    //morphologyEx(binary, binary, MORPH_CLOSE, kernel);

    imshow("binaryImage",binary);

    //计算连通域
    Mat labels = Mat::zeros(image.size(), CV_32S);
    Mat stats, centroids;
    int num_labels = connectedComponentsWithStats(binary, labels, stats, centroids, 8, 4);
    //使用不同的颜色标记连通域
    vector<unsigned char> colors(num_labels);
    // 背景颜色
    colors[0] = 0;
    //将白色空洞染成黑色
    for (int i = 1; i < num_labels; i++) {
        Vec2d pt = centroids.at<Vec2d>(i, 0);
        int x = stats.at<int>(i, CC_STAT_LEFT);
        int y = stats.at<int>(i, CC_STAT_TOP);
        int width = stats.at<int>(i, CC_STAT_WIDTH);
        int height = stats.at<int>(i, CC_STAT_HEIGHT);
        int area = stats.at<int>(i, CC_STAT_AREA);
        if(area<=20||area>400||(y<image.rows/2&&area>100)){
            colors[i] = 0;
        }else{
            colors[i] = 255;
        }
    }

    Mat result = Mat::zeros(image.size(),CV_8U);
    int w = image.cols;
    int h = image.rows;
    for (int row = 0; row < h; row++) {
        for (int col = 0; col < w; col++) {
            int label = labels.at<int>(row, col);
            if (label == 0) continue;
            result.at<unsigned char>(row, col) = colors[label];
        }
    }

    imshow("result", result);
    return result;
}

void detectWhiteDottedLine(string imgPath){
    Mat image = imread(imgPath);
    imshow("image",image);

    Mat result;
    result = connected_components_stat(image);

//    Mat gaussImage;
//    GaussianBlur(binaryImage,gaussImage,Size(3,3),0,0);
//    imshow("gaussImage",gaussImage);
//
    Mat cannyImage;
    Canny(result,cannyImage,235,250);
    imshow("cannyImage",cannyImage);

    Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3), Point(-1, -1));
    //morphologyEx(cannyImage,cannyImage,MORPH_DILATE,kernel);

    Mat OutputImage = imread(imgPath);
    vector<Vec4i> Lines;
    HoughLinesP(cannyImage, Lines, 1, CV_PI / 360,30, 20, 20);
    cout<<"检测到的直线的数量是："<<Lines.size()<<endl;
    //handlingOutlierLines(Lines,Lines.size()-1);
    double max;
    Vec4i max1,max2;
    max = getLineLength(Point(Lines[0][0],Lines[0][1]),Point(Lines[0][2], Lines[0][3]));
    max1 = {Lines[0][0],Lines[0][1],Lines[0][2],Lines[0][3]};
    for (size_t i = 0; i < Lines.size(); i++)
    {
        double lineLength = getLineLength(Point(Lines[i][0],Lines[i][1]),Point(Lines[i][2], Lines[i][3]));
        if(lineLength>max){
            max = lineLength;
            max2 = max1;
            max1 ={Lines[i][0],Lines[i][1],Lines[i][2], Lines[i][3]};
        }
        if(lineLength>0){
            line(OutputImage, Point(Lines[i][0], Lines[i][1]), Point(Lines[i][2], Lines[i][3]), Scalar(0, 0, 255), 2, 8);
        }
    }
    cout<<max1<<" "<<max2<<" "<<max<<endl;
    imshow("OutputImage", OutputImage);
    waitKey(0);
    destroyAllWindows();
}
void detectWhiteDottedLine2(string imgPath){
    Mat image = imread(imgPath,IMREAD_GRAYSCALE);
    imshow("image",image);
    Mat binaryImage;
    threshold(image,binaryImage,220,250,THRESH_BINARY);
    imshow("binaryImage",binaryImage);

    Mat morphImage;
    Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3), Point(-1, -1));
    morphologyEx(binaryImage,morphImage,MORPH_DILATE,kernel);
    imshow("morphImage",morphImage);
//
//    Mat gaussImage;
//    GaussianBlur(binaryImage,gaussImage,Size(3,3),0,0);
//    imshow("gaussImage",gaussImage);

    Mat cannyImage;
    Canny(morphImage,cannyImage,235,250);
    imshow("cannyImage",cannyImage);

    //计算连通域
    Mat labels = Mat::zeros(image.size(), CV_32S);
    Mat stats, centroids;
    int num_labels = connectedComponentsWithStats(cannyImage, labels, stats, centroids, 8, 4);
    //使用不同的颜色标记连通域
    vector<unsigned char> colors(num_labels);
    // 背景颜色
    colors[0] = 0;
    //将白色空洞染成黑色
    for (int i = 1; i < num_labels; i++) {
        Vec2d pt = centroids.at<Vec2d>(i, 0);
        //int x = stats.at<int>(i, CC_STAT_LEFT);
        int y = stats.at<int>(i, CC_STAT_TOP);
        //int width = stats.at<int>(i, CC_STAT_WIDTH);
        //int height = stats.at<int>(i, CC_STAT_HEIGHT);
        int area = stats.at<int>(i, CC_STAT_AREA);
        if(area<=35){
            colors[i] = 0;
        }else{
            colors[i] = 255;
        }
    }

    Mat result = Mat::zeros(image.size(),CV_8U);
    int w = image.cols;
    int h = image.rows;
    for (int row = 0; row < h; row++) {
        for (int col = 0; col < w; col++) {
            int label = labels.at<int>(row, col);
            if (label == 0) continue;
            result.at<unsigned char>(row, col) = colors[label];
        }
    }

    imshow("result", result);
//    Mat gaussImage;
//    GaussianBlur(result,gaussImage,Size(3,3),0,0);
//    imshow("gaussImage",gaussImage);

    Mat OutputImage = imread(imgPath);
    vector<Vec4i> Lines;
    HoughLinesP(result, Lines, 1, CV_PI / 360,50, 20, 30);
    cout<<"检测到的直线的数量是："<<Lines.size()<<endl;
    //handlingOutlierLines(Lines,Lines.size()-1);
    double max;
    Vec4i max1,max2;
    max = getLineLength(Point(Lines[0][0],Lines[0][1]),Point(Lines[0][2], Lines[0][3]));
    max1 = {Lines[0][0],Lines[0][1],Lines[0][2],Lines[0][3]};
    for (size_t i = 0; i < Lines.size(); i++)
    {
        double lineLength = getLineLength(Point(Lines[i][0],Lines[i][1]),Point(Lines[i][2], Lines[i][3]));
        if(lineLength>max){
            max = lineLength;
            max2 = max1;
            max1 ={Lines[i][0],Lines[i][1],Lines[i][2], Lines[i][3]};
        }
        if(lineLength>10&&lineLength<90){
            line(OutputImage, Point(Lines[i][0], Lines[i][1]), Point(Lines[i][2], Lines[i][3]), Scalar(0, 0, 255), 2, 8);
        }
    }
    cout<<max1<<" "<<max2<<" "<<max<<endl;
    imshow("OutputImage", OutputImage);
    waitKey(0);
    destroyAllWindows();
}

double getAngle(Point angle,Point edge1,Point edge2){
    double vec1_x = edge1.x - angle.x;
    double vec1_y = edge1.y - angle.y;
    double vec2_x = edge2.x - angle.x;
    double vec2_y = edge2.y - angle.y;
    double cos = (vec1_x*vec2_x+vec1_y*vec2_y)/( sqrt(pow(vec1_x,2)+pow(vec1_y,2)) * sqrt(pow(vec2_x,2)+pow(vec2_y,2)) );
    double result = acos(cos)/CV_PI*180;
    return result;
}
void detectFishboneLine(string imgPath){
    Mat image = imread(imgPath);
    Mat grayImage;
    cvtColor(image,grayImage,COLOR_RGB2GRAY);
    Mat binaryImage;
    threshold(grayImage,binaryImage,210,255,THRESH_BINARY);
    imshow("binaryImage",binaryImage);

    Mat dst0 = Mat::zeros(binaryImage.size(), CV_8UC3);
    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;
    findContours(binaryImage, contours, hierarchy, RETR_LIST, CHAIN_APPROX_SIMPLE);
    Mat contoursImage = image.clone();
    drawContours(contoursImage,contours,-1,Scalar(0,0,0),3);
    imshow("contoursImage",contoursImage);
    vector<vector<Point>> points(contours.size());
    for(int i = 0; i < contours.size(); i++){
        approxPolyDP(contours[i],points[i],3, true);
    }

    for(int i = 0; i < contours.size(); i++){
        if(points[i].size()==4){
            Point p1 = points[i][0];
            Point p2 = points[i][1];
            Point p3 = points[i][2];
            Point p4 = points[i][3];
            double sum = 0;
            double a1 = getAngle(p1,p2,p4);
            double a2 = getAngle(p2,p1,p3);
            double a3 = getAngle(p3,p2,p4);
            double a4 = getAngle(p4,p3,p1);
            sum = a1 + a2 + a3 + a4;
            if(sum>300&&sum<400){
                //cout<<"###"<<i<<points[i]<<endl;
                drawContours(image,points,i,Scalar(0,255,255),3);
            }
        }

    }
    imshow("output", image);

    waitKey(0);
    destroyAllWindows();
}
int main() {

    string imgPath = ".\imageProcess\\xx3.png";
    string imgPath1 = ".\imageProcess\\ygx1.png";
    int choice;
    cout<<"Detect white dotted line input 1, detect fishbone line input 2:"<<endl;
    cin>>choice;
    if(choice==1){

        cout<<"Enter the picture path + picture name:"<<endl;
        cin>>imgPath;
        detectWhiteDottedLine2(imgPath);
    }else{
        cout<<"Enter the picture path + picture name:"<<endl;
        cin>>imgPath1;
        detectFishboneLine(imgPath1);
    };

    return 0;
}

效果图

因为是同一套代码使用不同的测试图，所以检测效果不是特别好。如果是固定的路段或者是可以截取到比较固定的ROI的话，那么针对性地进行调参，结果会更好一些。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

参考文章

python+opencv车道线，实线虚线的检测
入门版的车道线检测（python+opencv）
OpenCV实战案例——车道线识别
HoughLinesP参数设置（看完还不会你砍死我！！！）
连通域标记图像ConnectedComponents
OpenCV C++（九）----几何形状的检测和拟合
approxPolyDP（拟合多边形）

C++ - opencv应用实例之矩形框检测
yohnyang的博客
01-02 3978
C++ - opencv应用实例之矩形框检测
使用OpenCV完成车道线检测功能
热门推荐
梦想家林肯
02-25 5万+
实验名称：车道线检测 本项目是基于反透视变换和Hough直线检测完成的。要理解反透视变换首先要理解摄像机坐标系，成像坐标系和图像坐标系的关系。 1st. 对原视频进行反透视变换，将视角转变为鸟瞰图。 2nd.对视频进行一些预处理，如腐蚀膨胀，平滑处理等，设置ROI，减少画面中车道线以外的干扰物的影响。 3rd. 进行Canny变换，检测出画面的边缘并且对图像自动进行二值化处理。 4th.所得图像进行Hough变换，通过阀值，线段最短长度，连接为线段的最长间隔的设定来检测出画面中存在的直线。 5th.直线筛选
OpenCV实战案例——车道线识别
weixin_54627824的博客
10-15 2万+
方法：在图像中，黑色表示0，白色为1，那么要保留矩形内的白色线，就使用逻辑与，当然前提是图像矩形外也是0，那么就采用创建一个全0图像，然后在矩形内全1，之后与之前的canny图像进行与操作，即可得到需要的车道线边缘。TIPs:使用霍夫变换需要将图像先二值化。
python+opencv车道线，实线虚线的检测
weixin_45685889的博客
07-17 6664
最近在做一个基于opencv的无人小车，行车过程中遇到障碍时需要变道，由于实线不能变道，所以要判断车道线。但是找了很多地方却找不到关于车道线的实线虚线检测，于是通过自己的奇思妙想，想到了解决的办法，于是写下此博客，希望能帮到更多的人。 入门版的车道线检测 参考的资料 在此参考代码基础上完成的实线，虚线检测 代码 import cv2 as cv import numpy as np import utils #读取图片 src = cv.imread('test_images/test3.jpg') #高
测试虚线
weixin_30820151的博客
08-12 133
测试虚线 ------------------------------- 1. 随笔为作者自己经验以及学习的总结；欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接 2. ； 3. 测试虚线 ------------------------------- 转载于:https://www.cnblog...
基于opencv的道路车道线检测
01-10
基于opencv的道路车道线检测。 采用了边缘检测法先检测出绘图图像的边缘，再hough直线拟合，拟合出图中的直线。由于这样查找到的直线非常多，所以先筛选掉角度明显有误的直线，在剩下的直线中保留最长的一组。 ...
【OpenCV • c++】几何检测 —— 霍夫变换 | 霍夫直线检测 | 霍夫线变化
Ceylan__的博客
05-24 3606
霍夫变化是从图像中识别几何形状的基本图像处理方法之一，应用广泛。霍夫变换用来检测图像中的直线，其原理是利用坐标空间变换将两个坐标进行相应的转换，或通过直线映射到另一坐标空间的点形成的峰值。从而把检测任意形状的问题转化为统计峰值的问题。它的优点在于分割结果的鲁棒性，它的缺点是要求知道物体边界线的解析方程。
【opencv-c++】斑点检测即Blob检测
jn10010537的博客
08-08 3237
Blob分析工具可以从背景中分离出目标，并可以计算出目标的数量、位置、形状、方向和大小，还可以提供相关斑点间的拓扑结构。直观上来看，blob特征就是一团东西，它并不一定是圆形的，但它是一团独立存在的特征，他们是像素组成的一小块，一小块的特征。斑点代表的是一个区域，相比单纯的角点，它的稳定性要好，抗噪声能力要强，往往也是我们图像处理中最关心得区域！在一幅图像上，暗背景上的亮区域，或者亮背景上的暗区域，他们都可以叫做Blob斑点！例如，对于圆，这个值是1，对于椭圆，它在0和1之间，对于直线，它是0。......
【C++】OpenCV：YOLO目标检测介绍及实现示例
DevFrank的博客
11-02 6877
YOLO目标检测介绍及实现示例
基于opencv的车道线检测代码
08-22
基于opencv的车道线检测
【opencv】角点检测——虚线表格
月照大江流的博客
08-23 1366
【opencv】角点检测——虚线表格处理对象——虚线表格处理方法——角点检测Harris角点检测函数解读处理结果 处理对象——虚线表格 把之前做研电赛的东西做一点小的分享，先给大家看一下所处理的对象。可以看到我们所面对的表格具有特殊性和复杂性，表格线为虚线，且存在错位情况。在这种情况下想要准确检测出表格区域，并不是容易的事。 我们需要对这种原始图像做较多的预处理，以达到去掉文字干扰的目的，下次的博客可以再对这块进行一个细致的说明。 我制作了一张预处理之后的图片来做算法测试。 处理方法——角点检测 角点检
在ROS中使用opencv-识别白线
穿着帆布鞋也能走猫步
04-19 1746
在ROS中使用opencv识别白线
车道线检测（opencv c++）
auto driving
11-22 605
数字图像处理——车道线检测（c++实现） - 知乎
OpenCv 画(椭圆)虚线
q176014901dfh的博客
06-02 1508
直接贴代码，矩形框同理 int Drawing_Random_Ellipses(Mat image, char* window_name, RNG rng) { int lineType = 8; int line_num = 36; for (int i = 0; i < 1; i++) { Point center; center.x = 650;//rng.uniform(x_1, x_2); center.y = 350;//rng.uniform(y_1, y_2);
图像表格实线和虚线检测
zjuPeco的博客
11-12 4196
图像中的实线和虚线检测
opencv车道线检测
m0_59521425的博客
05-09 2499
由此获得世界坐标系形式为（1,0,0），（2,0,0），（3,0,0）····为内交点的世界坐标用wld_object来保存，而通过cv2.findChessboardCorners获得的交点像素坐标系由img_object=[]保存，下一步带入cv2.calibrateCamera（）来获得mtx是相机的内参矩阵；dist表述的相机畸变参数；经过提取车道线后，可以的到非黑即白的二值化图像，可以利用直方图统计的方法来确定车道线在图像上的位置如下直方图所示横轴为图像水平坐标系，纵轴为像素个数。
OpenCV--基础车道线检测
enginelong的博客
06-20 484
import cv2 import numpy as np video_path = "D:\\opencv\\lane_detection.mp4" video_capture = cv2.VideoCapture(video_path) def roi(img, vertices): # 定义一个和输入图像同样大小的全黑图像mask mask = np.zeros_like(img) # 判断输入图像的通道个数 if len(img.shape) > 2:
opencv 车道线检测（三）
weixin_40137925的博客
07-02 832
opencv 车道线检测（三）
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值