opencv 기반 차선 검 측 실현

opencv 의 차선 검 측 을 바탕 으로 참고 하 시기 바 랍 니 다.구체 적 인 내용 은 다음 과 같 습 니 다.
원리:
알고리즘 기본 사상 설명:
전통 적 인 차선 검 측 은 대부분이 호 프 직선 검 측 을 바탕 으로 하 는 것 이다.사실은 이 안에 큰 잘못된 부분 이 있다.호 프 직선 적합 은 각종 소음 에 영향 을 받 기 쉬 우 며 가끔 효과 가 좋 지 않다.더 많은 경우 에 호 프 직선 검 측 을 통 해 초보적인 선별 을 한 다음 에 목적 성 있 게 직선 적합 을 한다.적합 한 직선 네 개의 점 좌표 에 따라차선 을 그립 니 다.이런 방식 은 호 프 의 직선 적합 불량 결 과 를 효과적으로 피 할 수 있 고 더욱 안정 적 인 차선 검 측 방법 입 니 다.실제 프로젝트 에서 두 가지 방법 을 병행 할 수 있 습 니 다.결 과 를 계산 한 후에 중첩 하거나 비교 추출 을 할 수 있 습 니 다.오늘 공 유 된 사례 는 주로 호 프 의 직선 검 사 를 돌 았 습 니 다.2 치 이미지 에 대한 윤곽 분석 과 기하학 적 분석 을 통 해 관련 차선 정 보 를 추출 한 다음 에 특정 지역 의 픽 셀 스 캔 을 실시 하여 직선 방정식 을 만 들 고 네 개의 점 을 확정 하여 차선 을 그립 니 다.연속 적 인 영상 에 있어 서 특정한 프레임 이 정상적으로 검사 되 지 않 으 면 캐 시 를 통 해 그 리 는 것 을 대체 할 수 있 습 니 다.현재 동 영상 차선 검사 에서 실시 간 으로 신뢰 할 수 있 습 니 다.
원리 도:

코드:

#include <opencv2/opencv.hpp>
#include <iostream>
#include <cmath>

using namespace cv;
using namespace std;

/**
**1、     
**2、   
**3、    
**4、    、    ，    
**5、    
**6、    
**
*/

Point left_line[2];
Point right_line[2];

void process(Mat &frame, Point *left_line, Point *right_line);
Mat fitLines(Mat &image, Point *left_line, Point *right_line);

int main(int argc, char** argv) {
 //    
 VideoCapture capture("E:/opencv/road_line.mp4");

 int height = capture.get(CAP_PROP_FRAME_HEIGHT);
 int width = capture.get(CAP_PROP_FRAME_WIDTH);
 int count = capture.get(CAP_PROP_FRAME_COUNT);
 int fps = capture.get(CAP_PROP_FPS);
 //   

 left_line[0] = Point(0,0);

 left_line[1] = Point(0, 0);
 
 right_line[0] = Point(0, 0);
 
 right_line[1] = Point(0, 0);

 cout << height<<" "<< width<< " " <<count<< " " <<fps << endl;

 //      
 Mat frame;
 while (true) {
 int ret = capture.read(frame);
 if (!ret) {
 break;
 }
 imshow("input", frame);
 process(frame, left_line, right_line);

 char c = waitKey(5);
 if (c == 27) {
 break;
 }
 
 
 }

}

