实现 FLD（快速线条检测器）算法的类，该算法在 [155] 中有所描述。更多...

#include <opencv2/ximgproc/fast_line_detector.hpp>

cv::ximgproc::FastLineDetector 的协作图

公用成员函数
virtual	~FastLineDetector ()

virtual void	detect (InputArray image, OutputArray lines)=0
	找出输入图像中的线条。这是算法在上述所示图像上使用默认参数的输出。

virtual void	drawSegments (InputOutputArray image, InputArray lines, bool draw_arrow=false, Scalar linecolor=Scalar(0, 0, 255), int linethickness=1)=0
	在给定图像上绘制线段。

从 cv::Algorithm 继承的公用成员函数
	算法 ()

virtual	~Algorithm ()

virtual void	清除 ()
	清除算法状态。

virtual bool	empty () const
	如果算法为空（例如在开头或读取不成功之后），则返回 true。

virtual String	getDefaultName () const

virtual void	read (const FileNode &fn)
	从文件存储中读取算法参数。

virtual void	save (const String &filename) const

void	写入 (const Ptr< 文件存储器 > &fs, const 字符串 &名称=字符串()) const

virtual void	写入 (文件存储器 &fs) const
	在文件存储器中存储算法参数。

void	写入 (文件存储器 &fs, const 字符串 &名称) const

从 cv::Algorithm 继承的附加成员
静态公共成员函数从 cv::Algorithm 继承
template<typename _Tp >
static Ptr< _Tp >	加载 (const 字符串 &文件名, const 字符串 &对象名称=字符串())
	从文件中加载算法。

template<typename _Tp >
static Ptr< _Tp >	从字符串加载 (const 字符串 &strModel, const 字符串 &对象名称=字符串())
	从字符串加载算法。

template<typename _Tp >
static Ptr< _Tp >	读取 (const 文件节点 &fn)
	从文件节点中读取算法。

受保护的成员函数从 cv::Algorithm 继承
void	写入格式 (文件存储器 &fs) const

详细信息

实现了 FLD（快速线检测器）算法的类，[155] 中有介绍。

#include <iostream>
 
#include "opencv2/imgproc.hpp"
#include "opencv2/ximgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
 
using namespace std;
using namespace cv;
 
int main(int argc, char** argv)
{
    string in;
    CommandLineParser parser(argc, argv, "{@input|corridor.jpg|input image}{help h||show help message}");
    if (parser.has("help"))
    {
parser.printMessage();
        return 0;
    }
in = samples::findFile(parser.get<string>("@input"));
 
    Mat image = imread(in, IMREAD_GRAYSCALE);
 
    if( image.empty() )
    {
        return -1;
    }
 
    // 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().
    // If zero, Canny() is not applied and the input
    // image is taken as an edge image.
    // do_merge false - If true, incremental merging of segments
    // will be performed
    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;
 
    // Because of some CPU's power strategy, it seems that the first running of
    // an algorithm takes much longer. So here we run the algorithm 10 times
    // to see the algorithm's processing time with sufficiently warmed-up
    // CPU performance.
    for (int run_count = 0; run_count < 5; run_count++) {
        double freq = getTickFrequency();
lines.clear();
        int64 start = getTickCount();
        // 检测具有场定位线的线
fld->detect(image, lines);
        double duration_ms = double(getTickCount() - start) * 1000 / freq;
cout << "FLD 所用时间 " << duration_ms << " 毫秒。"span> << endl;
    }
 
    // 显示发现具有 FLD 的线
    Mat line_image_fld(image);
fld->drawSegments(line_image_fld, lines);
    imshow("FLD 结果", line_image_fld);
 
    waitKey(1);
 
    Ptr<EdgeDrawing> ed = createEdgeDrawing();
ed->params.EdgeDetectionOperator = EdgeDrawing::SOBEL;
ed->params.GradientThresholdValue = 38;
ed->params.AnchorThresholdValue = 8;
 
vector<Vec6d> ellipses;
 
    for (int run_count = 0; run_count < 5; run_count++) {
        double freq = getTickFrequency();
lines.clear();
        int64 start = getTickCount();
 
        // 检测边缘
        // 在 detectLines() 和 detectEllipses() 之前调用此函数
ed->detectEdges(image);
 
        // 检测线
ed->detectLines(lines);
        double duration_ms = double(getTickCount() - start) * 1000 / freq;
cout << "EdgeDrawing detectLines 所用时间 " << duration_ms << " 毫秒。"span> << endl;
 
start = getTickCount();
        // 检测圆和椭圆
ed->detectEllipses(ellipses);
duration_ms = double(getTickCount() - start) * 1000 / freq;
cout << "EdgeDrawing detectEllipses 所用时间 " << duration_ms << " 毫秒。"span> << endl;
    }
 
    Mat edge_image_ed = Mat::zeros(image.size(), CV_8UC3);
vector<vector<Point> > segments = ed->getSegments();
 
    for (size_t i = 0; i < segments.size(); i++)
    {
        const Point* pts = &segments[i][0];
        int n = (int)segments[i].size();
        polylines(edge_image_ed, &pts, &n, 1, false, Scalar((rand() & 255), (rand() & 255), (rand() & 255)), 1);
    }
 
    imshow("EdgeDrawing detected edges", edge_image_ed);
 
    Mat line_image_ed(image);
fld->drawSegments(line_image_ed, lines);
 
    // 绘制圆形和椭圆形
    for (size_t i = 0; i < ellipses.size(); i++)
    {
        Point center((int)ellipses[i][0], (int)ellipses[i][1]);
        Size axes((int)ellipses[i][2] + (int)ellipses[i][3], (int)ellipses[i][2] + (int)ellipses[i][4]);
        double angle(ellipses[i][5]);
        Scalar color = ellipses[i][2] == 0 ? Scalar(255, 255, 0) : Scalar(0, 255, 0);
 
        ellipse(line_image_ed, center, axes, angle, 0, 360, color, 2, LINE_AA);
    }
 
    imshow("EdgeDrawing result", line_image_ed);
    waitKey();
    return 0;
}

构造函数和析构函数文档

◆ ~FastLineDetector()

virtual cv::ximgproc::FastLineDetector::~FastLineDetector ( )

inlinevirtual

成员函数文档

◆ detect()

virtual void cv::ximgproc::FastLineDetector::detect	(	InputArray	image,
		OutputArray	lines
	)

纯虚函数

Python
	cv.ximgproc.FastLineDetector.detect(	image[, lines]	) ->	lines

找出输入图像中的线条。这是算法在上述所示图像上使用默认参数的输出。

image

参数

image	灰度（CV_8UC1）输入图像。如果仅需要选择一个 roi，则使用：`fld_ptr-\>detect(image(roi), lines, ...); lines += Scalar(roi.x, roi.y, roi.x, roi.y);`
lines	指定了线的起点和终点的 Vec4f 元素向量。其中 Vec4f 为 (x1, y1, x2, y2)，point 1 为开始，point 2 为结束。返回的线是有向的，这样较亮的边在它们左侧。

◆ drawSegments()

virtual void cv::ximgproc::FastLineDetector::drawSegments	(	InputOutputArray	image,
		InputArray	lines,
		bool	draw_arrow = `false`,
		Scalar	linecolor = `Scalar(0, 0, 255)`,
		int	linethickness = `1`
	)

纯虚函数

Python
	cv.ximgproc.FastLineDetector.drawSegments(	image, lines[, draw_arrow[, linecolor[, linethickness]]]	) ->	image

在给定图像上绘制线段。