00-线段检测--FLD

最新推荐文章于 2024-07-03 16:21:53 发布
最新推荐文章于 2024-07-03 16:21:53 发布
阅读量1k 收藏 5
点赞数 1
分类专栏： OpenCV
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaohuigou1786/article/details/128429373
版权

opencv

在OpenCV 中线段检测的方法是ximageproc中的FastLineDetector效果较好且速度较快，我简单的实现了一下发现效果还不错，现在把结果和代码贴上，至于原理后续再更新。

结果如下：

 从上图中看对于线段的检测效果还是可以的，而且速度比较快，我跑了十次耗时如下，基本都在70ms左右。

因为OpenCV 的fastlinedetector类是在opencv_contrib中，所以我直接从源码中将这段代码拿了出来并做了些修改可以不依赖于ximageproc,

1: FLD.h

#pragma once
#include<iostream>
#include <vector>
#include "opencv2/imgproc.hpp"
//#include "opencv2/ximgproc.hpp"
//#include "opencv2/imgcodecs.hpp"
//#include "opencv2/highgui.hpp"
using namespace cv;
using namespace std;

struct SEGMENT
{
	float x1, y1, x2, y2, angle;
};
// class for fast line detector 
class FLD 
{
public:
	//contructor of class FLD
	FLD(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);

	void detect(InputArray image, OutputArray lines);

	void drawSegments(InputOutputArray image, InputArray lines, bool draw_arrow = false, Scalar linecolor = Scalar(0, 0, 255), int linethickness = 1);

//private:
public:
	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 Size srcSize, Point2i& pt);

	inline void getAngle(SEGMENT& seg);

	void additionalOperationsOnSegment(const Mat& src, SEGMENT& seg);

	void drawSegment(InputOutputArray image, const SEGMENT& seg, Scalar bgr = Scalar(0, 255, 0), int thickness = 1, bool directed = true);
};

2: FLD.cpp

#include "FLD.h"


/

FLD::FLD(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 FLD::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;
	cout << image.size() << endl;
	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 FLD::drawSegments(InputOutputArray image, InputArray lines, bool draw_arrow, Scalar linecolor, int linethickness)
{
	//CV_INSTRUMENT_REGION();

	int cn = image.channels();
	CV_Assert(!image.empty() && (cn == 1 || cn == 3 || cn == 4));

	if (cn == 1)
	{
		cvtColor(image, image, COLOR_GRAY2BGR);
	}
	else
	{
		cvtColor(image, image, COLOR_BGRA2GRAY);
		cvtColor(image, image, cn == 3 ? COLOR_GRAY2BGR : COLOR_GRAY2BGRA);
	}

	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, b, e, linecolor, linethickness);
		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 = cvRound(seg.x2 - gap * cos(arrow_angle * CV_PI / 180.0 + ang));
			p1.y = cvRound(seg.y2 - gap * sin(arrow_angle * CV_PI / 180.0 + ang));
			pointInboardTest(image.size(), p1);
			line(image, Point(cvRound(seg.x2), cvRound(seg.y2)), p1, linecolor, linethickness);
		}
	}
}

//void FLD::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 FLD::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 FLD::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 FLD::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 FLD::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); //两点叉乘出一条直线  连接局部的start和end point

		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 FLD::pointInboardTest(const Size srcSize, Point2i& pt)
{
	pt.x = pt.x <= 5 ? 5 : pt.x >= srcSize.width - 5 ? srcSize.width - 5 : pt.x;
	pt.y = pt.y <= 5 ? 5 : pt.y >= srcSize.height - 5 ? srcSize.height - 5 : pt.y;
}

bool FLD::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 FLD::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;
	if (canny_aperture_size == 0)
	{
		canny = src;//input must be edge image
	}
	else
	{
		double fq = cv::getTickFrequency();
		int64 curr_t = cv::getTickCount();
		//fld->detect(image, lines);
		Canny(src, canny, canny_th1, canny_th2, canny_aperture_size);
		double time = (double)(cv::getTickCount() - curr_t) * 1000 / fq;
		cout << "(Canny) elasped time is " << time << " ms." << endl;
		//Canny(src, canny, canny_th1, canny_th2, canny_aperture_size);
	}
	//为啥把左上和右下的5*5区域设置为0？
	canny.colRange(0, 6).rowRange(0, 6).setTo(cv::Scalar::all(0));
	canny.colRange(src.cols - 5, src.cols).rowRange(src.rows - 5, src.rows).setTo(cv::Scalar::all(0));
	//imshow("canny edge detection result all zero", canny);
	//waitKey();
	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 FLD::getAngle(SEGMENT& seg)
{
	seg.angle = (float)(fastAtan2(seg.y2 - seg.y1, seg.x2 - seg.x1) / 180.0f * CV_PI);
}

