＜图像处理＞ Kitchen-Rosenfeld角点检测

thisiszdy

于 2023-09-23 10:27:34 发布

阅读量155

点赞数

分类专栏：图像处理 # OpenCV 文章标签：图像处理

本文链接：https://blog.csdn.net/thisiszdy/article/details/133198721

版权

OpenCV 同时被 2 个专栏收录

20 篇文章 0 订阅

订阅专栏

图像处理

10 篇文章 0 订阅

订阅专栏

Kitchen-Rosenfeld角点检测原理

Kitchen和Rosenfeld认为角点是那些边缘曲线曲率和梯度幅值都很大的点，因此他们提出了使用曲率k与梯度幅值g的乘积来计算角点响应函数C的方法：
$C=kg=k(I_x^2-I_y^2)^{1/2} = \frac {I_{xx}I_y^2+I_{yy}I_x^2-2I_{xy}I_xI_y}{I_x^2+I_y^2}（1）$
C的极值点所对应的像素即为角点。 $I_x，I_y$ 为图像I的一阶导数，即：
$I_x=\frac{\partial I}{\partial x}，I_y=\frac{\partial I}{\partial y}$
$I_{xx}，I_{yy}，I_{xy}$ 为图像I的二阶导数，即：
$I_{xx}=\frac{\partial^2 I}{\partial x^2}，I_{yy}=\frac{\partial^2 I}{\partial y^2}，I_{xy}=\frac{\partial^2 I}{\partial xy}$
由于（1）式的分母恒大于0，它不改变角点响应函数的相对值，因此在实际应用中，只计算分子部分。

检测步骤

计算图像一阶、二阶导数；
利用（1）式分子，计算角点响应函数；
对角点响应函数进行非极大值抑制，并设定阈值，得到角点。

该方法对噪声比较敏感，因为使用了基于灰度的二阶偏导。

OpenCV函数

void cv::preCornerDetect(InputArray src, OutputArray dst, int ksize, int borderType = BORDER_DEFAULT)	

Parameters
src				输入图像，单通道8位整型或者32位浮点型；
dst				输出32位图像；
ksize			Sobel算子核尺寸；
borderType		边缘填充方法，但BORDER_WRAP不支持；

OpenCV源码分析

void cv::preCornerDetect( InputArray _src, OutputArray _dst, int ksize, int borderType )
{
    CV_INSTRUMENT_REGION();

    int type = _src.type();
    CV_Assert( type == CV_8UC1 || type == CV_32FC1 );

    CV_OCL_RUN( _src.dims() <= 2 && _dst.isUMat(),
                ocl_preCornerDetect(_src, _dst, ksize, borderType, CV_MAT_DEPTH(type)))

    Mat Dx, Dy, D2x, D2y, Dxy, src = _src.getMat();
    _dst.create( src.size(), CV_32FC1 );
    Mat dst = _dst.getMat();

	//Sobel算子计算一阶导数、二阶偏导
    Sobel( src, Dx, CV_32F, 1, 0, ksize, 1, 0, borderType );
    Sobel( src, Dy, CV_32F, 0, 1, ksize, 1, 0, borderType );
    Sobel( src, D2x, CV_32F, 2, 0, ksize, 1, 0, borderType );
    Sobel( src, D2y, CV_32F, 0, 2, ksize, 1, 0, borderType );
    Sobel( src, Dxy, CV_32F, 1, 1, ksize, 1, 0, borderType );

    double factor = 1 << (ksize - 1);
    if( src.depth() == CV_8U )
        factor *= 255;
    factor = 1./(factor * factor * factor);
#if CV_SIMD128
    float factor_f = (float)factor;
    v_float32x4 v_factor = v_setall_f32(factor_f), v_m2 = v_setall_f32(-2.0f);
#endif

    Size size = src.size();
    int i, j;
    for( i = 0; i < size.height; i++ )
    {
        float* dstdata = dst.ptr<float>(i);
        const float* dxdata = Dx.ptr<float>(i);
        const float* dydata = Dy.ptr<float>(i);
        const float* d2xdata = D2x.ptr<float>(i);
        const float* d2ydata = D2y.ptr<float>(i);
        const float* dxydata = Dxy.ptr<float>(i);

        j = 0;

//指令集加速
#if CV_SIMD128
        {
            for( ; j <= size.width - v_float32x4::nlanes; j += v_float32x4::nlanes )
            {
                v_float32x4 v_dx = v_load(dxdata + j);
                v_float32x4 v_dy = v_load(dydata + j);

                v_float32x4 v_s1 = (v_dx * v_dx) * v_load(d2ydata + j);
                v_float32x4 v_s2 = v_muladd((v_dy * v_dy),  v_load(d2xdata + j), v_s1);
                v_float32x4 v_s3 = v_muladd((v_dy * v_dx) * v_load(dxydata + j), v_m2, v_s2);

                v_store(dstdata + j, v_s3 * v_factor);
            }
        }
#endif

		//计算每个像素的响应函数
        for( ; j < size.width; j++ )
        {
            float dx = dxdata[j];
            float dy = dydata[j];
            dstdata[j] = (float)(factor*(dx*dx*d2ydata[j] + dy*dy*d2xdata[j] - 2*dx*dy*dxydata[j]));
        }
    }
}