图像特征检测(Image Feature Detection)

最新推荐文章于 2024-07-02 23:50:51 发布
转载 最新推荐文章于 2024-07-02 23:50:51 发布 · 1.6k 阅读 · 1

本文详细介绍并对比了多种图像特征检测方法，包括Sobel算子、拉普拉斯算子、Canny算子等边缘检测方法，以及Harris角点、ShiTomasi角点等角点检测方法，并给出了每种方法的具体实现代码。

图像特征检测(Image Feature Detection)

作者：王先荣
前言
    图像特征提取是计算机视觉和图像处理中的一个概念。它指的是使用计算机提取图像信息，决定每个图像的点是否属于一个图像特征。本文主要探讨如何提取图像中的“角点”这一特征，及其相关的内容。而诸如直方图、边缘、区域等内容在前文中有所提及，请查看相关文章。OpenCv（EmguCv）中实现了多种角点特征的提取方法，包括：Harris角点、ShiTomasi角点、亚像素级角点、SURF角点、Star关键点、FAST关键点、Lepetit关键点等等，本文将逐一介绍如何检测这些角点。在此之前将会先介绍跟角点检测密切相关的一些变换，包括Sobel算子、拉普拉斯算子、Canny算子、霍夫变换。另外，还会介绍一种广泛使用而OpenCv中并未实现的SIFT角点检测，以及最近在OpenCv中实现的MSER区域检测。所要讲述的内容会很多，我这里尽量写一些需要注意的地方及实现代码，而参考手册及书本中有的内容将一笔带过或者不会提及。

Sobel算子
    Sobel算子用多项式计算来拟合导数计算，可以用OpenCv中的cvSobel函数或者EmguCv中的Image<TColor,TDepth>.Sobel方法来进行计算。需要注意的是，xorder和yorder中必须且只能有一个为非零值，即只能计算x方向或者y反向的导数；如果将方形滤波器的宽度设置为特殊值CV_SCHARR（-1），将使用Scharr滤波器代替Sobel滤波器。
    使用Sobel滤波器的示例代码如下：

复制代码 
     

              
      //
      Sobel算子
      

              
      private
       
      string
       SobelFeatureDetect()
        {
            
      //
      获取参数
      

                  
      int
       xOrder 
      =
       
      int
      .Parse((
      string
      )cmbSobelXOrder.SelectedItem);
            
      int
       yOrder 
      =
       
      int
      .Parse((
      string
      )cmbSobelYOrder.SelectedItem);
            
      int
       apertureSize 
      =
       
      int
      .Parse((
      string
      )cmbSobelApertureSize.SelectedItem);
            
      if
       ((xOrder 
      ==
       
      0
       
      &&
       yOrder 
      ==
       
      0
      ) 
      ||
       (xOrder 
      !=
       
      0
       
      &&
       yOrder 
      !=
       
      0
      ))
                
      return
       
      "
      Sobel算子，参数错误：xOrder和yOrder中必须且只能有一个非零。\r\n
      "
      ;
            
      //
      计算
      

                  Stopwatch sw 
      =
       
      new
       Stopwatch();
            sw.Start();
            Image
      <
      Gray, Single
      >
       imageDest 
      =
       imageSourceGrayscale.Sobel(xOrder, yOrder, apertureSize);
            sw.Stop();
            
      //
      显示
      

                  pbResult.Image 
      =
       imageDest.Bitmap;
            
      //
      释放资源
      

                  imageDest.Dispose();
            
      //
      返回
      

                  
      return
       
      string
      .Format(
      "
      ·Sobel算子，用时{0:F05}毫秒，参数（x方向求导阶数：{1}，y方向求导阶数：{2}，方形滤波器宽度：{3}）\r\n
      "
      , sw.Elapsed.TotalMilliseconds, xOrder, yOrder, apertureSize);
        }
复制代码

 
拉普拉斯算子
    拉普拉斯算子可以用作边缘检测；可以用OpenCv中的cvLaplace函数或者EmguCv中的Image<TColor,TDepth>.Laplace方法来进行拉普拉斯变换。需要注意的是：OpenCv的文档有点小错误，apertureSize参数值不能为CV_SCHARR（-1）。
    使用拉普拉斯变换的示例代码如下：

复制代码 
     

              
      //
      拉普拉斯变换
      

              
      private
       
      string
       LaplaceFeatureDetect()
        {
            
      //
      获取参数
      

                  
      int
       apertureSize 
      =
       
      int
      .Parse((
      string
      )cmbLaplaceApertureSize.SelectedItem);
            
      //
      计算
      

                  Stopwatch sw 
      =
       
      new
       Stopwatch();
            sw.Start();
            Image
      <
      Gray, Single
      >
       imageDest 
      =
       imageSourceGrayscale.Laplace(apertureSize);
            sw.Stop();
            
      //
      显示
      

                  pbResult.Image 
      =
       imageDest.Bitmap;
            
      //
      释放资源
      

                  imageDest.Dispose();
            
      //
      返回
      

                  
      return
       
      string
      .Format(
      "
      ·拉普拉斯变换，用时{0:F05}毫秒，参数（方形滤波器宽度：{1}）\r\n
      "
      , sw.Elapsed.TotalMilliseconds, apertureSize);
        }
复制代码

 
Canny算子
    Canny算子也可以用作边缘检测；可以用OpenCv中的cvCanny函数或者EmguCv中的Image<TColor,TDepth>.Canny方法来进行Canny边缘检测。所不同的是，Image<TColor,TDepth>.Canny方法可以用于检测彩色图像的边缘，但是它只能使用apertureSize参数的默认值3；
而cvCanny只能处理灰度图像，不过可以自定义apertureSize。cvCanny和Canny的方法参数名有点点不同，下面是参数对照表。
Image<TColor,TDepth>.Canny    CvInvoke.cvCanny
thresh                                         lowThresh
threshLinking                               highThresh
3                                                apertureSize
值得注意的是，apertureSize只能取3，5或者7，这可以在cvcanny.cpp第87行看到：

    

         aperture_size 
     &=
      INT_MAX;
    
     if
     ( (aperture_size 
     &
      
     1
     ) 
     ==
      
     0
      
     ||
      aperture_size 
     <
      
     3
      
     ||
      aperture_size 
     >
      
     7
      )
        CV_ERROR( CV_StsBadFlag, 
     ""
      );


使用Canny算子的示例代码如下：

