Merge pull request #892 from spacetrain:fast_line_detector
Alexander Alekhin
8 years ago
commit
a2582d43b5
8 changed files with 1092 additions and 7 deletions
|
After Width: | Height: | Size: 517 KiB |
@ -0,0 +1,81 @@ |
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html.
|
||||
|
||||
#ifndef __OPENCV_FAST_LINE_DETECTOR_HPP__ |
||||
#define __OPENCV_FAST_LINE_DETECTOR_HPP__ |
||||
|
||||
#include <opencv2/core.hpp> |
||||
|
||||
namespace cv |
||||
{ |
||||
namespace ximgproc |
||||
{ |
||||
|
||||
//! @addtogroup ximgproc_feature
|
||||
//! @{
|
||||
|
||||
/** @brief Class implementing the FLD (Fast Line Detector) algorithm described
|
||||
in @cite Lee14 . |
||||
*/ |
||||
|
||||
//! @include samples/fld_lines.cpp
|
||||
|
||||
class CV_EXPORTS_W FastLineDetector : public Algorithm |
||||
{ |
||||
public: |
||||
/** @example fld_lines.cpp
|
||||
An example using the FastLineDetector |
||||
*/ |
||||
/** @brief Finds lines in the input image.
|
||||
This is the output of the default parameters of the algorithm on the above |
||||
shown image. |
||||
|
||||
 |
||||
|
||||
@param _image A grayscale (CV_8UC1) input image. If only a roi needs to be |
||||
selected, use: `fld_ptr-\>detect(image(roi), lines, ...); |
||||
lines += Scalar(roi.x, roi.y, roi.x, roi.y);` |
||||
@param _lines A vector of Vec4f elements specifying the beginning |
||||
and ending point of a line. Where Vec4f is (x1, y1, x2, y2), point |
||||
1 is the start, point 2 - end. Returned lines are directed so that the |
||||
brighter side is on their left. |
||||
*/ |
||||
CV_WRAP virtual void detect(InputArray _image, OutputArray _lines) = 0; |
||||
|
||||
/** @brief Draws the line segments on a given image.
|
||||
@param _image The image, where the lines will be drawn. Should be bigger |
||||
or equal to the image, where the lines were found. |
||||
@param lines A vector of the lines that needed to be drawn. |
||||
@param draw_arrow If true, arrow heads will be drawn. |
||||
*/ |
||||
CV_WRAP virtual void drawSegments(InputOutputArray _image, InputArray lines, |
||||
bool draw_arrow = false) = 0; |
||||
|
||||
virtual ~FastLineDetector() { } |
||||
}; |
||||
|
||||
/** @brief Creates a smart pointer to a FastLineDetector object and initializes it
|
||||
|
||||
@param _length_threshold 10 - Segment shorter than this will be discarded |
||||
@param _distance_threshold 1.41421356 - A point placed from a hypothesis line |
||||
segment farther than this will be |
||||
regarded as an outlier |
||||
@param _canny_th1 50 - First threshold for |
||||
hysteresis procedure in Canny() |
||||
@param _canny_th2 50 - Second threshold for |
||||
hysteresis procedure in Canny() |
||||
@param _canny_aperture_size 3 - Aperturesize for the sobel |
||||
operator in Canny() |
||||
@param _do_merge false - If true, incremental merging of segments |
||||
will be perfomred |
||||
*/ |
||||
CV_EXPORTS_W Ptr<FastLineDetector> createFastLineDetector( |
||||
int _length_threshold = 10, float _distance_threshold = 1.414213562f, |
||||
double _canny_th1 = 50.0, double _canny_th2 = 50.0, int _canny_aperture_size = 3, |
||||
bool _do_merge = false); |
||||
|
||||
//! @} ximgproc_feature
|
||||
} |
||||
} |
||||
#endif |
||||
@ -0,0 +1,91 @@ |
||||
#include <iostream> |
||||
|
||||
#include "opencv2/imgproc.hpp" |
||||
#include "opencv2/ximgproc.hpp" |
||||
#include "opencv2/imgcodecs.hpp" |
||||
#include "opencv2/highgui.hpp" |
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
using namespace cv::ximgproc; |
||||
|
||||
int main(int argc, char** argv) |
||||
{ |
||||
std::string in; |
||||
cv::CommandLineParser parser(argc, argv, "{@input|../samples/data/corridor.jpg|input image}{help h||show help message}"); |
||||
if (parser.has("help")) |
||||
{ |
||||
parser.printMessage(); |
||||
return 0; |
||||
} |
||||
in = parser.get<string>("@input"); |
||||
|
||||
Mat image = imread(in, IMREAD_GRAYSCALE); |
||||
|
||||
if( image.empty() ) |
||||
{ |
||||
return -1; |
||||
} |
||||
|
||||
// Create LSD detector
|
||||
Ptr<LineSegmentDetector> lsd = createLineSegmentDetector(); |
||||
vector<Vec4f> lines_lsd; |
||||
|
||||
// Create FLD detector
|
||||
// Param Default value Description
|
||||
// length_threshold 10 - Segments shorter than this will be discarded
|
||||
// distance_threshold 1.41421356 - A point placed from a hypothesis line
|
||||
// segment farther than this will be
|
||||
// regarded as an outlier
|
||||
// canny_th1 50 - First threshold for
|
||||
// hysteresis procedure in Canny()
|
||||
// canny_th2 50 - Second threshold for
|
||||
// hysteresis procedure in Canny()
|
||||
// canny_aperture_size 3 - Aperturesize for the sobel
|
||||
// operator in Canny()
|
||||
// do_merge false - If true, incremental merging of segments
|
||||
// will be perfomred
|
||||
int length_threshold = 10; |
||||
float distance_threshold = 1.41421356f; |
||||
double canny_th1 = 50.0; |
||||
double canny_th2 = 50.0; |
||||
int canny_aperture_size = 3; |
||||
bool do_merge = false; |
||||
Ptr<FastLineDetector> fld = createFastLineDetector(length_threshold, |
||||
distance_threshold, canny_th1, canny_th2, canny_aperture_size, |
||||
do_merge); |
||||
vector<Vec4f> lines_fld; |
||||
|
||||
// Because of some CPU's power strategy, it seems that the first running of
|
||||
// an algorithm takes much longer. So here we run both of the algorithmes 10
|
||||
// times to see each algorithm's processing time with sufficiently warmed-up
|
||||
// CPU performance.
|
||||
for(int run_count = 0; run_count < 10; run_count++) { |
||||
lines_lsd.clear(); |
||||
int64 start_lsd = getTickCount(); |
||||
lsd->detect(image, lines_lsd); |
||||
// Detect the lines with LSD
|
||||
double freq = getTickFrequency(); |
||||
double duration_ms_lsd = double(getTickCount() - start_lsd) * 1000 / freq; |
||||
std::cout << "Elapsed time for LSD: " << duration_ms_lsd << " ms." << std::endl; |
||||
|
||||
lines_fld.clear(); |
||||
int64 start = getTickCount(); |
||||
// Detect the lines with FLD
|
||||
fld->detect(image, lines_fld); |
||||
double duration_ms = double(getTickCount() - start) * 1000 / freq; |
||||
std::cout << "Ealpsed time for FLD " << duration_ms << " ms." << std::endl; |
||||
} |
||||
// Show found lines with LSD
|
||||
Mat line_image_lsd(image); |
||||
lsd->drawSegments(line_image_lsd, lines_lsd); |
||||
imshow("LSD result", line_image_lsd); |
||||
|
||||
// Show found lines with FLD
|
||||
Mat line_image_fld(image); |
||||
fld->drawSegments(line_image_fld, lines_fld); |
||||
imshow("FLD result", line_image_fld); |
||||
|
||||
waitKey(); |
||||
return 0; |
||||
} |
||||
@ -0,0 +1,730 @@ |
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html.
|
||||
|
||||
#include "precomp.hpp" |
||||
#include <vector> |
||||
#include <iostream> |
||||
|
||||
struct SEGMENT |
||||
{ |
||||
float x1, y1, x2, y2, angle; |
||||
}; |
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace cv{ |
||||
namespace ximgproc{ |
||||
|
||||
class FastLineDetectorImpl : public FastLineDetector |
||||
{ |
||||
public: |
||||
/**
|
||||
* @param _length_threshold 10 - Segment shorter than this will be discarded |
||||
* @param _distance_threshold 1.41421356 - A point placed from a hypothesis line segment |
||||
* farther than this will be regarded as an outlier |
||||
* @param _canny_th1 50 - First threshold for |
||||
* _ hysteresis procedure in Canny() |
||||
* @param _canny_th2 50 - Second threshold for |
||||
* _ hysteresis procedure in Canny() |
||||
* @param _canny_aperture_size 3 - Aperturesize for the sobel |
||||
* _ operator in Canny() |
||||
* @param _do_merge false - If true, incremental merging of segments |
||||
will be perfomred |
||||
*/ |
||||
FastLineDetectorImpl(int _length_threshold = 10, float _distance_threshold = 1.414213562f, |
||||
double _canny_th1 = 50.0, double _canny_th2 = 50.0, int _canny_aperture_size = 3, |
||||
bool _do_merge = false); |
||||
|
||||
/**
|
||||
* Detect lines in the input image. |
||||
* |
||||
* @param _image A grayscale(CV_8UC1) input image. |
||||
* If only a roi needs to be selected, use |
||||
* lsd_ptr->detect(image(roi), ..., lines); |
||||
* lines += Scalar(roi.x, roi.y, roi.x, roi.y); |
||||
* @param _lines Return: A vector of Vec4f elements specifying the beginning and ending point of |
||||
* a line. Where Vec4f is (x1, y1, x2, y2), point 1 is the start, point 2 is the end. |
||||
* Returned lines are directed so that the brighter side is placed on left. |
||||
*/ |
||||
void detect(InputArray _image, OutputArray _lines); |
||||
|
||||
/**
|
||||
* Draw lines on the given canvas. |
||||
* |
||||
* @param image The image, where lines will be drawn |
||||
* Should have the size of the image, where the lines were found |
||||
* @param lines The lines that need to be drawn |
||||
* @param draw_arrow If true, arrow heads will be drawn |
||||
*/ |
||||
void drawSegments(InputOutputArray _image, InputArray lines, bool draw_arrow = false); |
||||
|
||||
private: |
||||
int imagewidth, imageheight, threshold_length; |
||||
float threshold_dist; |
||||
double canny_th1, canny_th2; |
||||
int canny_aperture_size; |
||||
bool do_merge; |
||||
|
||||
FastLineDetectorImpl& operator= (const FastLineDetectorImpl&); // to quiet MSVC
|
||||
template<class T> |
||||
void incidentPoint(const Mat& l, T& pt); |
||||
|
||||
void mergeLines(const SEGMENT& seg1, const SEGMENT& seg2, SEGMENT& seg_merged); |
||||
|
||||
bool mergeSegments(const SEGMENT& seg1, const SEGMENT& seg2, SEGMENT& seg_merged); |
||||
|
||||
bool getPointChain(const Mat& img, Point pt, Point& chained_pt, float& direction, int step); |
||||
|
||||
double distPointLine(const Mat& p, Mat& l); |
||||
|
||||
void extractSegments(const std::vector<Point2i>& points, std::vector<SEGMENT>& segments ); |
||||
|
||||
void lineDetection(const Mat& src, std::vector<SEGMENT>& segments_all); |
||||
|
||||
void pointInboardTest(const Mat& src, Point2i& pt); |
||||
|
||||
inline void getAngle(SEGMENT& seg); |
||||
|
||||
void additionalOperationsOnSegment(const Mat& src, SEGMENT& seg); |
||||
|
||||
void drawSegment(Mat& mat, const SEGMENT& seg, Scalar bgr = Scalar(0,255,0), |
||||
int thickness = 1, bool directed = true); |
||||
}; |
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
CV_EXPORTS Ptr<FastLineDetector> createFastLineDetector( |
||||
int _length_threshold, float _distance_threshold, |
||||
double _canny_th1, double _canny_th2, int _canny_aperture_size, bool _do_merge) |
||||
{ |
||||
return makePtr<FastLineDetectorImpl>( |
||||
_length_threshold, _distance_threshold, |
||||
_canny_th1, _canny_th2, _canny_aperture_size, _do_merge); |
||||
} |
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
FastLineDetectorImpl::FastLineDetectorImpl(int _length_threshold, float _distance_threshold, |
||||
double _canny_th1, double _canny_th2, int _canny_aperture_size, bool _do_merge) |
||||
:threshold_length(_length_threshold), threshold_dist(_distance_threshold), |
||||
canny_th1(_canny_th1), canny_th2(_canny_th2), canny_aperture_size(_canny_aperture_size), do_merge(_do_merge) |
||||
{ |
||||
CV_Assert(_length_threshold > 0 && _distance_threshold > 0 && |
||||
_canny_th1 > 0 && _canny_th2 > 0 && _canny_aperture_size > 0); |
||||
} |
||||
|
||||
void FastLineDetectorImpl::detect(InputArray _image, OutputArray _lines) |
||||
{ |
||||
CV_INSTRUMENT_REGION(); |
||||
|
||||
Mat image = _image.getMat(); |
||||
CV_Assert(!image.empty() && image.type() == CV_8UC1); |
||||
|
||||
std::vector<Vec4f> lines; |
||||
std::vector<SEGMENT> segments; |
||||
lineDetection(image, segments); |
||||
for(size_t i = 0; i < segments.size(); ++i) |
||||
{ |
||||
const SEGMENT seg = segments[i]; |
||||
Vec4f line(seg.x1, seg.y1, seg.x2, seg.y2); |
||||
lines.push_back(line); |
||||
} |
||||
Mat(lines).copyTo(_lines); |
||||
} |
||||
|
||||
void FastLineDetectorImpl::drawSegments(InputOutputArray _image, InputArray lines, bool draw_arrow) |
||||
{ |
||||
CV_INSTRUMENT_REGION(); |
||||
|
||||
CV_Assert(!_image.empty() && (_image.channels() == 1 || _image.channels() == 3)); |
||||
|
||||
Mat gray; |
||||
if (_image.channels() == 1) |
||||
{ |
||||
gray = _image.getMatRef(); |
||||
} |
||||
else if (_image.channels() == 3) |
||||
{ |
||||
cvtColor(_image, gray, COLOR_BGR2GRAY); |
||||
} |
||||
|
||||
// Create a 3 channel image in order to draw colored lines
|
||||
std::vector<Mat> planes; |
||||
planes.push_back(gray); |
||||
planes.push_back(gray); |
||||
planes.push_back(gray); |
||||
|
||||
merge(planes, _image); |
||||
|
||||
double gap = 10.0; |
||||
double arrow_angle = 30.0; |
||||
|
||||
Mat _lines; |
||||
_lines = lines.getMat(); |
||||
int N = _lines.checkVector(4); |
||||
// Draw segments
|
||||
for(int i = 0; i < N; ++i) |
||||
{ |
||||
const Vec4f& v = _lines.at<Vec4f>(i); |
||||
Point2f b(v[0], v[1]); |
||||
Point2f e(v[2], v[3]); |
||||
line(_image.getMatRef(), b, e, Scalar(0, 0, 255), 1); |
||||
if(draw_arrow) |
||||
{ |
||||
SEGMENT seg; |
||||
seg.x1 = b.x; |
||||
seg.y1 = b.y; |
||||
seg.x2 = e.x; |
||||
seg.y2 = e.y; |
||||
getAngle(seg); |
||||
double ang = (double)seg.angle; |
||||
Point2i p1; |
||||
p1.x = (int)round(seg.x2 - gap*cos(arrow_angle * CV_PI / 180.0 + ang)); |
||||
p1.y = (int)round(seg.y2 - gap*sin(arrow_angle * CV_PI / 180.0 + ang)); |
||||
pointInboardTest(_image.getMatRef(), p1); |
||||
line(_image.getMatRef(), Point((int)round(seg.x2), (int)round(seg.y2)), p1, Scalar(0,0,255), 1); |
||||
} |
||||
} |
||||
} |
||||
|
||||
void FastLineDetectorImpl::mergeLines(const SEGMENT& seg1, const SEGMENT& seg2, SEGMENT& seg_merged) |
||||
{ |
||||
double xg = 0.0, yg = 0.0; |
||||
double delta1x = 0.0, delta1y = 0.0, delta2x = 0.0, delta2y = 0.0; |
||||
float ax = 0, bx = 0, cx = 0, dx = 0; |
||||
float ay = 0, by = 0, cy = 0, dy = 0; |
||||
double li = 0.0, lj = 0.0; |
||||
double thi = 0.0, thj = 0.0, thr = 0.0; |
||||
double axg = 0.0, bxg = 0.0, cxg = 0.0, dxg = 0.0, delta1xg = 0.0, delta2xg = 0.0; |
||||
|
||||
ax = seg1.x1; |
||||
ay = seg1.y1; |
||||
|
||||
bx = seg1.x2; |
||||
by = seg1.y2; |
||||
cx = seg2.x1; |
||||
cy = seg2.y1; |
||||
|
||||
dx = seg2.x2; |
||||
dy = seg2.y2; |
||||
|
||||
float dlix = (bx - ax); |
||||
float dliy = (by - ay); |
||||
float dljx = (dx - cx); |
||||
float dljy = (dy - cy); |
||||
|
||||
li = sqrt((double) (dlix * dlix) + (double) (dliy * dliy)); |
||||
lj = sqrt((double) (dljx * dljx) + (double) (dljy * dljy)); |
||||
|
||||
xg = (li * (double) (ax + bx) + lj * (double) (cx + dx)) |
||||
/ (double) (2.0 * (li + lj)); |
||||
yg = (li * (double) (ay + by) + lj * (double) (cy + dy)) |
||||
/ (double) (2.0 * (li + lj)); |
||||
|
||||
if(dlix == 0.0f) thi = CV_PI / 2.0; |
||||
else thi = atan(dliy / dlix); |
||||
|
||||
if(dljx == 0.0f) thj = CV_PI / 2.0; |
||||
else thj = atan(dljy / dljx); |
||||
|
||||
if (fabs(thi - thj) <= CV_PI / 2.0) |
||||
{ |
||||
thr = (li * thi + lj * thj) / (li + lj); |
||||
} |
||||
else |
||||
{ |
||||
double tmp = thj - CV_PI * (thj / fabs(thj)); |
||||
thr = li * thi + lj * tmp; |
||||
thr /= (li + lj); |
||||
} |
||||
|
||||
axg = ((double) ay - yg) * sin(thr) + ((double) ax - xg) * cos(thr); |
||||
bxg = ((double) by - yg) * sin(thr) + ((double) bx - xg) * cos(thr); |
||||
cxg = ((double) cy - yg) * sin(thr) + ((double) cx - xg) * cos(thr); |
||||
dxg = ((double) dy - yg) * sin(thr) + ((double) dx - xg) * cos(thr); |
||||
|
||||
delta1xg = min(axg,min(bxg,min(cxg,dxg))); |
||||
delta2xg = max(axg,max(bxg,max(cxg,dxg))); |
||||
|
||||
delta1x = delta1xg * cos(thr) + xg; |
||||
delta1y = delta1xg * sin(thr) + yg; |
||||
delta2x = delta2xg * cos(thr) + xg; |
||||
delta2y = delta2xg * sin(thr) + yg; |
||||
|
||||
seg_merged.x1 = (float)delta1x; |
||||
seg_merged.y1 = (float)delta1y; |
||||
seg_merged.x2 = (float)delta2x; |
||||
seg_merged.y2 = (float)delta2y; |
||||
} |
||||
|
||||
double FastLineDetectorImpl::distPointLine(const Mat& p, Mat& l) |
||||
{ |
||||
double x = l.at<double>(0,0); |
||||
double y = l.at<double>(1,0); |
||||
double w = sqrt(x*x+y*y); |
||||
|
||||
l.at<double>(0,0) = x / w; |
||||
l.at<double>(1,0) = y / w; |
||||
l.at<double>(2,0) = l.at<double>(2,0) / w; |
||||
|
||||
return l.dot(p); |
||||
} |
||||
|
||||
bool FastLineDetectorImpl::mergeSegments(const SEGMENT& seg1, const SEGMENT& seg2, SEGMENT& seg_merged) |
||||
{ |
||||
double o[] = { 0.0, 0.0, 1.0 }; |
||||
double a[] = { 0.0, 0.0, 1.0 }; |
||||
double b[] = { 0.0, 0.0, 1.0 }; |
||||
double c[3]; |
||||
|
||||
o[0] = ( seg2.x1 + seg2.x2 ) / 2.0; |
||||
o[1] = ( seg2.y1 + seg2.y2 ) / 2.0; |
||||
|
||||
a[0] = seg1.x1; |
||||
a[1] = seg1.y1; |
||||
b[0] = seg1.x2; |
||||
b[1] = seg1.y2; |
||||
|
||||
Mat ori = Mat(3, 1, CV_64FC1, o).clone(); |
||||
Mat p1 = Mat(3, 1, CV_64FC1, a).clone(); |
||||
Mat p2 = Mat(3, 1, CV_64FC1, b).clone(); |
||||
Mat l1 = Mat(3, 1, CV_64FC1, c).clone(); |
||||
|
||||
l1 = p1.cross(p2); |
||||
|
||||
Point2f seg1mid, seg2mid; |
||||
seg1mid.x = (seg1.x1 + seg1.x2) /2.0f; |
||||
seg1mid.y = (seg1.y1 + seg1.y2) /2.0f; |
||||
seg2mid.x = (seg2.x1 + seg2.x2) /2.0f; |
||||
seg2mid.y = (seg2.y1 + seg2.y2) /2.0f; |
||||
|
||||
float seg1len = sqrt((seg1.x1 - seg1.x2)*(seg1.x1 - seg1.x2)+(seg1.y1 - seg1.y2)*(seg1.y1 - seg1.y2)); |
||||
float seg2len = sqrt((seg2.x1 - seg2.x2)*(seg2.x1 - seg2.x2)+(seg2.y1 - seg2.y2)*(seg2.y1 - seg2.y2)); |
||||
float middist = sqrt((seg1mid.x - seg2mid.x)*(seg1mid.x - seg2mid.x) + (seg1mid.y - seg2mid.y)*(seg1mid.y - seg2mid.y)); |
||||
float angdiff = fabs(seg1.angle - seg2.angle); |
||||
|
||||
float dist = (float)distPointLine(ori, l1); |
||||
|
||||
if ( fabs( dist ) <= threshold_dist * 2.0f && middist <= seg1len / 2.0f + seg2len / 2.0f + 20.0f |
||||
&& angdiff <= CV_PI / 180.0f * 5.0f) |
||||
{ |
||||
mergeLines(seg1, seg2, seg_merged); |
||||
return true; |
||||
} |
||||
else |
||||
{ |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
template<class T> |
||||
void FastLineDetectorImpl::incidentPoint(const Mat& l, T& pt) |
||||
{ |
||||
double a[] = { (double)pt.x, (double)pt.y, 1.0 }; |
||||
double b[] = { l.at<double>(0,0), l.at<double>(1,0), 0.0 }; |
||||
double c[3]; |
||||
|
||||
Mat xk = Mat(3, 1, CV_64FC1, a).clone(); |
||||
Mat lh = Mat(3, 1, CV_64FC1, b).clone(); |
||||
Mat lk = Mat(3, 1, CV_64FC1, c).clone(); |
||||
|
||||
lk = xk.cross(lh); |
||||
xk = lk.cross(l); |
||||
|
||||
xk.convertTo(xk, -1, 1.0 / xk.at<double>(2,0)); |
||||
|
||||
Point2f pt_tmp; |
||||
pt_tmp.x = (float)xk.at<double>(0,0) < 0.0f ? 0.0f : (float)xk.at<double>(0,0) |
||||
>= (imagewidth - 1.0f) ? (imagewidth - 1.0f) : (float)xk.at<double>(0,0); |
||||
pt_tmp.y = (float)xk.at<double>(1,0) < 0.0f ? 0.0f : (float)xk.at<double>(1,0) |
||||
>= (imageheight - 1.0f) ? (imageheight - 1.0f) : (float)xk.at<double>(1,0); |
||||
pt = T(pt_tmp); |
||||
} |
||||
|
||||
void FastLineDetectorImpl::extractSegments(const std::vector<Point2i>& points, std::vector<SEGMENT>& segments ) |
||||
{ |
||||
bool is_line; |
||||
|
||||
int i, j; |
||||
SEGMENT seg; |
||||
Point2i ps, pe, pt; |
||||
|
||||
std::vector<Point2i> l_points; |
||||
|
||||
int total = (int)points.size(); |
||||
|
||||
for ( i = 0; i + threshold_length < total; i++ ) |
||||
{ |
||||
ps = points[i]; |
||||
pe = points[i + threshold_length]; |
||||
|
||||
double a[] = { (double)ps.x, (double)ps.y, 1 }; |
||||
double b[] = { (double)pe.x, (double)pe.y, 1 }; |
||||
double c[3], d[3]; |
||||
|
||||
Mat p1 = Mat(3, 1, CV_64FC1, a).clone(); |
||||
Mat p2 = Mat(3, 1, CV_64FC1, b).clone(); |
||||
Mat p = Mat(3, 1, CV_64FC1, c).clone(); |
||||
Mat l = Mat(3, 1, CV_64FC1, d).clone(); |
||||
l = p1.cross(p2); |
||||
|
||||
is_line = true; |
||||
|
||||
l_points.clear(); |
||||
l_points.push_back(ps); |
||||
|
||||
for ( j = 1; j < threshold_length; j++ ) |
||||
{ |
||||
pt.x = points[i+j].x; |
||||
pt.y = points[i+j].y; |
||||
|
||||
p.at<double>(0,0) = (double)pt.x; |
||||
p.at<double>(1,0) = (double)pt.y; |
||||
p.at<double>(2,0) = 1.0; |
||||
|
||||
double dist = distPointLine(p, l); |
||||
|
||||
if ( fabs( dist ) > threshold_dist ) |
||||
{ |
||||
is_line = false; |
||||
break; |
||||
} |
||||
l_points.push_back(pt); |
||||
} |
||||
|
||||
// Line check fail, test next point
|
||||
if ( is_line == false ) |
||||
continue; |
||||
|
||||
l_points.push_back(pe); |
||||
|
||||
Vec4f line; |
||||
fitLine( Mat(l_points), line, DIST_L2, 0, 0.01, 0.01); |
||||
a[0] = line[2]; |
||||
a[1] = line[3]; |
||||
b[0] = line[2] + line[0]; |
||||
b[1] = line[3] + line[1]; |
||||
|
||||
p1 = Mat(3, 1, CV_64FC1, a).clone(); |
||||
p2 = Mat(3, 1, CV_64FC1, b).clone(); |
||||
|
||||
l = p1.cross(p2); |
||||
|
||||
incidentPoint(l, ps); |
||||
|
||||
// Extending line
|
||||
for ( j = threshold_length + 1; i + j < total; j++ ) |
||||
{ |
||||
pt.x = points[i+j].x; |
||||
pt.y = points[i+j].y; |
||||
|
||||
p.at<double>(0,0) = (double)pt.x; |
||||
p.at<double>(1,0) = (double)pt.y; |
||||
p.at<double>(2,0) = 1.0; |
||||
|
||||
double dist = distPointLine(p, l); |
||||
if ( fabs( dist ) > threshold_dist ) |
||||
{ |
||||
fitLine( Mat(l_points), line, DIST_L2, 0, 0.01, 0.01); |
||||
a[0] = line[2]; |
||||
a[1] = line[3]; |
||||
b[0] = line[2] + line[0]; |
||||
b[1] = line[3] + line[1]; |
||||
|
||||
p1 = Mat(3, 1, CV_64FC1, a).clone(); |
||||
p2 = Mat(3, 1, CV_64FC1, b).clone(); |
||||
|
||||
l = p1.cross(p2); |
||||
dist = distPointLine(p, l); |
||||
if ( fabs( dist ) > threshold_dist ) { |
||||
j--; |
||||
break; |
||||
} |
||||
} |
||||
pe = pt; |
||||
l_points.push_back(pt); |
||||
} |
||||
fitLine( Mat(l_points), line, DIST_L2, 0, 0.01, 0.01); |
||||
a[0] = line[2]; |
||||
a[1] = line[3]; |
||||
b[0] = line[2] + line[0]; |
||||
b[1] = line[3] + line[1]; |
||||
|
||||
p1 = Mat(3, 1, CV_64FC1, a).clone(); |
||||
p2 = Mat(3, 1, CV_64FC1, b).clone(); |
||||
|
||||
l = p1.cross(p2); |
||||
|
||||
Point2f e1, e2; |
||||
e1.x = (float)ps.x; |
||||
e1.y = (float)ps.y; |
||||
e2.x = (float)pe.x; |
||||
e2.y = (float)pe.y; |
||||
|
||||
incidentPoint(l, e1); |
||||
incidentPoint(l, e2); |
||||
seg.x1 = e1.x; |
||||
seg.y1 = e1.y; |
||||
seg.x2 = e2.x; |
||||
seg.y2 = e2.y; |
||||
|
||||
segments.push_back(seg); |
||||
i = i + j; |
||||
} |
||||
} |
||||
|
||||
void FastLineDetectorImpl::pointInboardTest(const Mat& src, Point2i& pt) |
||||
{ |
||||
pt.x = pt.x <= 5 ? 5 : pt.x >= src.cols - 5 ? src.cols - 5 : pt.x; |
||||
pt.y = pt.y <= 5 ? 5 : pt.y >= src.rows - 5 ? src.rows - 5 : pt.y; |
||||
} |
||||
|
||||
bool FastLineDetectorImpl::getPointChain(const Mat& img, Point pt, |
||||
Point& chained_pt, float& direction, int step) |
||||
{ |
||||
int ri, ci; |
||||
int indices[8][2] = { {1,1}, {1,0}, {1,-1}, {0,-1}, |
||||
{-1,-1},{-1,0}, {-1,1}, {0,1} }; |
||||
|
||||
float min_dir_diff = 7.0f; |
||||
Point consistent_pt; |
||||
int consistent_direction = 0; |
||||
for ( int i = 0; i < 8; i++ ) |
||||
{ |
||||
ci = pt.x + indices[i][1]; |
||||
ri = pt.y + indices[i][0]; |
||||
|
||||
if ( ri < 0 || ri == img.rows || ci < 0 || ci == img.cols ) |
||||
continue; |
||||
|
||||
if ( img.at<unsigned char>(ri, ci) == 0 ) |
||||
continue; |
||||
|
||||
if(step == 0) |
||||
{ |
||||
chained_pt.x = ci; |
||||
chained_pt.y = ri; |
||||
// direction = (float)i;
|
||||
direction = i > 4 ? (float)(i - 8) : (float)i; |
||||
return true; |
||||
} |
||||
else |
||||
{ |
||||
float curr_dir = i > 4 ? (float)(i - 8) : (float)i; |
||||
float dir_diff = abs(curr_dir - direction); |
||||
dir_diff = dir_diff > 4.0f ? 8.0f - dir_diff : dir_diff; |
||||
if(dir_diff <= min_dir_diff) |
||||
{ |
||||
min_dir_diff = dir_diff; |
||||
consistent_pt.x = ci; |
||||
consistent_pt.y = ri; |
||||
consistent_direction = i > 4 ? i - 8 : i; |
||||
} |
||||
} |
||||
} |
||||
if(min_dir_diff < 2.0f) |
||||
{ |
||||
chained_pt.x = consistent_pt.x; |
||||
chained_pt.y = consistent_pt.y; |
||||
direction = (direction * (float)step + (float)consistent_direction) |
||||
/ (float)(step + 1); |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
void FastLineDetectorImpl::lineDetection(const Mat& src, std::vector<SEGMENT>& segments_all) |
||||
{ |
||||
int r, c; |
||||
imageheight=src.rows; imagewidth=src.cols; |
||||
|
||||
std::vector<Point2i> points; |
||||
std::vector<SEGMENT> segments, segments_tmp; |
||||
Mat canny; |
||||
Canny(src, canny, canny_th1, canny_th2, canny_aperture_size); |
||||
|
||||
canny.colRange(0,6).rowRange(0,6) = 0; |
||||
canny.colRange(src.cols-5,src.cols).rowRange(src.rows-5,src.rows) = 0; |
||||
|
||||
SEGMENT seg, seg1, seg2; |
||||
|
||||
for ( r = 0; r < imageheight; r++ ) |
||||
{ |
||||
for ( c = 0; c < imagewidth; c++ ) |
||||
{ |
||||
// Find seeds - skip for non-seeds
|
||||
if ( canny.at<unsigned char>(r,c) == 0 ) |
||||
continue; |
||||
|
||||
// Found seeds
|
||||
Point2i pt = Point2i(c,r); |
||||
|
||||
points.push_back(pt); |
||||
canny.at<unsigned char>(pt.y, pt.x) = 0; |
||||
|
||||
float direction = 0.0f; |
||||
int step = 0; |
||||
while(getPointChain(canny, pt, pt, direction, step)) |
||||
{ |
||||
points.push_back(pt); |
||||
step++; |
||||
canny.at<unsigned char>(pt.y, pt.x) = 0; |
||||
} |
||||
|
||||
if ( points.size() < (unsigned int)threshold_length + 1 ) |
||||
{ |
||||
points.clear(); |
||||
continue; |
||||
} |
||||
|
||||
extractSegments(points, segments); |
||||
|
||||
if ( segments.size() == 0 ) |
||||
{ |
||||
points.clear(); |
||||
continue; |
||||
} |
||||
for ( int i = 0; i < (int)segments.size(); i++ ) |
||||
{ |
||||
seg = segments[i]; |
||||
float length = sqrt((seg.x1 - seg.x2)*(seg.x1 - seg.x2) + |
||||
(seg.y1 - seg.y2)*(seg.y1 - seg.y2)); |
||||
if(length < threshold_length) |
||||
continue; |
||||
if( (seg.x1 <= 5.0f && seg.x2 <= 5.0f) || |
||||
(seg.y1 <= 5.0f && seg.y2 <= 5.0f) || |
||||
(seg.x1 >= imagewidth - 5.0f && seg.x2 >= imagewidth - 5.0f) || |
||||
(seg.y1 >= imageheight - 5.0f && seg.y2 >= imageheight - 5.0f) ) |
||||
continue; |
||||
additionalOperationsOnSegment(src, seg); |
||||
if(!do_merge) |
||||
segments_all.push_back(seg); |
||||
segments_tmp.push_back(seg); |
||||
} |
||||
points.clear(); |
||||
segments.clear(); |
||||
} |
||||
} |
||||
if(!do_merge) |
||||
return; |
||||
|
||||
bool is_merged = false; |
||||
int ith = (int)segments_tmp.size() - 1; |
||||
int jth = ith - 1; |
||||
while(ith > 1 || jth > 0) |
||||
{ |
||||
seg1 = segments_tmp[ith]; |
||||
seg2 = segments_tmp[jth]; |
||||
SEGMENT seg_merged; |
||||
is_merged = mergeSegments(seg1, seg2, seg_merged); |
||||
if(is_merged == true) |
||||
{ |
||||
seg2 = seg_merged; |
||||
additionalOperationsOnSegment(src, seg2); |
||||
std::vector<SEGMENT>::iterator it = segments_tmp.begin() + ith; |
||||
*it = seg2; |
||||
segments_tmp.erase(segments_tmp.begin()+jth); |
||||
ith--; |
||||
jth = ith - 1; |
||||
} |
||||
else |
||||
{ |
||||
jth--; |
||||
} |
||||
if(jth < 0) { |
||||
ith--; |
||||
jth = ith - 1; |
||||
} |
||||
} |
||||
segments_all = segments_tmp; |
||||
} |
||||
|
||||
inline void FastLineDetectorImpl::getAngle(SEGMENT& seg) |
||||
{ |
||||
seg.angle = (float)(fastAtan2(seg.y2 - seg.y1, seg.x2 - seg.x1) / 180.0f * CV_PI); |
||||
} |
||||
|
||||
void FastLineDetectorImpl::additionalOperationsOnSegment(const Mat& src, SEGMENT& seg) |
||||
{ |
||||
if(seg.x1 == 0.0f && seg.x2 == 0.0f && seg.y1 == 0.0f && seg.y2 == 0.0f) |
||||
return; |
||||
|
||||
getAngle(seg); |
||||
double ang = (double)seg.angle; |
||||
|
||||
Point2f start = Point2f(seg.x1, seg.y1); |
||||
Point2f end = Point2f(seg.x2, seg.y2); |
||||
|
||||
double dx = 0.0, dy = 0.0; |
||||
dx = (double) end.x - (double) start.x; |
||||
dy = (double) end.y - (double) start.y; |
||||
|
||||
int num_points = 10; |
||||
Point2f *points = new Point2f[num_points]; |
||||
|
||||
points[0] = start; |
||||
points[num_points - 1] = end; |
||||
for (int i = 0; i < num_points; i++) |
||||
{ |
||||
if (i == 0 || i == num_points - 1) |
||||
continue; |
||||
points[i].x = points[0].x + ((float)dx / float(num_points - 1) * (float) i); |
||||
points[i].y = points[0].y + ((float)dy / float(num_points - 1) * (float) i); |
||||
} |
||||
|
||||
Point2i *points_right = new Point2i[num_points]; |
||||
Point2i *points_left = new Point2i[num_points]; |
||||
double gap = 1.0; |
||||
|
||||
for(int i = 0; i < num_points; i++) |
||||
{ |
||||
points_right[i].x = cvRound(points[i].x + gap*cos(90.0 * CV_PI / 180.0 + ang)); |
||||
points_right[i].y = cvRound(points[i].y + gap*sin(90.0 * CV_PI / 180.0 + ang)); |
||||
points_left[i].x = cvRound(points[i].x - gap*cos(90.0 * CV_PI / 180.0 + ang)); |
||||
points_left[i].y = cvRound(points[i].y - gap*sin(90.0 * CV_PI / 180.0 + ang)); |
||||
pointInboardTest(src, points_right[i]); |
||||
pointInboardTest(src, points_left[i]); |
||||
} |
||||
|
||||
int iR = 0, iL = 0; |
||||
for(int i = 0; i < num_points; i++) |
||||
{ |
||||
iR += src.at<unsigned char>(points_right[i].y, points_right[i].x); |
||||
iL += src.at<unsigned char>(points_left[i].y, points_left[i].x); |
||||
} |
||||
|
||||
if(iR > iL) |
||||
{ |
||||
std::swap(seg.x1, seg.x2); |
||||
std::swap(seg.y1, seg.y2); |
||||
getAngle(seg); |
||||
} |
||||
|
||||
delete[] points; |
||||
delete[] points_right; |
||||
delete[] points_left; |
||||
|
||||
return; |
||||
} |
||||
|
||||
void FastLineDetectorImpl::drawSegment(Mat& mat, const SEGMENT& seg, Scalar bgr, int thickness, bool directed) |
||||
{ |
||||
double gap = 10.0; |
||||
double ang = (double)seg.angle; |
||||
double arrow_angle = 30.0; |
||||
|
||||
Point2i p1; |
||||
p1.x = (int)round(seg.x2 - gap*cos(arrow_angle * CV_PI / 180.0 + ang)); |
||||
p1.y = (int)round(seg.y2 - gap*sin(arrow_angle * CV_PI / 180.0 + ang)); |
||||
pointInboardTest(mat, p1); |
||||
|
||||
line(mat, Point((int)round(seg.x1), (int)round(seg.y1)), |
||||
Point((int)round(seg.x2), (int)round(seg.y2)), bgr, thickness, 1); |
||||
if(directed) |
||||
line(mat, Point((int)round(seg.x2), (int)round(seg.y2)), p1, bgr, thickness, 1); |
||||
} |
||||
} // namespace cv
|
||||
} // namespace ximgproc
|
||||
@ -0,0 +1,173 @@ |
||||
#include "test_precomp.hpp" |
||||
|
||||
#include <vector> |
||||
|
||||
using namespace cv; |
||||
using namespace cv::ximgproc; |
||||
using namespace std; |
||||
|
||||
const Size img_size(640, 480); |
||||
const int FLD_TEST_SEED = 0x134679; |
||||
const int EPOCHS = 20; |
||||
|
||||
class FLDBase : public testing::Test |
||||
{ |
||||
public: |
||||
FLDBase() { } |
||||
|
||||
protected: |
||||
Mat test_image; |
||||
vector<Vec4f> lines; |
||||
RNG rng; |
||||
int passedtests; |
||||
|
||||
void GenerateWhiteNoise(Mat& image); |
||||
void GenerateConstColor(Mat& image); |
||||
void GenerateLines(Mat& image, const unsigned int numLines); |
||||
void GenerateBrokenLines(Mat& image, const unsigned int numLines); |
||||
void GenerateRotatedRect(Mat& image); |
||||
virtual void SetUp(); |
||||
}; |
||||
|
||||
class ximgproc_FLD: public FLDBase |
||||
{ |
||||
public: |
||||
ximgproc_FLD() { } |
||||
protected: |
||||
|
||||
}; |
||||
|
||||
void FLDBase::GenerateWhiteNoise(Mat& image) |
||||
{ |
||||
image = Mat(img_size, CV_8UC1); |
||||
rng.fill(image, RNG::UNIFORM, 0, 256); |
||||
} |
||||
|
||||
void FLDBase::GenerateConstColor(Mat& image) |
||||
{ |
||||
image = Mat(img_size, CV_8UC1, Scalar::all(rng.uniform(0, 256))); |
||||
} |
||||
|
||||
void FLDBase::GenerateLines(Mat& image, const unsigned int numLines) |
||||
{ |
||||
image = Mat(img_size, CV_8UC1, Scalar::all(rng.uniform(0, 128))); |
||||
|
||||
for(unsigned int i = 0; i < numLines; ++i) |
||||
{ |
||||
int y = rng.uniform(10, img_size.width - 10); |
||||
Point p1(y, 10); |
||||
Point p2(y, img_size.height - 10); |
||||
line(image, p1, p2, Scalar(255), 2); |
||||
} |
||||
} |
||||
|
||||
void FLDBase::GenerateBrokenLines(Mat& image, const unsigned int numLines) |
||||
{ |
||||
image = Mat(img_size, CV_8UC1, Scalar::all(rng.uniform(0, 128))); |
||||
|
||||
for(unsigned int i = 0; i < numLines; ++i) |
||||
{ |
||||
int y = rng.uniform(10, img_size.width - 10); |
||||
Point p1(y, 10); |
||||
Point p2(y, img_size.height/2); |
||||
line(image, p1, p2, Scalar(255), 2); |
||||
p1 = Point2i(y, img_size.height/2 + 3); |
||||
p2 = Point2i(y, img_size.height - 10); |
||||
line(image, p1, p2, Scalar(255), 2); |
||||
} |
||||
} |
||||
|
||||
void FLDBase::GenerateRotatedRect(Mat& image) |
||||
{ |
||||
image = Mat::zeros(img_size, CV_8UC1); |
||||
|
||||
Point center(rng.uniform(img_size.width/4, img_size.width*3/4), |
||||
rng.uniform(img_size.height/4, img_size.height*3/4)); |
||||
Size rect_size(rng.uniform(img_size.width/8, img_size.width/6), |
||||
rng.uniform(img_size.height/8, img_size.height/6)); |
||||
float angle = rng.uniform(0.f, 360.f); |
||||
|
||||
Point2f vertices[4]; |
||||
|
||||
RotatedRect rRect = RotatedRect(center, rect_size, angle); |
||||
|
||||
rRect.points(vertices); |
||||
for (int i = 0; i < 4; i++) |
||||
{ |
||||
line(image, vertices[i], vertices[(i + 1) % 4], Scalar(255), 3); |
||||
} |
||||
} |
||||
|
||||
void FLDBase::SetUp() |
||||
{ |
||||
lines.clear(); |
||||
test_image = Mat(); |
||||
rng = RNG(FLD_TEST_SEED); |
||||
passedtests = 0; |
||||
} |
||||
|
||||
|
||||
TEST_F(ximgproc_FLD, whiteNoise) |
||||
{ |
||||
for (int i = 0; i < EPOCHS; ++i) |
||||
{ |
||||
GenerateWhiteNoise(test_image); |
||||
Ptr<FastLineDetector> detector = createFastLineDetector(20); |
||||
detector->detect(test_image, lines); |
||||
|
||||
if(40u >= lines.size()) ++passedtests; |
||||
} |
||||
ASSERT_EQ(EPOCHS, passedtests); |
||||
} |
||||
|
||||
TEST_F(ximgproc_FLD, constColor) |
||||
{ |
||||
for (int i = 0; i < EPOCHS; ++i) |
||||
{ |
||||
GenerateConstColor(test_image); |
||||
Ptr<FastLineDetector> detector = createFastLineDetector(); |
||||
detector->detect(test_image, lines); |
||||
|
||||
if(0u == lines.size()) ++passedtests; |
||||
} |
||||
ASSERT_EQ(EPOCHS, passedtests); |
||||
} |
||||
|
||||
TEST_F(ximgproc_FLD, lines) |
||||
{ |
||||
for (int i = 0; i < EPOCHS; ++i) |
||||
{ |
||||
const unsigned int numOfLines = 1; |
||||
GenerateLines(test_image, numOfLines); |
||||
Ptr<FastLineDetector> detector = createFastLineDetector(); |
||||
detector->detect(test_image, lines); |
||||
if(numOfLines * 2 == lines.size()) ++passedtests; // * 2 because of Gibbs effect
|
||||
} |
||||
ASSERT_EQ(EPOCHS, passedtests); |
||||
} |
||||
|
||||
TEST_F(ximgproc_FLD, mergeLines) |
||||
{ |
||||
for (int i = 0; i < EPOCHS; ++i) |
||||
{ |
||||
const unsigned int numOfLines = 1; |
||||
GenerateBrokenLines(test_image, numOfLines); |
||||
Ptr<FastLineDetector> detector = createFastLineDetector(10, 1.414213562f, true); |
||||
detector->detect(test_image, lines); |
||||
if(numOfLines * 2 == lines.size()) ++passedtests; // * 2 because of Gibbs effect
|
||||
} |
||||
ASSERT_EQ(EPOCHS, passedtests); |
||||
} |
||||
|
||||
TEST_F(ximgproc_FLD, rotatedRect) |
||||
{ |
||||
for (int i = 0; i < EPOCHS; ++i) |
||||
{ |
||||
GenerateRotatedRect(test_image); |
||||
Ptr<FastLineDetector> detector = createFastLineDetector(); |
||||
detector->detect(test_image, lines); |
||||
|
||||
if(2u <= lines.size()) ++passedtests; |
||||
} |
||||
ASSERT_EQ(EPOCHS, passedtests); |
||||
} |
||||
|
After Width: | Height: | Size: 225 KiB |
Loading…
Reference in new issue