void FLD::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.size(), points_right[i]);
		pointInboardTest(src.size(), 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;
}

3: main.cpp

//#include <iostream>
#include "opencv2/imgproc.hpp"
//#include "opencv2/ximgproc.hpp"
//#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
#include "FLD.h"
using namespace std;
using namespace cv;
//using namespace cv::ximgproc;

//ours FLD
int main()
{
	string in = "E:/ImageProcessing_C++/imgs/indoor.jpg";
	Mat image_input = imread(in, IMREAD_GRAYSCALE);
	if (image_input.empty())
	{
		cout << "error image path,please check!!!" << endl;
		return -1;
	}
	cout << image_input.size() << endl;
	Size s = image_input.size();
	Mat image(0.3*s.height, 0.3*s.width, CV_8UC1);
	cv::resize(image_input, image, image.size());
	imshow("input_img(resized)", image);
	waitKey(1);

	//初始化FLD类　　用于后续线段检测
	int length_threshold = 35;
	float distance_threshold = 1.41421356f*3.0f;
	double canny_th1 = 50.0;
	double canny_th2 = 50.0;
	int canny_aperture_size = 3;
	bool do_merge = false;
	FLD* fld = new FLD(length_threshold,distance_threshold,canny_th1,canny_th2,canny_aperture_size,do_merge);
	vector<Vec4f> lines;

	for (int ii = 0; ii < 10; ii++)
	{
		lines.clear();
		double fq = cv::getTickFrequency();
		int64 curr_t = cv::getTickCount();
		fld->detect(image, lines);
		double time = (double)(cv::getTickCount() - curr_t) * 1000 / fq;
		cout << "(FLD) elasped time is " << time << " ms." << endl;
		cout << lines.size() << endl;
	}


	Mat line_image_fld = image.clone();
	fld->drawSegments(line_image_fld, lines);
	imshow("FLD result", line_image_fld);
	waitKey();
    delete fld;
	return 0;
}