复制代码 
     

              
      //
      Canny算子
      

              
      private
       
      string
       CannyFeatureDetect()
        {
            
      //
      获取参数
      

                  
      double
       lowThresh 
      =
       
      double
      .Parse(txtCannyLowThresh.Text);
            
      double
       highThresh 
      =
       
      double
      .Parse(txtCannyHighThresh.Text);
            
      int
       apertureSize 
      =
       
      int
      .Parse((
      string
      )cmbCannyApertureSize.SelectedItem);
            
      //
      计算
      

                  Stopwatch sw 
      =
       
      new
       Stopwatch();
            sw.Start();
            Image
      <
      Gray, Byte
      >
       imageDest 
      =
       
      null
      ;
            Image
      <
      Bgr, Byte
      >
       imageDest2 
      =
       
      null
      ;
            
      if
       (rbCannyUseCvCanny.Checked)
            {
                imageDest 
      =
       
      new
       Image
      <
      Gray, 
      byte
      >
      (imageSourceGrayscale.Size);
                CvInvoke.cvCanny(imageSourceGrayscale.Ptr, imageDest.Ptr, lowThresh, highThresh, apertureSize);
            }
            
      else
      
                imageDest2 
      =
       imageSource.Canny(
      new
       Bgr(lowThresh, lowThresh, lowThresh), 
      new
       Bgr(highThresh, highThresh, highThresh));
            sw.Stop();
            
      //
      显示
      

                  pbResult.Image 
      =
       rbCannyUseCvCanny.Checked 
      ?
       imageDest.Bitmap : imageDest2.Bitmap;
            
      //
      释放资源
      

                  
      if
       (imageDest 
      !=
       
      null
      )
                imageDest.Dispose();
            
      if
       (imageDest2 
      !=
       
      null
      )
                imageDest2.Dispose();
            
      //
      返回
      

                  
      return
       
      string
      .Format(
      "
      ·Canny算子，用时{0:F05}毫秒，参数（方式：{1}，阀值下限：{2}，阀值上限：{3}，方形滤波器宽度：{4}）\r\n
      "
      , sw.Elapsed.TotalMilliseconds, rbCannyUseCvCanny.Checked 
      ?
       
      "
      cvCanny
      "
       : 
      "
      Image<TColor, TDepth>.Canny
      "
      , lowThresh, highThresh, apertureSize);
        }
复制代码

 

另外，在http://www.china-vision.net/blog/user2/15975/archives/2007/804.html有一种自动获取Canny算子高低阀值的方法，作者提供了用C语言实现的代码。我将其改写成了C#版本，代码如下：

复制代码 
     

              
      ///
       
      <summary>
      
        
      ///
       计算图像的自适应Canny算子阀值
        
      ///
       
      </summary>
      
        
      ///
       
      <param name="imageSrc">
      源图像，只能是256级灰度图像
      </param>
      
        
      ///
       
      <param name="apertureSize">
      方形滤波器的宽度
      </param>
      
        
      ///
       
      <param name="lowThresh">
      阀值下限
      </param>
      
        
      ///
       
      <param name="highThresh">
      阀值上限
      </param>
      

              
      unsafe
       
      void
       AdaptiveFindCannyThreshold(Image
      <
      Gray, Byte
      >
       imageSrc, 
      int
       apertureSize, 
      out
       
      double
       lowThresh, 
      out
       
      double
       highThresh)
        {
            
      //
      计算源图像x方向和y方向的1阶Sobel算子
      

                  Size size 
      =
       imageSrc.Size;
            Image
      <
      Gray, Int16
      >
       imageDx 
      =
       
      new
       Image
      <
      Gray, 
      short
      >
      (size);
            Image
      <
      Gray, Int16
      >
       imageDy 
      =
       
      new
       Image
      <
      Gray, 
      short
      >
      (size);
            CvInvoke.cvSobel(imageSrc.Ptr, imageDx.Ptr, 
      1
      , 
      0
      , apertureSize);
            CvInvoke.cvSobel(imageSrc.Ptr, imageDy.Ptr, 
      0
      , 
      1
      , apertureSize);
            Image
      <
      Gray, Single
      >
       image 
      =
       
      new
       Image
      <
      Gray, 
      float
      >
      (size);
            
      int
       i, j;
            DenseHistogram hist 
      =
       
      null
      ;
            
      int
       hist_size 
      =
       
      255
      ;
            
      float
      [] range_0 
      =
       
      new
       
      float
      [] { 
      0
      , 
      256
       };
            
      double
       PercentOfPixelsNotEdges 
      =
       
      0.7
      ;
            
      //
      计算边缘的强度，并保存于图像中
      

                  
      float
       maxv 
      =
       
      0
      ;
            
      float
       temp;
            
      byte
      *
       imageDataDx 
      =
       (
      byte
      *
      )imageDx.MIplImage.imageData.ToPointer();
            
      byte
      *
       imageDataDy 
      =
       (
      byte
      *
      )imageDy.MIplImage.imageData.ToPointer();
            
      byte
      *
       imageData 
      =
       (
      byte
      *
      )image.MIplImage.imageData.ToPointer();
            
      int
       widthStepDx 
      =
       imageDx.MIplImage.widthStep;
            
      int
       widthStepDy 
      =
       widthStepDx;
            
      int
       widthStep 
      =
       image.MIplImage.widthStep;
            
      for
       (i 
      =
       
      0
      ; i 
      <
       size.Height; i
      ++
      )
            {
                
      short
      *
       _dx 
      =
       (
      short
      *
      )(imageDataDx 
      +
       widthStepDx 
      *
       i);
                
      short
      *
       _dy 
      =
       (
      short
      *
      )(imageDataDy 
      +
       widthStepDy 
      *
       i);
                
      float
      *
       _image 
      =
       (
      float
      *
      )(imageData 
      +
       widthStep 
      *
       i);
                
      for
       (j 
      =
       
      0
      ; j 
      <
       size.Width; j
      ++
      )
                {
                    temp 
      =
       (
      float
      )(Math.Abs(
      *
      (_dx 
      +
       j)) 
      +
       Math.Abs(
      *
      (_dy 
      +
       j)));
                    
      *
      (_image 
      +
       j) 
      =
       temp;
                    
      if
       (maxv 
      <
       temp)
                        maxv 
      =
       temp;
                }
            }
            
      //
      计算直方图
      

                  range_0[
      1
      ] 
      =
       maxv;
            hist_size 
      =
       hist_size 
      >
       maxv 
      ?
       (
      int
      )maxv : hist_size;
            hist 
      =
       
      new
       DenseHistogram(hist_size, 
      new
       RangeF(range_0[
      0
      ], range_0[
      1
      ]));
            hist.Calculate
      <
      Single
      >
      (
      new
       Image
      <
      Gray, Single
      >
      [] { image }, 
      false
      , 
      null
      );
            
      int
       total 
      =
       (
      int
      )(size.Height 
      *
       size.Width 
      *
       PercentOfPixelsNotEdges);
            
      double
       sum 
      =
       
      0
      ;
            
      int
       icount 
      =
       hist.BinDimension[
      0
      ].Size;
            
      for
       (i 
      =
       
      0
      ; i 
      <
       icount; i
      ++
      )
            {
                sum 
      +=
       hist[i];
                
      if
       (sum 
      >
       total)
                    
      break
      ;
            }
            
      //
      计算阀值
      

                  highThresh 
      =
       (i 
      +
       
      1
      ) 
      *
       maxv 
      /
       hist_size;
            lowThresh 
      =
       highThresh 
      *
       
      0.4
      ;
            
      //
      释放资源
      

                  imageDx.Dispose();
            imageDy.Dispose(); image.Dispose();
            hist.Dispose();
        }
