C++ opencv实现车道线识别

2023-07-05 09:34:03 263

本文实例为大家分享了C++opencv实现车道线识别的具体代码，供大家参考，具体内容如下

先上图

1、

2、

（一）目前国内外广泛使用的车道线检测方法主要分为两大类：

（1）基于道路特征的车道线检测；

（2）基于道路模型的车道线检测。

基于道路特征的车道线检测作为主流检测方法之一，主要是利用车道线与道路环境的物理特征差异进行后续图像的分割与处理，从而突出车道线特征，以实现车道线的检测。该方法复杂度较低，实时性较高，但容易受到道路环境干扰。
基于道路模型的车道线检测主要是基于不同的二维或三维道路图像模型（如直线型、抛物线型、样条曲线型、组合模型等），采用相应方法确定各模型参数，然后进行车道线拟合。该方法对特定道路的检测具有较高的准确度，但局限性强、运算量大、实时性较差。

（二）在这我介绍一种车道线检测方法，效果在高速上还可以，对于破损道路，光照变化太大等道路效果不佳，后续继续改进（直方图均衡以及多特征融合等等），这里有个基础版本的接口，大致步骤如下

（1）图像灰度化
（2）图像高斯滤波
（3）边缘检测
（4）获取掩膜，获取感兴趣区域
（5）霍夫变换检测直线
（6）将检测到的车道线分类，设置阈值，以图像中线分为左右两边的车道线，存入一个vector
（7）回归两条直线，即左右分别两个点，且求出斜率方程
（8）确定车道线的转弯与否

下面我贴出代码

（1）头文件（LaneDetector.h）

classLaneDetector
{
private:
doubleimg_size;
doubleimg_center;
boolleft_flag=false;//Tellsusifthere'sleftboundaryoflanedetected
boolright_flag=false;//Tellsusifthere'srightboundaryoflanedetected
cv::Pointright_b;//Membersofbothlineequationsofthelaneboundaries:
doubleright_m;//y=m*x+b
cv::Pointleft_b;//
doubleleft_m;//

public:
cv::MatdeNoise(cv::MatinputImage);//ApplyGaussianblurringtotheinputImage
cv::MatedgeDetector(cv::Matimg_noise);//Filtertheimagetoobtainonlyedges
cv::Matmask(cv::Matimg_edges);//MasktheedgesimagetoonlycareaboutROI
std::vectorhoughLines(cv::Matimg_mask);//DetectHoughlinesinmaskededgesimage
std::vector>lineSeparation(std::vectorlines,cv::Matimg_edges);//Sprtdetectedlinesbytheirslopeintorightandleftlines
std::vectorregression(std::vector>left_right_lines,cv::MatinputImage);//Getonlyonelineforeachsideofthelane
std::stringpredictTurn();//Determineifthelaneisturningornotbycalculatingthepositionofthevanishingpoint
intplotLane(cv::MatinputImage,std::vectorlane,std::stringturn);//Plottheresultantlaneandturnpredictionintheframe.
};

源文件LaneDetector.cpp

*@fileLaneDetector.cpp
*@authorMiguelMaestreTrueba
*@briefDefinitionofallthefunctionthatformpartoftheLaneDetectorclass.
*@briefTheclasswilltakeRGBimagesasinputsandwilloutputthesameRGBimagebut
*@briefwiththeplotofthedetectedlanesandtheturnprediction.
*/
#include
#include
#include
#include"LaneDetector.h"

//IMAGEBLURRING
/**
*@briefApplygaussianfiltertotheinputimagetodenoiseit
*@paraminputImageistheframeofavideoinwhichthe
*@paramlaneisgoingtobedetected
*@returnBlurredanddenoisedimage
*/
cv::MatLaneDetector::deNoise(cv::MatinputImage){
cv::Matoutput;

cv::GaussianBlur(inputImage,output,cv::Size(3,3),0,0);

returnoutput;
}

//EDGEDETECTION
/**
*@briefDetectalltheedgesintheblurredframebyfilteringtheimage
*@paramimg_noiseisthepreviouslyblurredframe
*@returnBinaryimagewithonlytheedgesrepresentedinwhite
*/
cv::MatLaneDetector::edgeDetector(cv::Matimg_noise){
cv::Matoutput;
cv::Matkernel;
cv::Pointanchor;

//ConvertimagefromRGBtogray
cv::cvtColor(img_noise,output,cv::COLOR_RGB2GRAY);
//Binarizegrayimage
cv::threshold(output,output,140,255,cv::THRESH_BINARY);

//Createthekernel[-101]
//Thiskernelisbasedontheonefoundinthe
//LaneDepartureWarningSystembyMathworks
anchor=cv::Point(-1,-1);
kernel=cv::Mat(1,3,CV_32F);
kernel.at(0,0)=-1;
kernel.at(0,1)=0;
kernel.at(0,2)=1;

//Filterthebinaryimagetoobtaintheedges
cv::filter2D(output,output,-1,kernel,anchor,0,cv::BORDER_DEFAULT);
cv::imshow("output",output);
returnoutput;
}

