OpenCV-------阈值化操作-cv::threshold()与cv::adaptiveThreshold()详解

左手的ㄟ右手 2022-05-14 01:37 229阅读 0赞

# 文章来源：　[点击打开链接][Link 1] #

阈值化操作在图像处理中是一种常用的算法，比如图像的二值化就是一种最常见的一种阈值化操作。opencv2和opencv3中提供了直接阈值化操作cv::threshold()和自适应阈值化操作cv::adaptiveThreshold()两种阈值化操作接口，这里将对这两个接口进行介绍和对比。

**1、直接阈值化——cv::threshold()**

阈值化操作的基本思想是，给定一个输入数组和一个阈值，数组中的每个元素将根据其与阈值之间的大小发生相应的改变。opencv3中支持这一操作的接口是cv::threshold()，具体调用方法如下：

double cv::threshold(
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
              cv::InputArray src, 
          
           // 输入图像
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
              cv::OutputArray dst, 
          
           // 输出图像
         
          
        
         
        
        
         
         
          
        
         
        
         
         
             
          
           double thresh, 
          
           // 阈值
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
          
           double maxValue, 
          
           // 向上最大值
         
          
        
         
        
        
         
         
          
        
         
        
         
         
              
          
           int thresholdType 
          
           // 阈值化操作的类型 
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          );

如下表所示，每一种阈值化操作类型，对应着一种源图像上每一个像素点与阈值thresh之间比较操作。根据源图像像素和阈值之间的大小关系，目标像素可能被置为0、原像素值、或者设定的最大值maxValue。

![Center][]

下图将会帮助大家理解不同的阈值化类型所表示的确切含义。

![Center 1][]

void test_threshold()
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          {
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
              cv::Mat src = cv::imread(
          
           "lena.jpg", cv::IMREAD_GRAYSCALE);
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
           cv::Mat dst;
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
          
           double thresh = 
          
           100;
         
          
        
         
        
        
         
         
          
        
         
        
         
         
            
          
           int maxVal = 
          
           255;
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
           cv::threshold(src, dst, thresh, maxVal, cv::THRESH_BINARY);
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
           cv::imshow(
          
           "threshold", dst);
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
            cv::waitKey(
          
           0);
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
         
          
        
         
        
        
         
         
          
        
         
        
         
         
             
          
           return;
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          }

实用上面的代码进行阈值化处理，原图和五种不同方式阈值化的结果分别如下：

![Center 2][] ![Center 3][] ![Center 4][] ![Center 5][] ![Center 6][] ![Center 7][]

另外，在opencv3中cv::threshold()函数还支持一种特殊的阈值化操作方式，即Otsu算法。该算法的主要思想是，在进行阈值化时，考虑所有可能的阈值，分别计算低于阈值和高于阈值像素的方差，使下式最小化的值作为阈值：

![Center 8][]

其中，两类像素方差的权值由两类像素的个数决定。这种阈值化的结果相对来说比较理想，可以避免寻找合适阈值的操作，但是这种方式运算量较大，费时。处理的结果如下：

![Center 9][]

但是，直接阈值化操作是一种一刀切的方式，对于亮度分布差异较大的图像，常常无法找到一个合适的阈值。如下所示，对棋盘格进行二值化操作，由于图像右上角区域和图像下部的亮度差异较为大，无法找到一个合适的阈值，将棋盘上的所有棋盘格给区分开来。

![Center 10][]

![Center 11][] ![Center 12][]

针对于上述情况，我们需要一种改进的阈值化算法，即自适应阈值化。

**2、自适应阈值化——cv::adaptiveThreshold()**

自适应阈值化能够根据图像不同区域亮度分布的，改变阈值，具体调用方法如下：

void cv::adaptiveThreshold(
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
            cv::InputArray src, 
          
           // 输入图像
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
              cv::OutputArray dst, 
          
           // 输出图像
         
          
        
         
        
        
         
         
          
        
         
        
         
         
             
          
           double maxValue, 
          
           // 向上最大值
         
          
        
         
        
        
         
         
          
        
         
        
         
         
              
          
           int adaptiveMethod, 
          
           // 自适应方法，平均或高斯
         
          
        
         
        
        
         
         
          
        
         
        
         
         
             
          
           int thresholdType 
          
           // 阈值化类型
         
          
        
         
        
        
         
         
          
        
         
        
         
         
             
          
           int blockSize, 
          
           // 块大小
         
          
        
         
        
        
         
         
          
        
         
        
         
         
              
          
           double C 
          
           // 常量
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          );

cv::adaptiveThreshold()支持两种自适应方法，即cv::ADAPTIVE\_THRESH\_MEAN\_C（平均）和cv::ADAPTIVE\_THRESH\_GAUSSIAN\_C（高斯）。在两种情况下，自适应阈值T(x, y)。通过计算每个像素周围bxb大小像素块的加权均值并减去常量C得到。其中，b由blockSize给出，大小必须为奇数；如果使用平均的方法，则所有像素周围的权值相同；如果使用高斯的方法，则（x,y）周围的像素的权值则根据其到中心点的距离通过高斯方程得到。

测试代码如下：

void test_adaptive_threshold()
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          {
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
             cv::Mat src = cv::imread(
          
           "chessboard.png", cv::IMREAD_GRAYSCALE);
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
             cv::Mat dst;
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
          
           int maxVal = 
          
           255;
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
          
           int blockSize = 
          
           41;
         
          
        
         
        
        
         
         
          
        
         
        
         
         
             
          
           double C = 
          
           0;
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
           cv::adaptiveThreshold(src, dst, maxVal, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, blockSize, C);
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
            cv::imshow(
          
           "threshold", dst);
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
            cv::waitKey(
          
           0);
         
          
        
         
        
        
         
         
          
        
         
        
         
         
           
         
          
        
         
        
        
         
         
          
        
         
        
         
         
             
          
           return;
         
          
        
         
        
        
         
         
          
        
         
        
         
         
          
           
          }

我们分别使用了平均和高斯两种自适应方法，结果如下：

![Center 13][] ![Center 14][]

2017.03.29

[Link 1]: https://blog.csdn.net/guduruyu/article/details/68059450
[Center]: /images/20220514/8c6009d41f354f0ca9f376174db6214a.png
[Center 1]: /images/20220514/18b7af6b75704a46b5b3290f3d31f096.png
[Center 2]: https://img-blog.csdn.net/20170329104047852?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZ3VkdXJ1eXU=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 3]: https://img-blog.csdn.net/20170329104946178?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZ3VkdXJ1eXU=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 4]: https://img-blog.csdn.net/20170329105006619?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZ3VkdXJ1eXU=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 5]: https://img-blog.csdn.net/20170329105022913?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZ3VkdXJ1eXU=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 6]: https://img-blog.csdn.net/20170329105037804?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZ3VkdXJ1eXU=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 7]: /images/20220514/539767930f7e4f77956abc0c1c0d8583.png
[Center 8]: /images/20220514/6d3717ddc8c34075a97275316fed0cfc.png
[Center 9]: /images/20220514/10836d0ee82845b7a113c824df4d2189.png
[Center 10]: /images/20220514/6e8449ce9023430cb89bbee03746f85e.png
[Center 11]: https://img-blog.csdn.net/20170329112136556?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZ3VkdXJ1eXU=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 12]: /images/20220514/825cd0c0646d49ee8c51a0d06f9e1eb0.png
[Center 13]: https://img-blog.csdn.net/20170329115527629?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZ3VkdXJ1eXU=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 14]: /images/20220514/925e373fb7f94882aa5545b34ebbb04a.png