cvHoughLines2霍夫直线检测函数详解及源码解析

转载请注明出处。  
文章链接:https://blog.csdn.net/duiwangxiaomi/article/details/126406184

博文目录

  • 一. 前言
  • 二. cvHoughLines2函数定义
    • (一) 函数说明
    • (二) 函数使用
  • 三. 源码解析
    • (一) HoughLines、HoughLinesP源码
    • (二) cvHoughLines2源码解析
  • 四. 总结

一. 前言

  霍夫变换是一种在图像中寻找直线、圆及其他简单形状的方法,利用Hough变换在二值图像中找到直线。本文主要介绍opencv自带的几种直线检测函数,以及主要检测函数cvHoughLines2()的源码解析。

二. cvHoughLines2函数定义

  目前opencv直线检测方法有如下三种:

1. CV_HOUGH_STANDARD(SHT)
	传统或标准Hough变换.每一个线段由两个浮点数(ρ,θ)表示,此中ρ是原点(0,0)到直线的距
	离,θ表示线段与x-轴之间的夹角。是以,矩阵类型必须是 CV_32FC2 type.
2. CV_HOUGH_PROBABILISTIC(PPHT)
	概率Hough变换(如果图像包含一些长的线性分割,则效率更高). 它返回线段分割而不是整条
	直线。每个分割用起点和终点来表示,所以矩阵(或创建的序列)类型是 CV_32SC4.
3. CV_HOUGH_MULTI_SCALE(MSHT)
	传统 Hough 变换的多标准变种。线段的编码体式格式与 CV_HOUGH_STANDARD 的一致。

  opencv自带的几种直线检测函数,如下:

序号 使用方式 函数名称
1 C接口 cvHoughLines2()
2 C++接口-SHT,MSHT HoughLines()
3 C++接口-PPHT HoughLinesP()

(一) 函数说明

!!!注意:参数中的theta为检测直线对应的垂线角度,从后面的源码解析可以看出。
// 1.C接口
CV_IMPL CvSeq*
cvHoughLines2( CvArr* src_image, void* lineStorage, int method,
               double rho, double theta, int threshold,
               double param1, double param2 )
函数说明:C接口中的hough检测实现了上述三种检测方法,调用时可通过method设置检测方法。
返 回 值:返回找到的线段序列.
参数说明:
		src_image	输入 8-比特、单通道 (二值) 图像
		lineStorage	指向保存结果位置的指针,既可以是内存块cvMemoryStorage,
					也可以是N*1的矩阵数列(行数N将有助于限制直线的最大数量)
		method		采用的检测方法,可以是
					CV_HOUGH_STANDARD(SHT)
					CV_HOUGH_PROBABILISTIC(PPHT)
					CV_HOUGH_MULTI_SCALE(MSHT)
		rho			以像素为单位的距离精度。另一种形容方式是直线搜索时的进步尺寸的
					单位半径。一般设置为1
		theta		以弧度为单位的角度精度.另一种形容方式是直线搜索时的进步尺寸的
					单位角度.一般设置为CV_PI/180.
		threshold	累加平面的阈值参数,即识别某部分为图中的一条直线时它在累加平面
					中必须达到的值.阈值>threshold的线段才可以被检测通过并返回到
					结果中.
		param1		1)对传统 Hough 变换,不使用(0).
					2)对概率 Hough 变换,它是最小线段长度.x方向或y向有一者距离满足
					要求即可.
					3)对多尺度 Hough 变换,它是距离精度rho的分母(大致的距离精度是
					rho而精确的应该是rho/param1 ).
		param2		1)对传统 Hough 变换,不使用 (0).
					2)对概率 Hough 变换,这个参数表示在同一条直线上进行碎线段连接的
					最大间隔值(gap), 即当同一条直线上的两条碎线段之间的间隔小于
					param2时,将其合二为一。
					3)对多尺度 Hough 变换,它是角度精度 theta 的分母 (大致的角度精
					度是 theta 而精确的角度应该是 theta/param2). 			
// 2.C++接口
// 标准和多尺度霍夫变换函数
void HoughLines(InputArray image, OutputArray lines, 
				double rho, double theta, int threshold, 
				double srn=0, double stn=0 )
函数说明:此函数实现了标准霍夫变换SHT和多尺度霍夫变换MSHT进行直线检测。
		调用时可通过method设置检测方法。