复制代码

 
霍夫变换
    霍夫变换是一种在图像中寻找直线、圆及其他简单形状的方法，在OpenCv中实现了霍夫线变换和霍夫圆变换。值得注意的地方有以下几点：（1）HoughLines2需要先计算Canny边缘，然后再检测直线；（2）HoughLines2计算结果的获取随获取方式的不同而不同；（3）HoughCircles检测结果似乎不正确。
    使用霍夫变换的示例代码如下所示：

复制代码 
     

              
      //
      霍夫线变换
      

              
      private
       
      string
       HoughLinesFeatureDetect()
        {
            
      //
      获取参数
      

                  HOUGH_TYPE method 
      =
       rbHoughLinesSHT.Checked 
      ?
       HOUGH_TYPE.CV_HOUGH_STANDARD : (rbHoughLinesPPHT.Checked 
      ?
       HOUGH_TYPE.CV_HOUGH_PROBABILISTIC : HOUGH_TYPE.CV_HOUGH_MULTI_SCALE);
            
      double
       rho 
      =
       
      double
      .Parse(txtHoughLinesRho.Text);
            
      double
       theta 
      =
       
      double
      .Parse(txtHoughLinesTheta.Text);
            
      int
       threshold 
      =
       
      int
      .Parse(txtHoughLinesThreshold.Text);
            
      double
       param1 
      =
       
      double
      .Parse(txtHoughLinesParam1.Text);
            
      double
       param2 
      =
       
      double
      .Parse(txtHoughLinesParam2.Text);
            MemStorage storage 
      =
       
      new
       MemStorage();
            
      int
       linesCount 
      =
       
      0
      ;
            StringBuilder sbResult 
      =
       
      new
       StringBuilder();
            
      //
      计算，先运行Canny边缘检测（参数来自Canny算子属性页），然后再用计算霍夫线变换
      

                  
      double
       lowThresh 
      =
       
      double
      .Parse(txtCannyLowThresh.Text);
            
      double
       highThresh 
      =
       
      double
      .Parse(txtCannyHighThresh.Text);
            
      int
       apertureSize 
      =
       
      int
      .Parse((
      string
      )cmbCannyApertureSize.SelectedItem);
            Image
      <
      Gray, Byte
      >
       imageCanny 
      =
       
      new
       Image
      <
      Gray, 
      byte
      >
      (imageSourceGrayscale.Size);
            CvInvoke.cvCanny(imageSourceGrayscale.Ptr, imageCanny.Ptr, lowThresh, highThresh, apertureSize);
            Stopwatch sw 
      =
       
      new
       Stopwatch();
            sw.Start();
            IntPtr ptrLines 
      =
       CvInvoke.cvHoughLines2(imageCanny.Ptr, storage.Ptr, method, rho, theta, threshold, param1, param2);
            Seq
      <
      LineSegment2D
      >
       linesSeq 
      =
       
      null
      ;
            Seq
      <
      PointF
      >
       linesSeq2 
      =
       
      null
      ;
            
      if
       (method 
      ==
       HOUGH_TYPE.CV_HOUGH_PROBABILISTIC)
                linesSeq 
      =
       
      new
       Seq
      <
      LineSegment2D
      >
      (ptrLines, storage);
            
      else
      
                linesSeq2 
      =
       
      new
       Seq
      <
      PointF
      >
      (ptrLines, storage);
            sw.Stop();
            
      //
      显示
      

                  Image
      <
      Bgr, Byte
      >
       imageResult 
      =
       imageSourceGrayscale.Convert
      <
      Bgr, Byte
      >
      ();
            
      if
       (linesSeq 
      !=
       
      null
      )
            {
                linesCount 
      =
       linesSeq.Total;
                
      foreach
       (LineSegment2D line 
      in
       linesSeq)
                {
                    imageResult.Draw(line, 
      new
       Bgr(255d, 0d, 0d), 
      4
      );
                    sbResult.AppendFormat(
      "
      {0}-{1}，
      "
      , line.P1, line.P2);
                }
            }
            
      else
      
            {
                linesCount 
      =
       linesSeq2.Total;
                
      foreach
       (PointF line 
      in
       linesSeq2)
                {
                    
      float
       r 
      =
       line.X;
                    
      float
       t 
      =
       line.Y;
                    
      double
       a 
      =
       Math.Cos(t), b 
      =
       Math.Sin(t);
                    
      double
       x0 
      =
       a 
      *
       r, y0 
      =
       b 
      *
       r;
                    
      int
       x1 
      =
       (
      int
      )(x0 
      +
       
      1000
       
      *
       (
      -
      b));
                    
      int
       y1 
      =
       (
      int
      )(y0 
      +
       
      1000
       
      *
       (a));
                    
      int
       x2 
      =
       (
      int
      )(x0 
      -
       
      1000
       
      *
       (
      -
      b));
                    
      int
       y2 
      =
       (
      int
      )(y0 
      -
       
      1000
       
      *
       (a));
                    Point pt1 
      =
       
      new
       Point(x1, y1);
                    Point pt2 
      =
       
      new
       Point(x2, y2);
                    imageResult.Draw(
      new
       LineSegment2D(pt1, pt2), 
      new
       Bgr(255d, 0d, 0d), 
      4
      );
                    sbResult.AppendFormat(
      "
      {0}-{1}，
      "
      , pt1, pt2);
                }
            }
            pbResult.Image 
      =
       imageResult.Bitmap;
            
      //
      释放资源
      

                  imageCanny.Dispose();
            imageResult.Dispose();
            storage.Dispose();
            
      //
      返回
      

                  
      return
       
      string
      .Format(
      "
      ·霍夫线变换，用时{0:F05}毫秒，参数（变换方式：{1}，距离精度：{2}，弧度精度：{3}，阀值：{4}，参数1：{5}，参数2：{6}），找到{7}条直线\r\n{8}
      "
      ,
                sw.Elapsed.TotalMilliseconds, method.ToString(
      "
      G
      "
      ), rho, theta, threshold, param1, param2, linesCount, linesCount 
      !=
       
      0
       
      ?
       (sbResult.ToString() 
      +
       
      "
      \r\n
      "
      ) : 
      ""
      );
        }

        
      //
      霍夫圆变换
      

              
      private
       
      string
       HoughCirclesFeatureDetect()
        {
            
      //
      获取参数
      

                  
      double
       dp 
      =
       
      double
      .Parse(txtHoughCirclesDp.Text);
            
      double
       minDist 
      =
       
      double
      .Parse(txtHoughCirclesMinDist.Text);
            
      double
       param1 
      =
       
      double
      .Parse(txtHoughCirclesParam1.Text);
            
      double
       param2 
      =
       
      double
      .Parse(txtHoughCirclesParam2.Text);
            
      int
       minRadius 
      =
       
      int
      .Parse(txtHoughCirclesMinRadius.Text);
            
      int
       maxRadius 
      =
       
      int
      .Parse(txtHoughCirclesMaxRadius.Text);
            StringBuilder sbResult 
      =
       
      new
       StringBuilder();
            
      //
      计算
      

                  Stopwatch sw 
      =
       
      new
       Stopwatch();
            sw.Start();
            CircleF[][] circles 
      =
       imageSourceGrayscale.HoughCircles(
      new
       Gray(param1), 
      new
       Gray(param2), dp, minDist, minRadius, maxRadius);
            sw.Stop();
            
      //
      显示
      

                  Image
      <
      Bgr, Byte
      >
       imageResult 
      =
       imageSourceGrayscale.Convert
      <
      Bgr, Byte
      >
      ();
            
      int
       circlesCount 
      =
       
      0
      ;
            
      foreach
       (CircleF[] cs 
      in
       circles)
            {
                
      foreach
       (CircleF circle 
      in
       cs)
                {
                    imageResult.Draw(circle, 
      new
       Bgr(255d, 0d, 0d), 
      4
      );
                    sbResult.AppendFormat(
      "
      圆心{0}半径{1}，
      "
      , circle.Center, circle.Radius);
                    circlesCount
      ++
      ;
                }
            }
            pbResult.Image 
      =
       imageResult.Bitmap;
            
      //
      释放资源
      

                  imageResult.Dispose();
            
      //
      返回
      

                  
      return
       
      string
      .Format(
      "
      ·霍夫圆变换，用时{0:F05}毫秒，参数（累加器图像的最小分辨率：{1}，不同圆之间的最小距离：{2}，边缘阀值：{3}，累加器阀值：{4}，最小圆半径：{5}，最大圆半径：{6}），找到{7}个圆\r\n{8}
      "
      ,
                sw.Elapsed.TotalMilliseconds, dp, minDist, param1, param2, minRadius, maxRadius, circlesCount, sbResult.Length 
      >
       
      0
       
      ?
       (sbResult.ToString() 
      +
       
      "
      \r\n
      "
      ) : 
      ""
      );
        }
