opcv检测直线交叉_OpenCV 直线检测-阿里云开发者社区

/*------------------------------------------------------------------------------------------*\

This file contains material supporting chapter 7 of the cookbook:

Computer Vision Programming using the OpenCV Library.

by Robert Laganiere, Packt Publishing, 2011.

This program is free software; permission is hereby granted to use, copy, modify,

and distribute this source code, or portions thereof, for any purpose, without fee,

subject to the restriction that the copyright notice may not be removed

or altered from any source or altered source distribution.

The software is released on an as-is basis and without any warranties of any kind.

In particular, the software is not guaranteed to be fault-tolerant or free from failure.

The author disclaims all warranties with regard to this software, any use,

and any consequent failure, is purely the responsibility of the user.

Copyright (C) 2010-2011 Robert Laganiere, www.laganiere.name

\*------------------------------------------------------------------------------------------*/

#if !defined LINEF

#define LINEF

#include

#include

#define PI 3.1415926

class LineFinder {

private:

// original image

cv::Mat img;

// vector containing the end points

// of the detected lines

std::vector<:vec4i> lines;

// accumulator resolution parameters

double deltaRho;

double deltaTheta;

// minimum number of votes that a line

// must receive before being considered

int minVote;

// min length for a line

double minLength;

// max allowed gap along the line

double maxGap;

public:

// Default accumulator resolution is 1 pixel by 1 degree

// no gap, no mimimum length

LineFinder() : deltaRho(1), deltaTheta(PI/180), minVote(10), minLength(0.), maxGap(0.) {}

// Set the resolution of the accumulator

void setAccResolution(double dRho, double dTheta)

{

deltaRho= dRho;

deltaTheta= dTheta;

}

// Set the minimum number of votes

void setMinVote(int minv)

{

minVote= minv;

}

// Set line length and gap

void setLineLengthAndGap(double length, double gap)

{

minLength= length;

maxGap= gap;

}

// Apply probabilistic Hough Transform

std::vector<:vec4i> findLines(cv::Mat& binary)

{

lines.clear();

cv::HoughLinesP(binary,lines,deltaRho,deltaTheta,minVote, minLength, maxGap);

return lines;

}

// Draw the detected lines on an image

void drawDetectedLines(cv::Mat &image, cv::Scalar color=cv::Scalar(255,255,255))

{

// Draw the lines

std::vector<:vec4i>::const_iterator it2= lines.begin();

while (it2!=lines.end()) {

cv::Point pt1((*it2)[0],(*it2)[1]);

cv::Point pt2((*it2)[2],(*it2)[3]);

cv::line( image, pt1, pt2, color);

++it2;

}

}

// Eliminates lines that do not have an orientation equals to

// the ones specified in the input matrix of orientations

// At least the given percentage of pixels on the line must

// be within plus or minus delta of the corresponding orientation

std::vector<:vec4i> removeLinesOfInconsistentOrientations(

const cv::Mat &orientations, double percentage, double delta)

{

std::vector<:vec4i>::iterator it= lines.begin();

// check all lines

while (it!=lines.end()) {

// end points

int x1= (*it)[0];

int y1= (*it)[1];

int x2= (*it)[2];

int y2= (*it)[3];

// line orientation + 90o to get the parallel line

double ori1= atan2(static_cast(y1-y2),static_cast(x1-x2))+PI/2;

if (ori1>PI) ori1= ori1-2*PI;

double ori2= atan2(static_cast(y2-y1),static_cast(x2-x1))+PI/2;

if (ori2>PI) ori2= ori2-2*PI;

// for all points on the line

cv::LineIterator lit(orientations,cv::Point(x1,y1),cv::Point(x2,y2));

int i,count=0;

for(i = 0, count=0; i < lit.count; i++, ++lit) {

float ori= *(reinterpret_cast(*lit));

// is line orientation similar to gradient orientation ?

if (std::min(fabs(ori-ori1),fabs(ori-ori2))

count++;

}

double consistency= count/static_cast(i);

// set to zero lines of inconsistent orientation

if (consistency < percentage) {

(*it)[0]=(*it)[1]=(*it)[2]=(*it)[3]=0;

}

++it;

}

return lines;

}

};

#endif

// HoughLines.cpp : 定义控制台应用程序的入口点。

//

// findContours.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

/*------------------------------------------------------------------------------------------*\

This file contains material supporting chapter 7 of the cookbook:

Computer Vision Programming using the OpenCV Library.

by Robert Laganiere, Packt Publishing, 2011.

This program is free software; permission is hereby granted to use, copy, modify,

and distribute this source code, or portions thereof, for any purpose, without fee,

subject to the restriction that the copyright notice may not be removed

or altered from any source or altered source distribution.

The software is released on an as-is basis and without any warranties of any kind.

In particular, the software is not guaranteed to be fault-tolerant or free from failure.

The author disclaims all warranties with regard to this software, any use,

and any consequent failure, is purely the responsibility of the user.

Copyright (C) 2010-2011 Robert Laganiere, www.laganiere.name

\*------------------------------------------------------------------------------------------*/

#include

#include

#include

#include

#include

#include "HoughLines.h"

#pragma comment(lib,"opencv_core2410d.lib")

#pragma comment(lib,"opencv_highgui2410d.lib")

#pragma comment(lib,"opencv_imgproc2410d.lib")

#define PI 3.1415926

int main()

{

// Read input image

cv::Mat image= cv::imread("road.jpg",0);

if (!image.data)

return 0;

// Display the image

cv::namedWindow("Original Image");

cv::imshow("Original Image",image);

// Apply Canny algorithm

cv::Mat contours;

cv::Canny(image,contours,125,350);

cv::Mat contoursInv;

cv::threshold(contours,contoursInv,128,255,cv::THRESH_BINARY_INV);

// Display the image of contours

cv::namedWindow("Canny Contours");

cv::imshow("Canny Contours",contoursInv);

// Hough tranform for line detection

std::vector<:vec2f> lines;

cv::HoughLines(contours,lines,1,PI/180,60);

// Draw the lines

cv::Mat result(contours.rows,contours.cols,CV_8U,cv::Scalar(255));

image.copyTo(result);

std::cout << "Lines detected: " << lines.size() << std::endl;

std::vector<:vec2f>::const_iterator it= lines.begin();

while (it!=lines.end())

{

float rho= (*it)[0]; // first element is distance rho

float theta= (*it)[1]; // second element is angle theta

if (theta < PI/4. || theta > 3.*PI/4.) { // ~vertical line

// point of intersection of the line with first row

cv::Point pt1(rho/cos(theta),0);

// point of intersection of the line with last row

cv::Point pt2((rho-result.rows*sin(theta))/cos(theta),result.rows);

// draw a white line

cv::line( result, pt1, pt2, cv::Scalar(255), 1);

} else { // ~horizontal line

// point of intersection of the line with first column

cv::Point pt1(0,rho/sin(theta));

// point of intersection of the line with last column

cv::Point pt2(result.cols,(rho-result.cols*cos(theta))/sin(theta));

// draw a white line

cv::line( result, pt1, pt2, cv::Scalar(255), 1);

}

std::cout << "line: (" << rho << "," << theta << ")\n";

++it;

}

// Display the detected line image

cv::namedWindow("Detected Lines with Hough");

cv::imshow("Detected Lines with Hough",result);

// Create LineFinder instance

LineFinder ld;

// Set probabilistic Hough parameters

ld.setLineLengthAndGap(100,20);

ld.setMinVote(80);

// Detect lines

std::vector<:vec4i> li= ld.findLines(contours);

ld.drawDetectedLines(image);

cv::namedWindow("Detected Lines with HoughP");

cv::imshow("Detected Lines with HoughP",image);

cv::waitKey();

return 0;

}

实现效果：