Lane Detector divider lines c ++ with OpenCV

Refresh

December 2018

Views

3.8k time

2

Now I have been working on the analysis of images with OpenCV, what I'm trying to do is recognize the lane dividing lines, what I do is the following:

1.I receive a image,
2. Then transform it to grayscale
3.I apply the GaussianBlur
4.After I place me in the ROI
5.I apply the canny
6.then I look for lines with hough transform Lines 
7.Draw the lines obtained from hough

But I've run into a problem which is: that recognizes no dividing lines both rail and neither recognizes the yellow lines.

I hope to help me solve this problem, you will thank a lot. Then I put the code

#include "opencv2/highgui/highgui.hpp"
#include <opencv2/objdetect/objdetect.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>
#include <vector>
#include <stdio.h>
#include "linefinder.h"

using namespace cv;

int main(int argc, char* argv[]) {
int houghVote = 200;
string arg = argv[1];
Mat image;
image = imread(argv[1]);    
    Mat gray;
    cvtColor(image,gray,CV_RGB2GRAY);
   GaussianBlur( gray, gray, Size( 5, 5 ), 0, 0 );
    vector<string> codes;
    Mat corners;
    findDataMatrix(gray, codes, corners);
    drawDataMatrixCodes(image, codes, corners);
 //Mat image = imread("");
    //Rect region_of_interest = Rect(x, y, w, h);
    //Mat image_roi = image(region_of_interest);
 std::cout << image.cols << "\n";
 std::cout << image.rows << "\n";
 Rect roi(0,290,640,190);// set the ROI for the image
 Mat imgROI = image(roi);
 // Display the image
 imwrite("original.bmp", imgROI);
// Canny algorithm
Mat contours;
Canny(imgROI, contours, 120, 300, 3); 
imwrite("canny.bmp", contours);
Mat contoursInv;
threshold(contours,contoursInv,128,255,THRESH_BINARY_INV);
// Display Canny image
imwrite("contours.bmp", contoursInv);

/* 
Hough tranform for line detection with feedback
Increase by 25 for the next frame if we found some lines.  
This is so we don't miss other lines that may crop up in the next frame
but at the same time we don't want to start the feed back loop from scratch. 
*/
std::vector<Vec2f> lines;
if (houghVote < 1 or lines.size() > 2){ // we lost all lines. reset 
    houghVote = 200; 
}else{ 
    houghVote += 25;
} 
while(lines.size() < 5 && houghVote > 0){
    HoughLines(contours,lines,1,PI/180, houghVote);
    houghVote -= 5;
}
std::cout << houghVote << "\n";
Mat result(imgROI.size(),CV_8U,Scalar(255));
imgROI.copyTo(result);
// Draw the limes
std::vector<Vec2f>::const_iterator it= lines.begin();
Mat hough(imgROI.size(),CV_8U,Scalar(0));
while (it!=lines.end()) {
    float rho= (*it)[0];   // first element is distance rho
    float theta= (*it)[1]; // second element is angle theta
    if ( theta > 0.09 && theta < 1.48 || theta < 3.14 && theta > 1.66 ) { 
    // filter to remove    vertical and horizontal lines
        // point of intersection of the line with first row
        Point pt1(rho/cos(theta),0);        
        // point of intersection of the line with last row
        Point pt2((rho-result.rows*sin(theta))/cos(theta),result.rows);
        // draw a white line
        line( result, pt1, pt2, Scalar(255), 8); 
        line( hough, pt1, pt2, Scalar(255), 8);
    }
    ++it;
   }

   // Display the detected line image
   std::cout << "line image:"<< "\n";
   namedWindow("Detected Lines with Hough");
   imwrite("hough.bmp", result);

   // Create LineFinder instance
   LineFinder ld;

  // Set probabilistic Hough parameters
   ld.setLineLengthAndGap(60,10);
   ld.setMinVote(4);

  // Detect lines
  std::vector<Vec4i> li= ld.findLines(contours);
  Mat houghP(imgROI.size(),CV_8U,Scalar(0));
  ld.setShift(0);
  ld.drawDetectedLines(houghP);
  std::cout << "First Hough" << "\n";
  imwrite("houghP.bmp", houghP);

  // bitwise AND of the two hough images
  bitwise_and(houghP,hough,houghP);
  Mat houghPinv(imgROI.size(),CV_8U,Scalar(0));
  Mat dst(imgROI.size(),CV_8U,Scalar(0));
  threshold(houghP,houghPinv,150,255,THRESH_BINARY_INV); // threshold and invert to black lines
  namedWindow("Detected Lines with Bitwise");
  imshow("Detected Lines with Bitwise", houghPinv);

  Canny(houghPinv,contours,100,350);
  li= ld.findLines(contours);
 // Display Canny image
 imwrite("contours.bmp", contoursInv);

 // Set probabilistic Hough parameters
  ld.setLineLengthAndGap(5,2);
  ld.setMinVote(1);
  ld.setShift(image.cols/3);
  ld.drawDetectedLines(image);

  std::stringstream stream;
  stream << "Lines Segments: " << lines.size();

  putText(image, stream.str(), Point(10,image.rows-10), 2, 0.8, Scalar(0,0,255),0); 
  imwrite("processed.bmp", image);

  char key = (char) waitKey(10);
  lines.clear();
  }

The following are the input images respectively: input 1 input 2

Here I show two photos one that recognizes the white line and another that does not recognize the yellow line, what I require is to recognize the dividing lines because I monitor the lane, but is complicated to me and it does not recognize the presence of all dividing lines, I hope help me because I have honestly tried everything but I have not had good results.

Lane Lane 2

1 answers

0

Я думаю, это потому, что вы делаете побитовое сложение как вероятностный Хаф и регулярных HOUGH преобразований. Это означает, что выводимое изображение будет содержать только строки, которые появляются в обеих этих преобразованиях. Я уверен, что в регулярном преобразовании линия не обнаружена, но в вероятностном выходе HOUGH обнаруживается линия. Вы лучше всего выводить и трансформирует отдельно и отладки. Я делаю подобный проект, я полагаю, вы могли бы включать в себя отдельный ROI, чтобы исключить из побитового сложения и эта область будет по Центруму из разметки.