复制代码

 

Harris角点
    cvCornerHarris函数检测的结果实际上是一幅包含Harris角点的浮点型单通道图像，可以使用类似下面的代码来计算包含Harris角点的图像：

复制代码 
     

              
      //
      Harris角点
      

              
      private
       
      string
       CornerHarrisFeatureDetect()
        {
            
      //
      获取参数
      

                  
      int
       blockSize 
      =
       
      int
      .Parse(txtCornerHarrisBlockSize.Text);
            
      int
       apertureSize 
      =
       
      int
      .Parse(txtCornerHarrisApertureSize.Text);
            
      double
       k 
      =
       
      double
      .Parse(txtCornerHarrisK.Text);
            
      //
      计算
      

                  Image
      <
      Gray, Single
      >
       imageDest 
      =
       
      new
       Image
      <
      Gray, 
      float
      >
      (imageSourceGrayscale.Size);
            Stopwatch sw 
      =
       
      new
       Stopwatch();
            sw.Start();
            CvInvoke.cvCornerHarris(imageSourceGrayscale.Ptr, imageDest.Ptr, blockSize, apertureSize, k);
            sw.Stop();
            
      //
      显示
      

                  pbResult.Image 
      =
       imageDest.Bitmap;
            
      //
      释放资源
      

                  imageDest.Dispose();
            
      //
      返回
      

                  
      return
       
      string
      .Format(
      "
      ·Harris角点，用时{0:F05}毫秒，参数（邻域大小：{1}，方形滤波器宽度：{2}，权重系数：{3}）\r\n
      "
      , sw.Elapsed.TotalMilliseconds, blockSize, apertureSize, k);
        }
复制代码

    如果要计算Harris角点列表，需要使用cvGoodFeatureToTrack函数，并传递适当的参数。

ShiTomasi角点
    在默认情况下，cvGoodFeatureToTrack函数计算ShiTomasi角点；不过如果将参数use_harris设置为非0值，那么它会计算harris角点。
使用cvGoodFeatureToTrack函数的示例代码如下：

复制代码 
     

              
      //
      ShiTomasi角点
      

              
      private
       
      string
       CornerShiTomasiFeatureDetect()
        {
            
      //
      获取参数
      

                  
      int
       cornerCount 
      =
       
      int
      .Parse(txtGoodFeaturesCornerCount.Text);
            
      double
       qualityLevel 
      =
       
      double
      .Parse(txtGoodFeaturesQualityLevel.Text);
            
      double
       minDistance 
      =
       
      double
      .Parse(txtGoodFeaturesMinDistance.Text);
            
      int
       blockSize 
      =
       
      int
      .Parse(txtGoodFeaturesBlockSize.Text);
            
      bool
       useHarris 
      =
       cbGoodFeaturesUseHarris.Checked;
            
      double
       k 
      =
       
      double
      .Parse(txtGoodFeaturesK.Text);
            
      //
      计算
      

                  Stopwatch sw 
      =
       
      new
       Stopwatch();
            sw.Start();
            PointF[][] corners 
      =
       imageSourceGrayscale.GoodFeaturesToTrack(cornerCount, qualityLevel, minDistance, blockSize, useHarris, k);
            sw.Stop();
            
      //
      显示
      

                  Image
      <
      Bgr, Byte
      >
       imageResult 
      =
       imageSourceGrayscale.Convert
      <
      Bgr, Byte
      >
      ();
            
      int
       cornerCount2 
      =
       
      0
      ;
            StringBuilder sbResult 
      =
       
      new
       StringBuilder();
            
      int
       radius 
      =
       (
      int
      )(minDistance 
      /
       
      2
      ) 
      +
       
      1
      ;
            
      int
       thickness 
      =
       (
      int
      )(minDistance 
      /
       
      4
      ) 
      +
       
      1
      ;
            
      foreach
       (PointF[] cs 
      in
       corners)
            {
                
      foreach
       (PointF p 
      in
       cs)
                {
                    imageResult.Draw(
      new
       CircleF(p, radius), 
      new
       Bgr(255d, 0d, 0d), thickness);
                    cornerCount2
      ++
      ;
                    sbResult.AppendFormat(
      "
      {0}，
      "
      , p);
                }
            }
            pbResult.Image 
      =
       imageResult.Bitmap;
            
      //
      释放资源
      

                  imageResult.Dispose();
            
      //
      返回
      

                  
      return
       
      string
      .Format(
      "
      ·ShiTomasi角点，用时{0:F05}毫秒，参数（最大角点数目：{1}，最小特征值：{2}，角点间的最小距离：{3}，邻域大小：{4}，角点类型：{5}，权重系数：{6}），检测到{7}个角点\r\n{8}
      "
      ,
                sw.Elapsed.TotalMilliseconds, cornerCount, qualityLevel, minDistance, blockSize, useHarris 
      ?
       
      "
      Harris
      "
       : 
      "
      ShiTomasi
      "
      , k, cornerCount2, cornerCount2 
      >
       
      0
       
      ?
       (sbResult.ToString() 
      +
       
      "
      \r\n
      "
      ) : 
      ""
      );
        }