参数说明:
		image		InputArray类型的image,输入图像,即源图像,需为8位的单通道二进
					制,可将任意的源图载入进来由函数修改成此格式后,填在此处。
		lines		OutputArray类型的lines,储存检测到线条的输出矢量.每一条线由
					(ρ,θ),其中,ρ是离坐标原点((0,0)(也就是图像的左上角)的距离.
					θ是弧度线条旋转角度(0~垂直线,π/2~水平线).
		rho			同cvHoughLines2中参数说明
		theta		同cvHoughLines2中参数说明
		threshold	同cvHoughLines2中参数说明
		srn			默认值0
					对于多尺度霍夫变换,是第三个参数进步尺寸rho的除数距离。
					粗略的累加器进步尺寸直接是第三个参数rho,而精确的累加器进步尺寸为
					rho/srn。

		stn			默认值0
					对于多尺度霍夫变换,srn表示第四个参数进步尺寸的单位角度theta的
					除数距离。且如果srn和stn同时为0,就表示使用经典的霍夫变换。否则,
					这两个参数应该都为正数。

// 概率霍夫变换
void HoughLinesP(InputArray image, OutputArray lines, 
				double rho, double theta, int threshold, 
				double minLineLength=0, double maxLineGap=0 )
函数说明:C++接口将概率霍夫变换单独出来的函数。
参数说明:
		image			同HoughLines中参数说明
		lines			同HoughLines中参数说明
		rho				同cvHoughLines2中参数说明
		theta			同cvHoughLines2中参数说明
		threshold		同cvHoughLines2中参数说明
		minLineLength	同cvHoughLines2中参数param1-2)说明
		maxLineGap		同cvHoughLines2中参数param2-2)说明

(二) 函数使用

  1. cvHoughLines2示例
#include 
#include 
#include 
 
int main(int argc, char** argv)
{
	IplImage* src;
	src = cvLoadImage(./001.jpg”, 0 ); //加载灰度图
	IplImage* dst = cvCreateImage( cvGetSize( src ), IPL_DEPTH_8U, 1 );
	IplImage* color_dst = cvCreateImage( cvGetSize( src ), IPL_DEPTH_8U, 3 );  //创建三通道图像,用于直线显示
	CvMemStorage* storage = cvCreateMemStorage(0);
	CvSeq* lines = 0;
	
	cvCanny( src, dst, 50, 100, 3 );  //首先运行边缘检测,得到只有边缘的二值图像
	lines = cvHoughLines2( dst, storage, CV_HOUGH_PROBABILISTIC, 1, CV_PI/180, 80, 30, 10 ); 
	
 	//提取直线并显示
 	cvCvtColor( dst, color_dst, CV_GRAY2BGR ); 
	for( int i = 0; i < lines ->total; i++ )  //lines存储的是直线
	{
		CvPoint* line = ( CvPoint* )cvGetSeqElem( lines, i );  //lines序列里面存储的是像素点坐标
		cvLine( color_dst, line[0], line[1], CV_RGB( 0, 255, 0 ) );  //将找到的直线标记为绿色
	}
	cvNamedWindow( "src", 1 );
	cvShowImage( "src", src );
	cvNamedWindow( "Hough", 1 );
	cvShowImage( "Hough", color_dst );
	cvWaitKey(0);
 
	return 0;
}
  1. 对于HoughLines、HoughLinesP使用,可直接参照毛星云博客,大佬写的非常详细,这里贴上链接。
    毛星云hough直线检测

三. 源码解析

(一) HoughLines、HoughLinesP源码

  先贴出HoughLines、HoughLinesP函数源码,可以看出,二者最终都调用了cvHoughLines2函数,因此,我们直接对cvHoughLines2源码进行解析。

void cv::HoughLines( InputArray _image, OutputArray _lines,
                     double rho, double theta, int threshold,
                     double srn, double stn )
{
    Ptr<CvMemStorage> storage = cvCreateMemStorage(STORAGE_SIZE);
    Mat image = _image.getMat();
    CvMat c_image = image;
    CvSeq* seq = cvHoughLines2( &c_image, storage, srn == 0 && stn == 0 ?
                    CV_HOUGH_STANDARD : CV_HOUGH_MULTI_SCALE,
                    rho, theta, threshold, srn, stn );
    seqToMat(seq, _lines);
}

