0% found this document useful (0 votes)
144 views10 pages

AMRobots 3

This document describes a computer vision program for real-time road lane detection. The program uses OpenCV to read video frames from a camera, perform color thresholding to detect white and yellow lanes, apply edge detection and morphological operations to identify lane lines, and use Hough transforms to determine the position of lanes. Key steps include converting frames to HSV color space, thresholding for white and yellow colors, combining results, detecting edges, closing gaps, and drawing detected lane lines onto the output frame.

Uploaded by

Khoa Võ
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
144 views10 pages

AMRobots 3

This document describes a computer vision program for real-time road lane detection. The program uses OpenCV to read video frames from a camera, perform color thresholding to detect white and yellow lanes, apply edge detection and morphological operations to identify lane lines, and use Hough transforms to determine the position of lanes. Key steps include converting frames to HSV color space, thresholding for white and yellow colors, combining results, detecting edges, closing gaps, and drawing detected lane lines onto the output frame.

Uploaded by

Khoa Võ
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 10

/// Real Time Road Lane Detection

/* Computer Vision Tutorials

by Shafik Alsalem (c)

2018

[email protected]

*/

#include <opencv2/highgui/highgui.hpp>

#include <opencv2/imgproc/imgproc.hpp>

#include <iostream>

using namespace std;

using namespace cv;

int main()

VideoCapture cap(0);

if(!cap.isOpened())

cout<<"error";

return -1;

}
Mat frame1(640,480,CV_8UC3);

Mat whiteLane(640,480,CV_8UC3);

Mat yellowLane(640,480,CV_8UC3);

Mat LinesImg(640,480,CV_8UC3);

Mat HSV_Img(640,480,CV_8UC3);

while(1)

bool b=cap.read(frame1);

if(!b)

cout<<"err";

cap.open("laneD.mp4");

cap.read(frame1);

// break;

//resize image

resize(frame1, frame1, Size(640,480) );

//Sum the colour values in each channel

cv::Scalar sumImg=sum(frame1);

//normalise by the number of pixes in the image to obtain an extimate for the
illuminant

cv::Scalar illum=sumImg/(frame1.rows*frame1.cols);
// Split the image into different channels

std::vector<cv::Mat> rgbChannels(3);

cv::split(frame1, rgbChannels);

//Assign the three colour channels to CV::Mat variables for processing

cv::Mat redImg=rgbChannels[2];

cv::Mat greenImg=rgbChannels[1];

cv::Mat blueImg=rgbChannels[0];

//calculate scale factor for normalisation you can use 255 instead

double scale=(illum(0)+illum(1)+illum(2))/3;

//correct for illuminant (white balancing)

redImg=redImg*scale/illum(2);

greenImg=greenImg*scale/illum(1);

blueImg=blueImg*scale/illum(0);

//Assign the processed channels back into vector to use in the cv::merge()
function
rgbChannels[0]=blueImg;

rgbChannels[1]=greenImg;

rgbChannels[2]=redImg;

/// Merge the processed colour channels

Mat frame;

merge(rgbChannels, frame);

//Create a window

// convert our img to HSV Space

cvtColor(frame, HSV_Img, CV_RGB2HSV);

//white color thresholding

Scalar whiteMinScalar = Scalar(191,178,176);

Scalar whiteMaxScalar = Scalar(111,93,255);

inRange(HSV_Img, whiteMinScalar, whiteMaxScalar, whiteLane);

//yellow color thresholding

Scalar yellowMinScalar = Scalar(65,122,143);

Scalar yellowMaxScalar = Scalar(101,255,255);


inRange(HSV_Img, yellowMinScalar, yellowMaxScalar, yellowLane);

//namedWindow("framme");

//imshow("framme",HSV_Img);

//combine our two images in one image

addWeighted(whiteLane, 1.0, yellowLane, 1.0, 0.0, LinesImg);

// Edge detection using canny detector

int minCannyThreshold = 190;

int maxCannyThreshold = 230;

Canny(LinesImg, LinesImg, minCannyThreshold, maxCannyThreshold, 5, true);

// Morphological Operation

Mat k=getStructuringElement(CV_SHAPE_RECT,Size(9,9)); //MATLAB :k=Ones(9)

morphologyEx(LinesImg, LinesImg, MORPH_CLOSE, k);

// now applying hough transform TO dETECT Lines in our image