复制代码

 

亚像素级角点
    在检测亚像素级角点前，需要提供角点的初始为止，这些初始位置可以用本文给出的其他的角点检测方式来获取，不过使用GoodFeaturesToTrack得到的结果最方便直接使用。
    亚像素级角点检测的示例代码如下：

亚像素级角点

 

SURF角点
    OpenCv中的cvExtractSURF函数和EmguCv中的Image<TColor,TDepth>.ExtractSURF方法用于检测SURF角点。
    SURF角点检测的示例代码如下：

复制代码 
     

              
      //
      SURF角点
      

              
      private
       
      string
       SurfFeatureDetect()
        {
            
      //
      获取参数
      

                  
      bool
       getDescriptors 
      =
       cbSurfGetDescriptors.Checked;
            MCvSURFParams surfParam 
      =
       
      new
       MCvSURFParams();
            surfParam.extended
      =
      rbSurfBasicDescriptor.Checked 
      ?
       
      0
       : 
      1
      ;
            surfParam.hessianThreshold
      =
      double
      .Parse(txtSurfHessianThreshold.Text);
            surfParam.nOctaves
      =
      int
      .Parse(txtSurfNumberOfOctaves.Text);
            surfParam.nOctaveLayers
      =
      int
      .Parse(txtSurfNumberOfOctaveLayers.Text);
            
      //
      计算
      

                  SURFFeature[] features 
      =
       
      null
      ;
            MKeyPoint[] keyPoints 
      =
       
      null
      ;
            Stopwatch sw 
      =
       
      new
       Stopwatch();
            sw.Start();
            
      if
       (getDescriptors)
                features 
      =
       imageSourceGrayscale.ExtractSURF(
      ref
       surfParam);
            
      else
      
                keyPoints 
      =
       surfParam.DetectKeyPoints(imageSourceGrayscale, 
      null
      );
            sw.Stop();
            
      //
      显示
      

                  
      bool
       showDetail 
      =
       cbSurfShowDetail.Checked;
            Image
      <
      Bgr, Byte
      >
       imageResult 
      =
       imageSourceGrayscale.Convert
      <
      Bgr, Byte
      >
      ();
            StringBuilder sbResult 
      =
       
      new
       StringBuilder();
            
      int
       idx 
      =
       
      0
      ;
            
      if
       (getDescriptors)
            {
                
      foreach
       (SURFFeature feature 
      in
       features)
                {
                    imageResult.Draw(
      new
       CircleF(feature.Point.pt, 
      5
      ), 
      new
       Bgr(255d, 0d, 0d), 
      2
      );
                    
      if
       (showDetail)
                    {
                        sbResult.AppendFormat(
      "
      第{0}点（坐标：{1}，尺寸：{2}，方向：{3}°，hessian值：{4}，拉普拉斯标志：{5}，描述：[
      "
      ,
                            idx, feature.Point.pt, feature.Point.size, feature.Point.dir, feature.Point.hessian, feature.Point.laplacian);
                        
      foreach
       (
      float
       d 
      in
       feature.Descriptor)
                            sbResult.AppendFormat(
      "
      {0},
      "
      , d);
                        sbResult.Append(
      "
      ]），
      "
      );
                    }
                    idx
      ++
      ;
                }
            }
            
      else
      
            {
                
      foreach
       (MKeyPoint keypoint 
      in
       keyPoints)
                {
                    imageResult.Draw(
      new
       CircleF(keypoint.Point, 
      5
      ), 
      new
       Bgr(255d, 0d, 0d), 
      2
      );
                    
      if
       (showDetail)
                        sbResult.AppendFormat(
      "
      第{0}点（坐标：{1}，尺寸：{2}，方向：{3}°，响应：{4}，octave：{5}），
      "
      ,
                            idx, keypoint.Point, keypoint.Size, keypoint.Angle, keypoint.Response, keypoint.Octave);
                    idx
      ++
      ;
                }
            }
            pbResult.Image 
      =
       imageResult.Bitmap;
            
      //
      释放资源
      

                  imageResult.Dispose();
            
      //
      返回
      

                  
      return
       
      string
      .Format(
      "
      ·SURF角点，用时{0:F05}毫秒，参数（描述：{1}，hessian阀值：{2}，octave数目：{3}，每个octave的层数：{4}，检测到{5}个角点\r\n{6}
      "
      ,
                sw.Elapsed.TotalMilliseconds, getDescriptors 
      ?
       (surfParam.extended 
      ==
       
      0
       
      ?
       
      "
      获取基本描述
      "
       : 
      "
      获取扩展描述
      "
      ) : 
      "
      不获取描述
      "
      , surfParam.hessianThreshold,
                surfParam.nOctaves, surfParam.nOctaveLayers, getDescriptors 
      ?
       features.Length : keyPoints.Length, showDetail 
      ?
       sbResult.ToString() 
      +
       
      "
      \r\n
      "
       : 
      ""
      );
        }
复制代码

 

Star关键点
    OpenCv中的cvGetStarKeypoints函数和EmguCv中的Image<TColor,TDepth>.GetStarKeypoints方法用于检测“星型”附近的点。
    Star关键点检测的示例代码如下：