void cv::HoughLinesP( InputArray _image, OutputArray _lines,
                      double rho, double theta, int threshold,
                      double minLineLength, double maxGap )
{
    Ptr<CvMemStorage> storage = cvCreateMemStorage(STORAGE_SIZE);
    Mat image = _image.getMat();
    CvMat c_image = image;
    CvSeq* seq = cvHoughLines2( &c_image, storage, CV_HOUGH_PROBABILISTIC,
                    rho, theta, threshold, minLineLength, maxGap );
    seqToMat(seq, _lines);
}

(二) cvHoughLines2源码解析

  这里主要对概率霍夫变换和标准变换进行分析,直接上源码,注释在代码中~

  1. cvHoughLines2,method处是代码核心,分别调用了三种检测方法的函数,2、3直接进行标准变换和概率霍夫变换函数的源码解析。
// cvHoughLines2
CV_IMPL CvSeq*
cvHoughLines2( CvArr* src_image, void* lineStorage, int method,
               double rho, double theta, int threshold,
               double param1, double param2 )
{
    CvSeq* result = 0;

    CvMat stub, *img = (CvMat*)src_image;
    CvMat* mat = 0;
    CvSeq* lines = 0;
    CvSeq lines_header;
    CvSeqBlock lines_block;
    int lineType, elemSize;
    int linesMax = INT_MAX;
    int iparam1, iparam2;

    img = cvGetMat( img, &stub );

    if( !CV_IS_MASK_ARR(img))
        CV_Error( CV_StsBadArg, "The source image must be 8-bit, single-channel" );

    if( !lineStorage )
        CV_Error( CV_StsNullPtr, "NULL destination" );

    if( rho <= 0 || theta <= 0 || threshold <= 0 )
        CV_Error( CV_StsOutOfRange, "rho, theta and threshold must be positive" );

    if( method != CV_HOUGH_PROBABILISTIC )
    {
        lineType = CV_32FC2;
        elemSize = sizeof(float)*2;
    }
    else
    {
        lineType = CV_32SC4;
        elemSize = sizeof(int)*4;
    }

    if( CV_IS_STORAGE( lineStorage ))
    {
        lines = cvCreateSeq( lineType, sizeof(CvSeq), elemSize, (CvMemStorage*)lineStorage );
    }
    else if( CV_IS_MAT( lineStorage ))
    {
        mat = (CvMat*)lineStorage;

        if( !CV_IS_MAT_CONT( mat->type ) || (mat->rows != 1 && mat->cols != 1) )
            CV_Error( CV_StsBadArg,
            "The destination matrix should be continuous and have a single row or a single column" );

        if( CV_MAT_TYPE( mat->type ) != lineType )
            CV_Error( CV_StsBadArg,
            "The destination matrix data type is inappropriate, see the manual" );

        lines = cvMakeSeqHeaderForArray( lineType, sizeof(CvSeq), elemSize, mat->data.ptr,
                                         mat->rows + mat->cols - 1, &lines_header, &lines_block );
        linesMax = lines->total;
        cvClearSeq( lines );
    }
    else
        CV_Error( CV_StsBadArg, "Destination is not CvMemStorage* nor CvMat*" );

    iparam1 = cvRound(param1);
    iparam2 = cvRound(param2);

    switch( method )
    {
    case CV_HOUGH_STANDARD:
          icvHoughLinesStandard( img, (float)rho,
                (float)theta, threshold, lines, linesMax );
          break;
    case CV_HOUGH_MULTI_SCALE:
          icvHoughLinesSDiv( img, (float)rho, (float)theta,
                threshold, iparam1, iparam2, lines, linesMax );
          break;
    case CV_HOUGH_PROBABILISTIC:
          icvHoughLinesProbabilistic( img, (float)rho, (float)theta,
                threshold, iparam1, iparam2, lines, linesMax );
          break;
    default:
        CV_Error( CV_StsBadArg, "Unrecognized method id" );
    }

    if( mat )
    {
        if( mat->cols > mat->rows )
            mat->cols = lines->total;
        else
            mat->rows = lines->total;
    }
    else
        result = lines;

    return result;
}
  1. 标准霍夫变换