//MASKTHEEDGEIMAGE
/**
*@briefMasktheimagesothatonlytheedgesthatformpartofthelanearedetected
*@paramimg_edgesistheedgesimagefromthepreviousfunction
*@returnBinaryimagewithonlythedesirededgesbeingrepresented
*/
cv::MatLaneDetector::mask(cv::Matimg_edges){
cv::Matoutput;
cv::Matmask=cv::Mat::zeros(img_edges.size(),img_edges.type());
cv::Pointpts[4]={
cv::Point(210,720),
cv::Point(550,450),
cv::Point(717,450),
cv::Point(1280,720)
};

//Createabinarypolygonmask
cv::fillConvexPoly(mask,pts,4,cv::Scalar(255,0,0));
//Multiplytheedgesimageandthemasktogettheoutput
cv::bitwise_and(img_edges,mask,output);

returnoutput;
}

//HOUGHLINES
/**
*@briefObtainallthelinesegmentsinthemaskedimageswhicharegoingtobepartofthelaneboundaries
*@paramimg_maskisthemaskedbinaryimagefromthepreviousfunction
*@returnVectorthatcontainsallthedetectedlinesintheimage
*/
std::vectorLaneDetector::houghLines(cv::Matimg_mask){
std::vectorline;

//rhoandthetaareselectedbytrialanderror
HoughLinesP(img_mask,line,1,CV_PI/180,20,20,30);

returnline;
}