复制代码 
     

              
      //
      Star关键点
      

              
      private
       
      string
       StarKeyPointFeatureDetect()
        {
            
      //
      获取参数
      

                  StarDetector starParam 
      =
       
      new
       StarDetector();
            starParam.MaxSize 
      =
       
      int
      .Parse((
      string
      )cmbStarMaxSize.SelectedItem);
            starParam.ResponseThreshold 
      =
       
      int
      .Parse(txtStarResponseThreshold.Text);
            starParam.LineThresholdProjected 
      =
       
      int
      .Parse(txtStarLineThresholdProjected.Text);
            starParam.LineThresholdBinarized 
      =
       
      int
      .Parse(txtStarLineThresholdBinarized.Text);
            starParam.SuppressNonmaxSize 
      =
       
      int
      .Parse(txtStarSuppressNonmaxSize.Text);
            
      //
      计算
      

                  Stopwatch sw 
      =
       
      new
       Stopwatch();
            sw.Start();
            MCvStarKeypoint[] keyPoints 
      =
       imageSourceGrayscale.GetStarKeypoints(
      ref
       starParam);
            sw.Stop();
            
      //
      显示
      

                  Image
      <
      Bgr, Byte
      >
       imageResult 
      =
       imageSourceGrayscale.Convert
      <
      Bgr, Byte
      >
      ();
            StringBuilder sbResult 
      =
       
      new
       StringBuilder();
            
      int
       idx 
      =
       
      0
      ;
            
      foreach
       (MCvStarKeypoint keypoint 
      in
       keyPoints)
            {
                imageResult.Draw(
      new
       CircleF(
      new
       PointF(keypoint.pt.X, keypoint.pt.Y), keypoint.size 
      /
       
      2
      ), 
      new
       Bgr(255d, 0d, 0d), keypoint.size 
      /
       
      4
      );
                sbResult.AppendFormat(
      "
      第{0}点（坐标：{1}，尺寸：{2}，强度：{3}），
      "
      , idx, keypoint.pt, keypoint.size, keypoint.response);
                idx
      ++
      ;
            }
            pbResult.Image 
      =
       imageResult.Bitmap;
            
      //
      释放资源
      

                  imageResult.Dispose();
            
      //
      返回
      

                  
      return
       
      string
      .Format(
      "
      ·Star关键点，用时{0:F05}毫秒，参数（MaxSize：{1}，ResponseThreshold：{2}，LineThresholdProjected：{3}，LineThresholdBinarized：{4}，SuppressNonmaxSize：{5}），检测到{6}个关键点\r\n{7}
      "
      ,
                sw.Elapsed.TotalMilliseconds, starParam.MaxSize, starParam.ResponseThreshold, starParam.LineThresholdProjected, starParam.LineThresholdBinarized, starParam.SuppressNonmaxSize, keyPoints.Length, keyPoints.Length 
      >
       
      0
       
      ?
       (sbResult.ToString() 
      +
       
      "
      \r\n
      "
      ) : 
      ""
      );
        }
复制代码

 
FAST角点检测
    FAST角点由E. Rosten教授提出，相比其他检测手段，这种方法的速度正如其名，相当的快。值得关注的是他所研究的理论都是属于实用类的，都很快。Rosten教授实现了FAST角点检测，并将其提供给了OpenCv，相当的有爱呀；不过OpenCv中的函数和Rosten教授的实现似乎有点点不太一样。遗憾的是，OpenCv中目前还没有FAST角点检测的文档。下面是我从Rosten的代码中找到的函数声明，可以看到粗略的参数说明。
/*
The references are:

 * Machine learning for high-speed corner detection,
 
   E. Rosten and T. Drummond, ECCV 2006
 * Faster and better: A machine learning approach to corner detection

   E. Rosten, R. Porter and T. Drummond, PAMI, 2009

*/
void cvCornerFast( const CvArr* image, int threshold, int N,

                   int nonmax_suppression, int* ret_number_of_corners,
                   CvPoint** ret_corners);


image:      OpenCV image in which to detect corners. Must be 8 bit unsigned.

threshold:  Threshold for detection (higher is fewer corners). 0--255

N:          Arc length of detector, 9, 10, 11 or 12. 9 is usually best.

nonmax_suppression: Whether to perform nonmaximal suppression.

ret_number_of_corners: The number of detected corners is returned here.

ret_corners: The corners are returned here.
EmguCv中的Image<TColor,TDepth>.GetFASTKeypoints方法也实现了FAST角点检测，不过参数少了一些，只有threshold和nonmaxSupression，其中N我估计取的默认值9，但是返回的角点数目我不知道是怎么设置的。
使用FAST角点检测的示例代码如下：

FAST关键点

 

Lepetit关键点
    Lepetit关键点由Vincent Lepetit提出，可以在他的网站（http://cvlab.epfl.ch/~vlepetit/）上看到相关的论文等资料。EmguCv中的类LDetector实现了Lepetit关键点的检测。
    使用Lepetit关键点检测的示例代码如下：

复制代码 
     

              
      //
      Lepetit关键点
      

              
      private
       
      string
       LepetitKeyPointFeatureDetect()
        {
            
      //
      获取参数
      

                  LDetector lepetitDetector 
      =
       
      new
       LDetector();
            lepetitDetector.BaseFeatureSize 
      =
       
      double
      .Parse(txtLepetitBaseFeatureSize.Text);
            lepetitDetector.ClusteringDistance 
      =
       
      double
      .Parse(txtLepetitClasteringDistance.Text);
            lepetitDetector.NOctaves 
      =
       
      int
      .Parse(txtLepetitNumberOfOctaves.Text);
            lepetitDetector.NViews 
      =
       
      int
      .Parse(txtLepetitNumberOfViews.Text);
            lepetitDetector.Radius 
      =
       
      int
      .Parse(txtLepetitRadius.Text);
            lepetitDetector.Threshold 
      =
       
      int
      .Parse(txtLepetitThreshold.Text);
            lepetitDetector.Verbose 
      =
       cbLepetitVerbose.Checked;
            
      int
       maxCount 
      =
       
      int
      .Parse(txtLepetitMaxCount.Text);
            
      bool
       scaleCoords 
      =
       cbLepetitScaleCoords.Checked;
            
      bool
       showDetail 
      =
       cbLepetitShowDetail.Checked;
            
      //
      计算
      

                  Stopwatch sw 
      =
       
      new
       Stopwatch();
            sw.Start();
            MKeyPoint[] keyPoints 
      =
       lepetitDetector.DetectKeyPoints(imageSourceGrayscale, maxCount, scaleCoords);
            sw.Stop();
            
      //
      显示
      

                  Image
      <
      Bgr, Byte
      >
       imageResult 
      =
       imageSourceGrayscale.Convert
      <
      Bgr, Byte
      >
      ();
            StringBuilder sbResult 
      =
       
      new
       StringBuilder();
            
      int
       idx 
      =
       
      0
      ;
            
      foreach
       (MKeyPoint keypoint 
      in
       keyPoints)
            {
                
      //
      imageResult.Draw(new CircleF(keypoint.Point, (int)(keypoint.Size / 2)), new Bgr(255d, 0d, 0d), (int)(keypoint.Size / 4));
      

                      imageResult.Draw(
      new
       CircleF(keypoint.Point, 
      4
      ), 
      new
       Bgr(255d, 0d, 0d), 
      2
      );
                
      if
       (showDetail)
                    sbResult.AppendFormat(
      "
      第{0}点（坐标：{1}，尺寸：{2}，方向：{3}°，响应：{4}，octave：{5}），
      "
      ,
                                idx, keypoint.Point, keypoint.Size, keypoint.Angle, keypoint.Response, keypoint.Octave);
                idx
      ++
      ;
            }
            pbResult.Image 
      =
       imageResult.Bitmap;
            
      //
      释放资源
      

                  imageResult.Dispose();
            
      //
      返回
      

                  
      return
       
      string
      .Format(
      "
      ·Lepetit关键点，用时{0:F05}毫秒，参数（基础特征尺寸：{1}，集群距离：{2}，阶数：{3}，视图数：{4}，半径：{5}，阀值：{6}，计算详细结果：{7}，最大关键点数目：{8}，缩放坐标：{9}），检测到{10}个关键点\r\n{11}
      "
      ,
                sw.Elapsed.TotalMilliseconds, lepetitDetector.BaseFeatureSize, lepetitDetector.ClusteringDistance, lepetitDetector.NOctaves, lepetitDetector.NViews,
                lepetitDetector.Radius, lepetitDetector.Threshold, lepetitDetector.Verbose, maxCount, scaleCoords, keyPoints.Length, showDetail 
      ?
       (sbResult.ToString() 
      +
       
      "
      \r\n
      "
      ) : 
      ""
      );
        }