送外卖的小熊
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
opencv_检测直线、线段、圆、矩形
07-13
opencv_检测直线、线段、圆、矩形 opencv_检测直线、线段、圆、矩形
线段检测与圆检测
01-22
在《【OpenCV入门指南】第五篇轮廓检测上》与《【OpenCV入门指南】第六篇轮廓检测下》讲解了OpenCV的轮廓检测。本篇将讲解在OpenCV中使用线段检测与圆检测。 线段检测与圆检测主要运用Hough变换，Hough变换是一种利用图像的全局特征将特定形状的边缘连接起来，形成连续平滑边缘的一种方法。它通过将源图像上的点影射到用于累加的参数空间，实现对已知解析式曲线进行识别。 在OpenCV编程中，线段检测和圆检测已经封装成函数了，直接使用cvHoughLines2和cvHoughCircles即可，下面来看看函数介绍和实际代码。
目标检测之线段检测---lsd line segment detector
weixin_34413103的博客
01-26 1334
（1）线段检测应用背景 （2）线段检测原理简介 （3）线段检测实例 a line segment detector （4）hough 变换和 lsd 的区别 ---------------------author：pkf ------------------------------time：2015-1-26 --------------------------------------...
【计算机视觉】基于OpenCV的直线检测
最新发布
m0_64280569的博客
07-03 398
检测具有特定形状的物体,该过程在一个参数空间中通过计算累计结果的局部最大值得到一个符合该特定形状的集合作为霍夫变换结果，该方法可以进行圆，直线，椭圆等形状的检测。在车道线检测中，当初考虑的一个方案便是采用霍夫变换检测直线进行车道线提取。在使用霍夫变换侦测直线前，须先利用边缘检测算法来减少图像的数据量、剔掉不相关的信息，保留图像中重要的结构特征。x,y坐标系中直线上的所有点在ρ,θ坐标系中对应的所有曲线交汇到一个点上。x,y坐标系中直线上的一个点对应到ρ,θ坐标系中是一条曲线。
线段检测
weixin_39326879的博客
07-15 1080
中心思路 将梯度相同的像素点进行聚类，然后拟合成直线。 具体流程 线段(直线)的几何特征是线上的点梯度方向相近，搜索聚类相同梯度的方向的区域，即是潜在线段的区域，使用该区域点集即可拟合成直线； ...
OpenCV学习代码记录——Hough线段检测
weixin_34186128的博客
04-05 120
很久之前学习过一段时间的OpenCV，当时没有做什么笔记，但是代码都还在，这里把它贴出来做个记录。 代码放在码云上，地址在这里https://gitee.com/solym/OpenCVTest/tree/master/OpenCVTest 效果 代码 #include &lt;opencv2/core.hpp&gt; #include &lt;opencv2/highgui.hpp&gt; #...
统计的力量-线段树全接触-张昆玮
05-10
线段树是一种高效的数据结构，特别适用于处理动态的区间查询和更新问题。它在计算机科学，尤其是算法竞赛和计算几何领域中有着广泛的应用。线段树通过将一维空间（通常是一组数值或数组）划分为多个重叠的区间来工作...
通达信指标公式源码缠论 笔-线段-中枢主图指标.doc
07-30
通达信指标公式源码缠论 笔-线段-中枢主图指标 通达信指标公式源码缠论 笔-线段-中枢主图指标是基于通达信平台开发的一款技术指标，旨在帮助投资者和交易者更好地分析和预测金融市场的走势。该指标公式由多个部分...
Unified-Line-Segment-Detection:统一线段检测
05-18
统一线段检测 该存储库包含该论文的官方PyTorch实现：ULSD：。 介绍 是一种统一的线段检测方法，用于检测来自针Kong，鱼眼或球形摄像机的畸变图像和未畸变图像。 通过基于贝塞尔曲线的新颖线段表示，我们的方法可以...
中考专题复习-----线段和差的最大值及最小值.doc
09-27
中考专题复习-----线段和差的最大值及最小值.doc
AutoJs源码-线段上的所有点
11-16
AutoJs源码-线段上的所有点。本资源购买前提醒：本源码都是实际autojs项目模板，安装好autojs直接运行即可打开。1、支持低版本autojs。2、资源仅供学习与参考，请勿用于商业用途，否则产生的一切后果将由您自己承担...
LSD线段检测_Matlab 版本（高速版）
09-25
本代码为Matlab语言编写，内部嵌入OpenCV函数（无需安装OpenCV），相比Matlab版本的LSD速度更快，附详细注释
opencv进行直线（车道线）检测
03-18
在vc++6.0中利用opencv进行sobel边缘检测，再对边缘图像进行直线检测。
Hough线段检测opencv和vc代码实现
12-06
Hough线段检测opencv和vc代码实现，已经测试过，很好用！
FLDFaceDetectionMATLAB:基于Fisher线性判别（FLD）的人脸识别算法的实现
05-02
FLDFaceDetectionMATLAB 基于Fisher线性判别（FLD）的人脸识别算法的实现 我们的人脸识别方法利用了两个观察结果： 从固定视点获取的朗伯曲面的所有图像都位于高维图像空间的3D线性子空间中。 由于面部表情不同，上述观察并不能完全成立。 在实践中，脸部的某些区域可能因图像而异，通常会明显偏离衬里子空间，并且识别的可靠性较差。 我们通过找到从高维图像空间到低维特征空间的线性投影来利用这些观察结果，该空间对面部表情的变化不敏感。 我们选择与类内散布几乎正交的投影方向，在保持可辨别性的同时，投影出面部表情的变化。 我们的方法Fisherfaces是Fisher线性判别式（FLD）的派生物，它使类间散布与类内散布的比率​​最大化。
直线检测算法
04-25
直线检测现在已经成为计算机视觉中的一个研究重点，近年来许多学者就这一领域展开了广泛研究并提出了许多直线检测算法。目前直线检测算法主要可以分为以下几类： 1）Hough变换法 2）相位编组法 3）链码检测法
OpenCV学习笔记（25）线段检测和圆检测练习
海底小星星的博客
06-16 710
//线段检测只能针对二值图像 #include #include #include"opencv2/imgproc/imgproc.hpp" #include #include using namespace cv; Mat GrayImage; Mat BinaryImage; Mat SrcImage; Mat CannyImage; Mat ColorImage;
底层视觉-线段检测-霍夫变换-python
liulibo1的博客
06-29 583
霍夫变换可以将空间坐标系下的一条直线转换到霍夫空间的一个点。一般情况下，霍夫空间，我们可以选择极坐标系。在极坐标系下，一个点可以表达空间坐标系下的一条直线，那么在极坐标系下越多点重合，说明在空间坐标系下这个对应的直线越有可能是一天直线。对于直线，空间坐标系和极坐标系的相互转换可以表达为： （1） 所以使用霍夫变换检测线段的步骤如下： 1、对图像进行边缘检测，并使之成为二值边缘图...
三种主流线条检测器：LSD、EDLines 和 Hough 线条检测器
gitblog_00086的博客
06-01 438
三种主流线条检测器：LSD、EDLines 和 Hough 线条检测器 line_detectorline segment detector(lsd) &. edge drawing line detector(edl) &. hough line detector(standard &. probabilistic) for detection项目地址:https://gitcode.com/...
统计的力量-线段树全接触-清华张昆玮2022研究探索
在他所著的《统计的力量-线段树全接触》一书中，他探讨了线段树在计算机算法中的重要性和广泛应用。他指出，根据D.E. Knuth的分类方法，计算机算法可以分为数值算法与非数值算法，其中非数值算法包括索引、分类、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值