//SORTRIGHTANDLEFTLINES
/**
*@briefSortallthedetectedHoughlinesbyslope.
*@briefThelinesareclassifiedintorightorleftdepending
*@briefonthesignoftheirslopeandtheirapproximatelocation
*@paramlinesisthevectorthatcontainsallthedetectedlines
*@paramimg_edgesisusedfordeterminingtheimagecenter
*@returnTheoutputisavector(2)thatcontainsalltheclassifiedlines
*/
std::vector>LaneDetector::lineSeparation(std::vectorlines,cv::Matimg_edges){
std::vector>output(2);
size_tj=0;
cv::Pointini;
cv::Pointfini;
doubleslope_thresh=0.3;
std::vectorslopes;
std::vectorselected_lines;
std::vectorright_lines,left_lines;

//Calculatetheslopeofallthedetectedlines
for(autoi:lines){
ini=cv::Point(i[0],i[1]);
fini=cv::Point(i[2],i[3]);

//Basicalgebra:slope=(y1-y0)/(x1-x0)
doubleslope=(static_cast(fini.y)-static_cast(ini.y))/(static_cast(fini.x)-static_cast(ini.x)+0.00001);

//Iftheslopeistoohorizontal,discardtheline
//Ifnot,savethemandtheirrespectiveslope
if(std::abs(slope)>slope_thresh){
slopes.push_back(slope);
selected_lines.push_back(i);
}
}

//Splitthelinesintorightandleftlines
img_center=static_cast((img_edges.cols/2));
while(j0&&fini.x>img_center&&ini.x>img_center){
right_lines.push_back(selected_lines[j]);
right_flag=true;
}
elseif(slopes[j]<0&&fini.xLaneDetector::regression(std::vector>left_right_lines,cv::MatinputImage){
std::vectoroutput(4);
cv::Pointini;
cv::Pointfini;
cv::Pointini2;
cv::Pointfini2;
cv::Vec4dright_line;
cv::Vec4dleft_line;
std::vectorright_pts;
std::vectorleft_pts;

//Ifrightlinesarebeingdetected,fitalineusingalltheinitandfinalpointsofthelines
if(right_flag==true){
for(autoi:left_right_lines[0]){
ini=cv::Point(i[0],i[1]);
fini=cv::Point(i[2],i[3]);

right_pts.push_back(ini);
right_pts.push_back(fini);
}

if(right_pts.size()>0){
//Therightlineisformedhere
cv::fitLine(right_pts,right_line,CV_DIST_L2,0,0.01,0.01);
right_m=right_line[1]/right_line[0];
right_b=cv::Point(right_line[2],right_line[3]);
}
}

//Ifleftlinesarebeingdetected,fitalineusingalltheinitandfinalpointsofthelines
if(left_flag==true){
for(autoj:left_right_lines[1]){
ini2=cv::Point(j[0],j[1]);
fini2=cv::Point(j[2],j[3]);

left_pts.push_back(ini2);
left_pts.push_back(fini2);
}

if(left_pts.size()>0){
//Theleftlineisformedhere
cv::fitLine(left_pts,left_line,CV_DIST_L2,0,0.01,0.01);
left_m=left_line[1]/left_line[0];
left_b=cv::Point(left_line[2],left_line[3]);
}
}

//Onetheslopeandoffsetpointshavebeenobtained,applythelineequationtoobtainthelinepoints
intini_y=inputImage.rows;
intfin_y=470;

doubleright_ini_x=((ini_y-right_b.y)/right_m)+right_b.x;
doubleright_fin_x=((fin_y-right_b.y)/right_m)+right_b.x;

doubleleft_ini_x=((ini_y-left_b.y)/left_m)+left_b.x;
doubleleft_fin_x=((fin_y-left_b.y)/left_m)+left_b.x;

output[0]=cv::Point(right_ini_x,ini_y);
output[1]=cv::Point(right_fin_x,fin_y);
output[2]=cv::Point(left_ini_x,ini_y);
output[3]=cv::Point(left_fin_x,fin_y);

returnoutput;
}

//TURNPREDICTION
/**
*@briefPredictifthelaneisturningleft,rightorifitisgoingstraight
*@briefItisdonebyseeingwherethevanishingpointiswithrespecttothecenteroftheimage
*@returnStringthatsaysifthereisleftorrightturnoriftheroadisstraight
*/
std::stringLaneDetector::predictTurn(){
std::stringoutput;
doublevanish_x;
doublethr_vp=10;

//Thevanishingpointisthepointwherebothlaneboundarylinesintersect
vanish_x=static_cast(((right_m*right_b.x)-(left_m*left_b.x)-right_b.y+left_b.y)/(right_m-left_m));

//Thevanishingpointslocationdetermineswhereistheroadturning
if(vanish_x<(img_center-thr_vp))
output="LeftTurn";
elseif(vanish_x>(img_center+thr_vp))
output="RightTurn";
elseif(vanish_x>=(img_center-thr_vp)&&vanish_x<=(img_center+thr_vp))
output="Straight";

returnoutput;
}

//PLOTRESULTS
/**
*@briefThisfunctionplotsbothsidesofthelane,theturnpredictionmessageandatransparentpolygonthatcoverstheareainsidethelaneboundaries
*@paraminputImageistheoriginalcapturedframe
*@paramlaneisthevectorcontainingtheinformationofbothlines
*@paramturnistheoutputstringcontainingtheturninformation
*@returnThefunctionreturnsa0
*/
intLaneDetector::plotLane(cv::MatinputImage,std::vectorlane,std::stringturn){
std::vectorpoly_points;
cv::Matoutput;

//Createthetransparentpolygonforabettervisualizationofthelane
inputImage.copyTo(output);
poly_points.push_back(lane[2]);
poly_points.push_back(lane[0]);
poly_points.push_back(lane[1]);
poly_points.push_back(lane[3]);
cv::fillConvexPoly(output,poly_points,cv::Scalar(0,0,255),CV_AA,0);
cv::addWeighted(output,0.3,inputImage,1.0-0.3,0,inputImage);

//Plotbothlinesofthelaneboundary
cv::line(inputImage,lane[0],lane[1],cv::Scalar(0,255,255),5,CV_AA);
cv::line(inputImage,lane[2],lane[3],cv::Scalar(0,255,255),5,CV_AA);

//Plottheturnmessage
cv::putText(inputImage,turn,cv::Point(50,90),cv::FONT_HERSHEY_COMPLEX_SMALL,3,cvScalar(0,255,0),1,CV_AA);

//Showthefinaloutputimage
cv::namedWindow("Lane",CV_WINDOW_AUTOSIZE);
cv::imshow("Lane",inputImage);
return0;
}

main函数

#include
#include
#include
#include
#include"LaneDetector.h"
//#include"LaneDetector.cpp"

/**
*@briefFunctionmainthatrunsthemainalgorithmofthelanedetection.
*@briefItwillreadavideoofacarinthehighwayanditwilloutputthe
*@briefsamevideobutwiththeplotteddetectedlane
*@paramargv[]isastringtothefullpathofthedemovideo
*@returnflag_plottellsifthedemohassucessfullyfinished
*/
intmain(){

//Theinputargumentisthelocationofthevideo
cv::VideoCapturecap("challenge_video.mp4");
if(!cap.isOpened())
return-1;

LaneDetectorlanedetector;//Createtheclassobject
cv::Matframe;
cv::Matimg_denoise;
cv::Matimg_edges;
cv::Matimg_mask;
cv::Matimg_lines;
std::vectorlines;
std::vector>left_right_lines;
std::vectorlane;
std::stringturn;
intflag_plot=-1;
inti=0;

//Mainalgorithmstarts.Iteratethrougheveryframeofthevideo
while(i<540){
//Captureframe
if(!cap.read(frame))
break;

//DenoisetheimageusingaGaussianfilter
img_denoise=lanedetector.deNoise(frame);

//Detectedgesintheimage
img_edges=lanedetector.edgeDetector(img_denoise);

//MasktheimagesothatweonlygettheROI
img_mask=lanedetector.mask(img_edges);

//ObtainHoughlinesinthecroppedimage
lines=lanedetector.houghLines(img_mask);

if(!lines.empty())
{
//Separatelinesintoleftandrightlines
left_right_lines=lanedetector.lineSeparation(lines,img_edges);

//Applyregressiontoobtainonlyonelineforeachsideofthelane
lane=lanedetector.regression(left_right_lines,frame);

//Predicttheturnbydeterminingthevanishingpointofthethelines
turn=lanedetector.predictTurn();

//Plotlanedetection
flag_plot=lanedetector.plotLane(frame,lane,turn);

i+=1;
cv::waitKey(25);
}
else{
flag_plot=-1;
}
}
returnflag_plot;
}

最后再晒一张结果图吧

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

C++ opencv实现车道线识别

热门推荐

随机推荐