复制代码


SIFT角点
    SIFT角点是一种广泛使用的图像特征，可用于物体跟踪、图像匹配、图像拼接等领域，然而奇怪的是它并未被OpenCv实现。提出SIFT角点的David Lowe教授已经用C和matlab实现了SIFT角点的检测，并开放了源代码，不过他的实现不方便直接使用。您可以在http://www.cs.ubc.ca/~lowe/keypoints/看到SIFT的介绍、相关论文及David Lowe教授的实现代码。下面我要介绍由Andrea Vedaldi和Brian Fulkerson先生创建的vlfeat开源图像处理库，vlfeat库有C和matlab两种实现，其中包含了SIFT检测。您可以在http://www.vlfeat.org/下载到vlfeat库的代码、文档及可执行文件。
    使用vlfeat检测SIFT角点需要以下步骤：
    （1）用函数vl_sift_new()初始化SIFT过滤器对象，该过滤器对象可以反复用于多幅尺寸相同的图像；
    （2）用函数vl_sift_first_octave()及vl_sift_process_next()遍历缩放空间的每一阶，直到返回VL_ERR_EOF为止；
    （3）对于缩放空间的每一阶，用函数vl_sift_detect()来获取关键点；
    （4）对每个关键点，用函数vl_sift_calc_keypoint_orientations()来获取该点的方向；
    （5）对关键点的每个方向，用函数vl_sift_calc_keypoint_descriptor()来获取该方向的描述；
    （6）使用完之后，用函数vl_sift_delete()来释放资源；
    （7）如果要计算某个自定义关键点的描述，可以使用函数vl_sift_calc_raw_descriptor()。
    直接使用vlfeat中的SIFT角点检测示例代码如下：

通过P/Invoke调用vlfeat函数来进行SIFT检测


    要在.net中使用vlfeat还是不够方便，为此我对vlfeat中的SIFT角点检测部分进行了封装，将相关操作放到了类SiftDetector中。
    使用SiftDetector需要两至三步：
    （1）用构造函数初始化SiftDetector对象；
    （2）用Process方法计算特征；
    （3）视需要调用Dispose方法释放资源，或者等待垃圾回收器来自动释放资源。
    使用SiftDetector的示例代码如下：

通过dotnet封装的SiftDetector类来进行SIFT检测


    对vlfeat库中的SIFT部分封装代码如下所示：

定义SiftDetector类


MSER区域
    OpenCv中的函数cvExtractMSER以及EmguCv中的Image<TColor,TDepth>.ExtractMSER方法实现了MSER区域的检测。由于OpenCv的文档中目前还没有cvExtractMSER这一部分，大家如果要看文档的话，可以先去看EmguCv的文档。
    需要注意的是MSER区域的检测结果是区域中所有的点序列。例如检测到3个区域，其中一个区域是从(0,0)到(2,1)的矩形，那么结果点序列为：(0,0),(1,0),(2,0),(2,1),(1,1),(0,1)。
    MSER区域检测的示例代码如下：

MSER（区域）特征检测

 

各种特征检测方法性能对比
    上面介绍了这么多的特征检测方法，那么它们的性能到底如何呢？因为它们的参数设置对处理时间及结果的影响很大，我们在这里基本都使用默认参数处理同一幅图像。在我机器上的处理结果见下表：

特征 用时（毫秒） 特征数目
Sobel算子 5.99420 n/a
拉普拉斯算子 3.13440 n/a
Canny算子 3.41160 n/a
霍夫线变换 13.70790 10
霍夫圆变换 78.07720 0
Harris角点 9.41750 n/a
ShiTomasi角点 16.98390 18
亚像素级角点 3.63360 18
SURF角点 266.27000 151
Star关键点 14.82800 56
FAST角点 31.29670 159
SIFT角点 287.52310 54
MSER区域 40.62970 2

（图片尺寸：583x301，处理器：AMD ATHLON IIx2 240，内存：DDR3 4G，显卡：GeForce 9500GT，操作系统：Windows 7）

 

感谢您耐心看完本文，希望对您有所帮助。

下一篇文章我们将一起看看如何来跟踪本文讲到的特征点（角点）。

另外，如果需要本文的源代码，请点击这里下载。