static void
icvHoughLinesStandard( const CvMat* img, float rho, float theta,
                       int threshold, CvSeq *lines, int linesMax )
{
	const uchar* image;
	int step, width, height;
	int numangle, numrho;
	int total = 0;
	int i, j;
	float irho = 1 / rho;
	double scale;

	CV_Assert( CV_IS_MAT(img) && CV_MAT_TYPE(img->type) == CV_8UC1 );

	image = img->data.ptr;
	step = img->step;
	width = img->cols;
	height = img->rows;

	numangle = cvRound(CV_PI / theta); //极坐标空间theta轴细分程度
	numrho = cvRound(((width + height) * 2 + 1) / rho); //极坐标空间rho轴细分程度
               //实质最小可以取图像两个对角之间的最大距离,eg: M*N的图片最大距离为sqrt(M^2+N^2)
               //如上计算,显然>sqrt(M^2+N^2), 使得计算分辨率更高
			   
	_accum.allocate((numangle+2) * (numrho+2));  //多分配一行一列,主要是方便stage    
	//2中4邻域的比较,否则比较时会溢出
	_sort_buf.allocate(numangle * numrho);
	_tabSin.allocate(numangle);
	_tabCos.allocate(numangle);
	int *accum = _accum, *sort_buf = _sort_buf;
	float *tabSin = _tabSin, *tabCos = _tabCos;
	
	memset( accum, 0, sizeof(accum[0]) * (numangle+2) * (numrho+2) );
	
	float ang = 0;
	for(int n = 0; n < numangle; ang += theta, n++ )
	{
		tabSin[n] = (float)(sin((double)ang) * irho);    //做好tabSin数组,后面备查
		tabCos[n] = (float)(cos((double)ang) * irho);    //做好tabCos数组,后面备查
	}
	
	// stage 1. fill accumulator
	for( i = 0; i < height; i++ )
		for( j = 0; j < width; j++ )
		{
			if( image[i * step + j] != 0 )                //二值图像非零点
				for(int n = 0; n < numangle; n++ )
				{
					int r = cvRound( j * tabCos[n] + i * tabSin[n] );   //ρ = x cos θ + y sin θ
					r += (numrho - 1) / 2;               //距离偏移一半,r有负值,使r取值在[0,numrho - 1]区间
					accum[(n+1) * (numrho+2) + r+1]++;   //累加器相应单元+1,
														//n+1是为了第一行空出来
														//numrho+2 是总共的列数
														//r+1把第一列空出来,stage 2需要比较4邻域累加器中值的大小
				}
		}
	
	// stage 2. find local maximums
	for(int r = 0; r < numrho; r++ )
		for(int n = 0; n < numangle; n++ )
		{
			int base = (n+1) * (numrho+2) + r+1;         //累加器空间的索引,与stage 1中相同
			if( accum[base] > threshold &&
				accum[base] > accum[base - 1] && accum[base] >= accum[base + 1] &&
				accum[base] > accum[base - numrho - 2] && accum[base] >= accum[base + numrho + 2] )
				sort_buf[total++] = base;
		}
	
	// stage 3. sort the detected lines by accumulator value
	icvHoughSortDescent32s( sort_buf, total, accum );    //opencv自带排序函数,
							//降序排列,降序排列后的数据在accum中的序号赋给sort_buf
	
	// stage 4. store the first min(total,linesMax) lines to the output buffer
	linesMax = MIN(linesMax, total);
	scale = 1./(numrho+2);
	for( i = 0; i < linesMax; i++ )
	{
		CvLinePolar line;
		int idx = sort_buf[i];   //累加器空间accum的序号
		int n = cvFloor(idx*scale) - 1;   //cvFloor()将浮点数转换为不大于该参数的整数
										//除以(numrho + 2)并减1→获得行数
		int r = idx - (n+1)*(numrho+2) - 1;  //获得列数
		line.rho = (r - (numrho - 1)*0.5f) * rho;   //0.5=1/2,距离大小,与之前偏移相对应
		line.angle = n * theta;        //角度大小
		cvSeqPush( lines, &line );     //直线以(ρ,r)装到lines中
	}

}
  1. 概率霍夫变换