void process(Mat &frame, Point *left_line, Point *right_line ){
 Mat gray,binary;
 /**   */
 cvtColor(frame, gray, COLOR_BGR2GRAY);
 
 //threshold(gray, binary, );
 //    
 Canny(gray, binary, 150, 300);
 //imshow("Canny", binary);
 for (size_t i = 0; i < (gray.rows/2+40); i++) {
 for (size_t j = 0; j < gray.cols; j++)
 {
 binary.at<uchar>(i, j) = 0;
 }
 }
 imshow("binary", binary);
 
 //    
 vector<vector<Point>> contours;
 findContours(binary, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);

 Mat out_image = Mat::zeros(gray.size(), gray.type());

 for (int i = 0; i < contours.size(); i++)
 {
 
 //       
 double length = arcLength(contours[i], true);
 double area = contourArea(contours[i]);
 //cout << "   length:" << length << endl;
 //cout << "   area:" << area << endl;

 //      
 Rect rect = boundingRect(contours[i]);
 int h = gray.rows - 50;

 //    ：
 if (length < 5.0 || area < 10.0) {
 continue;
 }
 if (rect.y > h) {
 continue;
 }

 //      
 RotatedRect rrt = minAreaRect(contours[i]);
 
 //cout << "       angle:" << rrt.angle << endl;

 double angle = abs(rrt.angle);
 
 //angle < 50.0 || angle>89.0

 if (angle < 20.0 || angle>84.0) {

 continue;

 }
 

 if (contours[i].size() > 5) {
 //     
 RotatedRect errt = fitEllipse(contours[i]);
 //cout << "     err.angle:" << errt.angle << endl;

 if ((errt.angle<5.0) || (errt.angle>160.0))
 {
 if (80.0 < errt.angle && errt.angle < 100.0) {
 continue;
 }
 
 }
 }


 //cout << "    ：" << endl;
 drawContours(out_image, contours, i, Scalar(255), 2, 8);
 imshow("out_image", out_image);

 }
 Mat result = fitLines(out_image, left_line, right_line);
 imshow("result", result);

 Mat dst;
 addWeighted(frame, 0.8, result, 0.5,0, dst);
 imshow("lane-lines", dst);

}

//    
Mat fitLines(Mat &image, Point *left_line, Point *right_line) {
 int height = image.rows;
 int width = image.cols;

 Mat out = Mat::zeros(image.size(), CV_8UC3);

 int cx = width / 2;
 int cy = height / 2;

 vector<Point> left_pts;
 vector<Point> right_pts;
 Vec4f left;
 

 for (int i = 100; i < (cx-10); i++)
 {
 for (int j = cy; j < height; j++)
 {
 int pv = image.at<uchar>(j, i);
 if (pv == 255) 
 {
 left_pts.push_back(Point(i, j));
 }
 }
 }

 for (int i = cx; i < (width-20); i++)
 {
 for (int j = cy; j < height; j++)
 {
 int pv = image.at<uchar>(j, i);
 if (pv == 255)
 {
 right_pts.push_back(Point(i, j));
 }
 }
 }

 if (left_pts.size() > 2)
 {
 fitLine(left_pts, left, DIST_L1, 0, 0.01, 0.01);
 
 double k1 = left[1] / left[0];
 double step = left[3] - k1 * left[2];

 int x1 = int((height - step) / k1);
 int y2 = int((cx - 25)*k1 + step);

 Point left_spot_1 = Point(x1, height);
 Point left_spot_end = Point((cx - 25), y2);
 

 line(out, left_spot_1, left_spot_end, Scalar(0, 0, 255), 8, 8, 0);
 left_line[0] = left_spot_1;
 left_line[1] = left_spot_end;

 }
 else
 {
 line(out, left_line[0], left_line[1], Scalar(0, 0, 255), 8, 8, 0);
 }



 if (right_pts.size()>2)
 {
 
 Point spot_1 = right_pts[0];
 Point spot_end = right_pts[right_pts.size()-1];

 int x1 = spot_1.x;
 
 int y1 = spot_1.y;

 int x2 = spot_end.x;
 int y2 = spot_end.y;

 

 line(out, spot_1, spot_end, Scalar(0, 0, 255), 8, 8, 0);
 right_line[0] = spot_1;
 right_line[1] = spot_end;

 }
 else
 {
 line(out, right_line[0], right_line[1], Scalar(0, 0, 255), 8, 8, 0);
 }

 return out;
}

결과 그림:

이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.