vector<Vec4i> lines;

double rho = 1;

double theta = CV_PI/180;

int threshold = 43;

double minLinLength = 35;

double maxLineGap = 300;

HoughLinesP(LinesImg, lines, rho, theta, threshold, minLinLength, maxLineGap );


float stt[3][yellowLane.rows][yellowLane.cols];

int gt[4];

for (int col = 0; col < yellowLane.cols; col++)

for (int row = 0; row < yellowLane.rows; row++)

Vec3i color = frame.at<Vec3f>(row,col);

int blue = color.val[0];

int green = color.val[1];

int red = color.val[2];

if((blue!=0)&&(green!=0)&&(red!=0))

printf("%d %d %d \n",blue,green,red);

//stt[0][row][col] = (LinesImg.at<uchar>(color.val[0],row,col));

//stt[1][row][col] =(double)(LinesImg.at<uchar>(color.val[1],row,col));

//stt[2][row][col] =(double)(LinesImg.at<uchar>(color.val[2],row,col));

break;

//for (int col = 0; col < yellowLane.cols; col++)

//for (int row = 0; row < yellowLane.rows; row++)

//{

//if(stt[row][col]==255)

//{

//gt[0]=row;

//gt[1]=col;

//break;

//}
//}

////printf("%d \n",gt[0]);

//for (int col = yellowLane.cols; col >0; col--)

//for (int row = yellowLane.rows; row > 0; row--)

//{

//if(stt[row][col]==255)

//{

//gt[2]=row;

//gt[3]=col;

//break;

//}

//}

//printf("%lf \n",stt[0][yellowLane.rows]);

//draw our lines

//for( size_t i = 0; i < lines.size(); i++ )

//{

//Vec4i l = lines[i]; // we have 4 elements p1=x1,y1 p2= x2,y2

//Scalar greenColor= Scalar(0,250,30); // B=0 G=250 R=30

//Scalar redColor= Scalar(0,0,255);

//stt++;

//if((stt==1)||(stt==4))

//{

//cout << line[i] << end1;

//}

//line( frame, Point(l[0], l[1]), Point(l[2], l[3]), greenColor, 50, CV_AA);

////if(stt>4)

////stt=0;
////line( frame, Point(l2[0], l2[1]), Point(l2[2], l2[3]), redColor , 3,
CV_AA);

//}

//line(frame,Point((gt[2] + gt[0])/2,gt[1]),Point((gt[2] +
gt[0])/2,gt[3]),Scalar(255),2,8,0);

namedWindow("frame");

imshow("frame",frame);

namedWindow("YellowLane");

imshow("YellowLane",yellowLane);

//namedWindow("WhiteLane");

//imshow("WhiteLane",HSV_Img);

///// Separate the image in 3 places ( B, G and R )

//vector<Mat> bgr_planes;

//split( HSV_Img, bgr_planes );

///// Establish the number of bins

//int histSize = 256;

///// Set the ranges ( for B,G,R) )

//float range[] = { 0, 256 } ;

//const float* histRange = { range };

//bool uniform = true; bool accumulate = false;


//Mat b_hist, g_hist, r_hist;

///// Compute the histograms:

//calcHist( &bgr_planes[0], 1, 0, Mat(), b_hist, 1, &histSize, &histRange,


uniform, accumulate );

//calcHist( &bgr_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, &histRange,


uniform, accumulate );

//calcHist( &bgr_planes[2], 1, 0, Mat(), r_hist, 1, &histSize, &histRange,


uniform, accumulate );

//// Draw the histograms for B, G and R

//int hist_w = 512; int hist_h = 400;

//int bin_w = cvRound( (double) hist_w/histSize );

//Mat histImage( hist_h, hist_w, CV_8UC3, Scalar( 0,0,0) );

///// Normalize the result to [ 0, histImage.rows ]

//normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );

//normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );

//normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );

///// Draw for each channel

//for( int i = 1; i < histSize; i++ )

//{

//line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-


1)) ) ,

//Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ),

//Scalar( 255, 0, 0), 2, 8, 0 );

//line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-


1)) ) ,

//Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),


//Scalar( 0, 255, 0), 2, 8, 0 );

//line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-


1)) ) ,

//Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),

//Scalar( 0, 0, 255), 2, 8, 0 );

//}

if(waitKey(30)==27)

cout<<"esc";

break;

return 0;

You might also like