图像特征检测笔记（特征检测基本概念，Harris，Shi-Tomasi，SIFT，SURF，ORB，暴力特征匹配，FLANN特征匹配））
yujiex的博客
04-12 1627
文章目录前言一、特征检测基本概念二、哈里斯角点检测（Harris）1.Harris角点基本原理2.Harris角点检测API3.Harris角点检测代码实例：三、Shi-Tomasi角点检测（Shi-Tomasi）1.Shi-Tomasi角点基本原理2.Shi-Tomasi角点检测API3.Shi-Tomasi角点检测代码实例：四、SIFT关键点检测（scale-invariant feature transform）1.SIFT出现的原因2.使用SIFT的步骤3.SIFT检测代码实例：五、计算SIFT描述
OpenCV图像特征提取与检测C++(二)Harris角点检测、Shi-Tomasi 角点检测、亚像素级别角点检测
法兰西流浪者博客
08-16 4854
图像特征类型可以分为三种： 边缘，角点，斑点。 其中，角点是个很特殊的存在，他们在图像中可以轻松定位，因为角点位于两条边缘的交点，代表了两条边缘变化的方向上的点，所以他们是可以精确定位的二维特征，甚至可以达到亚像素精度。 角点定义：如果某一点在任意方向的一个微小变动都会引起灰度很大的变化，则称为角点。 角点通常被定义为两条边的交点，更严格的说，角点的局部邻域应该具有两个不同区域的不同方向的...
06-01 DeepLearning-图像识别
小猿取经
03-03 2525
文章目录深度学习-图像识别人脸定位手工提取特征的图像分类识图认物传统分类系统的特征提取计算机眼中的图像什么是图像特征？卷积运算利用卷积提取图像特征基于神经网络的图像分类传统图像分类系统和深度神经网络深度神经网络的架构卷积层池化层全连接层归一化指数层非线性激活层Sigmoid函数双曲正切函数ReLU函数深度神经网络的训练反向传播算法图像分类应用——人脸识别人脸识别的流程人脸识别应用场景小结 深度学习...
image-feature-detection.rar_image feature_image feature
09-21
本资源“image-feature-detection.rar”包含了一个关于图像特征检测的文档——“image feature detection.docx”，旨在深入探讨这一主题。 图像特征可以被定义为图像中的显著点、线、边缘或者其他有意义的结构，...
精选资源
Image-feature-detection.zip_人脸特征提取_人脸边缘特征_图像 边缘提取_图像特征提取_提取人脸区域
09-23
综上所述，"Image-feature-detection.zip"压缩包中的内容涵盖了人脸特征提取的核心技术，包括人脸边缘特征的检测、图像边缘提取的方法、图像特征的抽象以及人脸区域的定位。这些技术的结合运用，能够有效地提高人脸...
Image-feature-detection.zip资源标题
最新发布
08-06
"Image-feature-detection.zip"压缩包中的内容涵盖了人脸特征提取的核心技术，包括人脸边缘特征的检测、图像边缘提取的方法、图像特征的抽象以及人脸区域的定位。这些技术的结合运用，能够有效地提高人脸识别系统的...
【图像篡改检测1】Learning Rich Features for Image Manipulation Detection
二十二画生
07-25 5435
前言 今天阅读的论文是《Learning Rich Features for Image Manipulation Detection》这可以算是图像篡改检测领域的一部经典之作。 Abstract 首先说明了图像篡改检测不同于显著性检测的一个很重要的区别在于：需要学习到更加丰富的特征 it pays more at- tention to tampering artifacts than to image content, which suggests that richer features need
【python】OpenCV—Feature Detection and Matching
bryant_meng
07-02 1838
在计算机图像处理中，特征检测和匹配是两个至关重要的环节，它们在多个领域如SLAM（即时定位与地图构建）、SFM（结构从运动恢复）、AR（增强现实）、VR（虚拟现实）等中发挥着关键作用。以下是对特征检测和匹配的详细解析：一、特征检测定义与意义特征检测是指使用计算机算法从图像中提取出具有独特性质的特征点，这些特征点能够代表图像中的关键信息，并且通常具有旋转、尺度和光照变化的不变性。这些特性使得特征点在图像的不同位置和角度下都能被准确检测。特征点的性质。
图像特征匹配+任意点自动识别
04-19
图像特征匹配+任意点自动识别，自动识别两幅图片特征，选取一副图中的点，自动匹配下一幅的点
计算机视觉之一：特征检测
weixin_34244102的博客
05-18 1005
计算机视觉之一：特征检测   主要内容： 1、一个例子解释为什么要进行特征检测 2、图像特征 3、点特征检测：Harris角点、MOPS、SIFT 4、边缘检测：一阶微分算子、二阶微分算子、Canny算子   一、为什么要检测特征？ 举一个例子：全景图像拼接，给定两张图像，如何拼接成一张大图？ 步骤一：检测特征点 步骤二：匹配特征点 步骤三：图像适配 二、...
数字图像处理之图像特征检测
Kerke的博客
06-25 994
实验要求 边缘检测 霍夫线变换 霍夫圆变换 算法实现 边缘检测 本代码采用LoG边缘检测算子 算子与图像卷积 寻找零交叉点，即边缘点 霍夫线变换 将彩色图像转化为灰度图，并对灰度图做边缘检测得到二值边缘图 参数空间离散化:对直线方程的参数(r,θ)(r,\theta)(r,θ)离散化，并给出(rmin,rmax)(r_{min},r_{max})(rmin​,rmax​)和(θmin,θmax)(\theta_{min},\theta_{max})(θmin​,θmax​)，划分为有限个等间
08- OpenCV进行图像的特征检测 (OpenCV系列) (机器视觉)
March_A的博客
01-08 2067
推荐Shi-Tomasi角点检测Harris角点检测计算的稳定性和K有关, 不稳定, shi-tomasi是优化版)。三种特征检测算法对比:SIFT 最慢, 准确率最高SURF 速度比SIFT快些, 准确率差些ORB速度最快, 可以实时检测, 准确率最差.两种特征匹配方式:BFMatcherFLANN(处理大数据集时效果较好)暴力特征匹配单应性矩阵的应用, 查找对应图形:(图像查找)直接读取为灰度图Harris角点检测shi-tomasi角点检测坐标画点cv2.circle。
图像处理【特征点检测】
技术学习
08-09 268
头文件 #include <opencv2/features2d.hpp> opencv类型 FastFeatureDetector SurfFeatureDetector SiftFeatureDetector GFTTDetector FAST
CV中的特征检测--feature detection
kongbai00000的博客
12-12 808
Feature detection
OpenCv-Python图像特征识别
JJSXBL的博客
10-12 8573
OpenCv-Python关于图像特征识别的一些算法，进行了角点识别 Corner Detection，特征匹配Matcher，并应用在拼图程序中。
图片特征提取 | 图像识别
weixin_34203426的博客
04-08 2171
  HOG特征 HOG特征是特别适合于做图像中的人体检测的。看一看原版英文论文：Histograms of Oriented Gradients for Human Detection （引用数2w）YouTube上有作者自己的讲解 参见：目标检测的图像特征提取之（一）HOG特征  ...
【opencv学习】图像特征检测
qq_29367075的博客
02-20 3754
import cv2 import numpy as np import matplotlib.pyplot as plt # 什么是特征？ # 当你看到芒果图像时，如何识别它是芒果？ # 通过分析颜色、形状和质地，你可以说它是芒果。 # 用于识别图像的线索称为图像的特征。同样，计算机视觉的功能是检测图像中的各种特征。 # 1：特征的定义： # 我们将图像中的某个特别的区域作为一个特征。特征是图像中有意义的图像区域，该区域具有独特特性或易于识别性。 # 角点和高密度区域是很好的特征，而大量重复的区域
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值