// icvHoughLinesProbabilistic
static void
icvHoughLinesProbabalistic( CvMat* image,
                            float rho, float theta, int threshold,
                            int lineLength, int lineGap,
                            CvSeq *lines, int linesMax )
{
		CvMat* accum = 0;//累加器
		CvMat* mask = 0;//保存0,1图像
		CvMat* trigtab = 0;//保存cos、sin与距离精度(irho)的乘积
    CvMemStorage* storage = 0;
 
    CV_FUNCNAME( "icvHoughLinesProbalistic" );
 
    __BEGIN__;
    
    CvSeq* seq;
    CvSeqWriter writer;
    int width, height;
    int numangle, numrho;
    float ang;
    int r, n, count;
    CvPoint pt;
    float irho = 1 / rho;
    CvRNG rng = cvRNG(-1);//产生随机数
    const float* ttab;
    uchar* mdata0;
 
    CV_ASSERT( CV_IS_MAT(image) && CV_MAT_TYPE(image->type) == CV_8UC1 );
 
    width = image->cols;
    height = image->rows;
 
    numangle = cvRound(CV_PI / theta);
    numrho = cvRound(((width + height) * 2 + 1) / rho);
 
    CV_CALL( accum = cvCreateMat( numangle, numrho, CV_32SC1 ));
    CV_CALL( mask = cvCreateMat( height, width, CV_8UC1 ));
    CV_CALL( trigtab = cvCreateMat( 1, numangle, CV_32FC2 ));
    cvZero( accum );
    
    CV_CALL( storage = cvCreateMemStorage(0) );
    
    for( ang = 0, n = 0; n < numangle; ang += theta, n++ )
    {
        trigtab->data.fl[n*2] = (float)(cos(ang) * irho);
        trigtab->data.fl[n*2+1] = (float)(sin(ang) * irho);
    }
    ttab = trigtab->data.fl;
    mdata0 = mask->data.ptr;
 
    CV_CALL( cvStartWriteSeq( CV_32SC2, sizeof(CvSeq), sizeof(CvPoint), storage, &writer )); 
 
    //第一步生成0,1图像,即:选择非零的点
    // stage 1. collect non-zero image points
    for( pt.y = 0, count = 0; pt.y < height; pt.y++ )
    {
        const uchar* data = image->data.ptr + pt.y*image->step;
        uchar* mdata = mdata0 + pt.y*width;
        for( pt.x = 0; pt.x < width; pt.x++ )
        {
            if( data[pt.x] )
            {
                mdata[pt.x] = (uchar)1;
                CV_WRITE_SEQ_ELEM( pt, writer );//存入链表
            }
            else
                mdata[pt.x] = 0;
        }
    }
 
    seq = cvEndWriteSeq( &writer );
    count = seq->total;
 
		//随机处理
    // stage 2. process all the points in random order
    for( ; count > 0; count-- )
    {
		    // choose random point out of the remaining ones
				int idx = cvRandInt(&rng) % count;//生成随机数
				int max_val = threshold-1, max_n = 0;
				CvPoint* pt = (CvPoint*)cvGetSeqElem( seq, idx );
				CvPoint line_end[2] = {{0,0}, {0,0}};
				float a, b;
				int* adata = accum->data.i;
				int i, j, k, x0, y0, dx0, dy0, xflag;
				int good_line;
				const int shift = 16;
		
				i = pt->y;
				j = pt->x;
 
				//注意这行代码是为了覆盖pt指向的内容,也就是说pt指向的链表seq的内容被count-1位置上的内容覆盖了
        // "remove" it by overriding it with the last element
        *pt = *(CvPoint*)cvGetSeqElem( seq, count-1 );
 
        // check if it has been excluded already (i.e. belongs to some other line)
        if( !mdata0[i*width + j] )
            continue;
            
				//更新 累加器,查找最大概率的线
        // update accumulator, find the most probable line
        for( n = 0; n < numangle; n++, adata += numrho )
        {
            r = cvRound( j * ttab[n*2] + i * ttab[n*2+1] );
            r += (numrho - 1) / 2;//r有负值,使r取值在[0,numrho - 1]区间
            int val = ++adata[r];
            if( max_val < val )
            {
                max_val = val;
                max_n = n;
            }
        }
 
				//如果点的个数max_val < threshold 就被认为是不符合条件的候选点(i,j)
        // if it is too "weak" candidate, continue with another point
        if( max_val < threshold )
            continue;
 
				//如果点的个数max_val >= threshold 就被认为是符合条件的候选点(i,j)
			  // from the current point walk in each direction
			  // along the found line and extract the line segment
				//极坐标中的方向角是直线的垂线与极轴正向的夹角,在图像中夹角是第四象限的角
				//(极轴正向逆时针旋转,极轴就是在平面直角坐标系中的x轴正方向,对于图像来说,y轴正向是向下的)
				//所以sin取负值,cos不变
					a = -ttab[max_n*2+1];
					b = ttab[max_n*2];
					x0 = j;
					y0 = i;
				
				//计算步长dx0,dy0
        if( fabs(a) > fabs(b) )
        {
            xflag = 1;
            dx0 = a > 0 ? 1 : -1;
            dy0 = cvRound( b*(1 << shift)/fabs(a) );
            y0 = (y0 << shift) + (1 << (shift-1));
	    			//1 << shift这是为了把浮点数计算转化为整数计算
        }
        else
        {
            xflag = 0;
            dy0 = b > 0 ? 1 : -1;
            dx0 = cvRound( a*(1 << shift)/fabs(b) );
            x0 = (x0 << shift) + (1 << (shift-1));
        }
 
				//当点的位置和cos、sin确定后,每条直线都有两个方向
        for( k = 0; k < 2; k++ )
        {
            int gap = 0, x = x0, y = y0, dx = dx0, dy = dy0;
            
            if( k > 0 ) //控制两个方向(正好相反)
                dx = -dx, dy = -dy;
 
            // walk along the line using fixed-point arithmetics,
            // stop at the image border or in case of too big gap
            for( ;; x += dx, y += dy )
            {
                uchar* mdata;
                int i1, j1;
 
                if( xflag )
                {
                    j1 = x;
                    i1 = y >> shift;
                }
                else
                {
                    j1 = x >> shift;
                    i1 = y;
                }
 
                if( j1 < 0 || j1 >= width || i1 < 0 || i1 >= height )
                    break;
 
                mdata = mdata0 + i1*width + j1;
 
                // for each non-zero point:
                //    update line end,
                //    clear the mask element
                //    reset the gap
                if( *mdata )
                {
									gap = 0;
									line_end[k].y = i1;
									line_end[k].x = j1;
                }
                else if( ++gap > lineGap )//像素间隙大于lineGap 则退出
                    break;
            }
        }
 
				//分别计算X、Y方向距离
        good_line = abs(line_end[1].x - line_end[0].x) >= lineLength ||
                    abs(line_end[1].y - line_end[0].y) >= lineLength;
 
        for( k = 0; k < 2; k++ )
        {
            int x = x0, y = y0, dx = dx0, dy = dy0;
            
            if( k > 0 )
                dx = -dx, dy = -dy;
 
            // walk along the line using fixed-point arithmetics,
            // stop at the image border or in case of too big gap
            for( ;; x += dx, y += dy )
            {
                uchar* mdata;
                int i1, j1;
 
                if( xflag )
                {
                    j1 = x;
                    i1 = y >> shift;
                }
                else
                {
									j1 = x >> shift;
									i1 = y;
								}
 
                mdata = mdata0 + i1*width + j1;
 
                // for each non-zero point:
                //    update line end,
                //    clear the mask element
                //    reset the gap
                //如果*mdata == 1则设置为0,去除已经检测过的点
                if( *mdata )
                {
                		//如果是直线,则去除累加器里面的值
                    if( good_line )
                    {
                        adata = accum->data.i;
                        for( n = 0; n < numangle; n++, adata += numrho )
                        {
                            r = cvRound( j1 * ttab[n*2] + i1 * ttab[n*2+1] );
                            r += (numrho - 1) / 2;//r有负值,使r取值在[0,numrho - 1]区间
                            adata[r]--;
                        }
                    }
                    *mdata = 0;
                }
 
                if( i1 == line_end[k].y && j1 == line_end[k].x )
                    break;
            }
        }
 
        if( good_line )
        {
            CvRect lr = { line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y };
            cvSeqPush( lines, &lr );
            if( lines->total >= linesMax )
                EXIT;
        }
    }
 
    __END__;
 
    cvReleaseMat( &accum );
    cvReleaseMat( &mask );
    cvReleaseMat( &trigtab );
    cvReleaseMemStorage( &storage );
}

四. 总结

  今天的博客就到这里啦,欢迎大家在评论区互相学习讨论,我们下期见,三连哦~

参考链接:
1.【OpenCV入门教程之十四】OpenCV霍夫变换:霍夫线变换,霍夫圆变换合辑
2. openCV cvHoughLines2 函数源码解析(CV_HOUGH_PROBABILISTIC 基于概率的霍夫变换)
3. 第六章 - 图像变换 - 霍夫线变换(cvHoughLines2)

你可能感兴趣的:(opencv,cvHoughLines2详解,HoughLines源码解析,霍夫直线检测函数详解及源码解析,opencv霍夫直线检测,opencv自带直线检测函数)