1. 什么是图像的二值化

  将图像上的[像素](https://baike.baidu.com/item/%E5%83%8F%E7%B4%A0/95084)点的[灰度值](https://baike.baidu.com/item/%E7%81%B0%E5%BA%A6%E5%80%BC/10259111)设置为0或255，也就是将整个图像呈现出明显的黑白效果的过程。

  图像的二值化使图像中数据量大为减少，从而能凸显出目标的轮廓。

2. 实现函数- cv2.threshold()、cv2.adaptiveThreshold（）

2.1 全局阈值-cv2.threshold()

• 参数如下:cv2.threshold(src, thresh, maxval, type）
• 参数说明: 1. src 源图像,必须是单通道 2. thresh 分类阈值 3. maxval 高于（低于）阈值时赋予的新值 4. type 阈值处理模式
• 返回值: 1.retval 得到的阈值 2. dst 阈值化后的图像
• 阈值处理模式:cv2.THRESH_BINARY、cv2.THRESH_BINARY_INV、cv2.THRESH_TRUNC、
  cv2.THRESH_TOZERO、cv2.THRESH_TOZERO_INV,具体说明如下:
  - 1. cv2.THRESH—BINARY
  如果像素值大于阈值，像素值就会被设为参数3; 小于等于阈值，设定为0
  - 2. cv2.THRESH_BINARY_INV
  这个是上面一种情况的反转: 如果像素值大于阈值，像素值为0; 小于等于阈值，设定为参数3
  - 3. cv2.THRESH_TRUNC
  如果像素大于阈值，设定为阈值;小于等于阈值，保持原像素值
  - 4. cv2.THRESH_TOZERO
  大于阈值，保持原像素值; 小于等于，设定为0
  - 5. cv2.THRESH_TOZERO_INV
  与上一种相反:大于阈值，设定为0;小于等于，保持原像素值

代码如下:

def threshold_simple(image):
    img = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    ret, thresh1 = cv.threshold(img, 127, 255, cv.THRESH_BINARY)
    ret, thresh2 = cv.threshold(img, 127, 255, cv.THRESH_BINARY_INV)
    ret, thresh3 = cv.threshold(img, 127, 255, cv.THRESH_TRUNC)
    ret, thresh4 = cv.threshold(img, 127, 255, cv.THRESH_TOZERO)
    ret, thresh5 = cv.threshold(img, 127, 255, cv.THRESH_TOZERO_INV)
    titles = ['Original Image', 'BINARY', 'BINARY_INV', 'TRUNC', 'TOZERO', 'TOZERO_INV']
    images = [img, thresh1, thresh2, thresh3, thresh4, thresh5]
 
    for i in range(6):
        plt.subplot(2, 3, i + 1), plt.imshow(images[i], 'gray')  # 将图像按2x3铺开
        plt.title(titles[i])
        plt.xticks([]), plt.yticks([])
 
    plt.show()

2.2 自适应阈值 -cv2.adaptiveThreshold（）

自适应阈值可以看成一种局部性的阈值，通过规定一个区域大小，比较这个点与区域大小里面像素点的平均值（或者其他特征）的大小关系确定这个像素点是属于黑或者白（如果是二值情况）。该函数需要填6个参数：

• 第一个原始图像
• 第二个像素值上限
• 第三个自适应方法Adaptive Method:
• — cv2.ADAPTIVE_THRESH_MEAN_C ：领域内均值
• —cv2.ADAPTIVE_THRESH_GAUSSIAN_C ：领域内像素点加权和，权重为一个高斯窗口
• 第四个值的赋值方法：只有cv2.THRESH_BINARY 和cv2.THRESH_BINARY_INV
• 第五个Block size:规定领域大小（一个正方形的领域），计算邻域时的领邻域大小，必须为奇数;当blockSize越大，参与计算阈值的区域也越大，细节轮廓就变得越少，整体轮廓越粗越明显
• 第六个常数C，阈值等于均值或者加权值减去这个常数,得到的就是最终阈值。当C越大，每个像素点的N*N邻域计算出的阈值就越小，中心点大于这个阈值的可能性也就越大，设置成255的概率就越大，整体图像白色像素就越多，反之亦然。
  这种方法理论上得到的效果更好，相当于在动态自适应的调整属于自己像素点的阈值，而不是整幅图像都用一个阈值。

代码如下:

def threshold_adaptive(image):
    img = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    # 中值滤波
    img = cv.medianBlur(img, 5)
 
    ret, th1 = cv.threshold(img, 127, 255, cv.THRESH_BINARY)
    # 11 为 Block size, 2 为 C 值
    th2 = cv.adaptiveThreshold(img, 255, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY, 11, 2)
    th3 = cv.adaptiveThreshold(img,255,cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv.THRESH_BINARY, 11, 2)
 
    titles = ['Original Image', 'Global Threshold (v = 127)', 'Adaptive Mean Threshold', 'Adaptive Gaussian Threshold']
    images = [img, th1, th2, th3]
 
    for i in range(4):
        plt.subplot(2, 2, i + 1), plt.imshow(images[i], 'gray')
        plt.title(titles[i])
        plt.xticks([]), plt.yticks([])
 
    plt.show()

import cv2
import numpy as np
 
blocksize = 3
C=0
def adaptive_demo(gray, blocksize, C):
    binary = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, blocksize, C)
    # binary = cv2.GaussianBlur(binary, (15,15), 0)
    cv2.imshow('binary', binary)
 
def C_changed(value):
    global gray
    global blocksize
    global C
    C = value - 30
    print('C:', C)
    adaptive_demo(gray, blocksize, C)
 
def blocksize_changed(value):
    global gray
    global blocksize
    global C
    blocksize = 2 * value + 1
 
    print('blocksize:', blocksize)
    adaptive_demo(gray, blocksize, C)
 
if __name__ == "__main__":
    image_path = './img/1.jpg'
    img = cv2.imread(image_path)
 
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
    adaptive_demo(gray, 3, 0)
    cv2.createTrackbar('C', 'binary',0, 60, C_changed)
    cv2.createTrackbar('blocksize', 'binary',1, 20, blocksize_changed)
 
    cv2.waitKey(0)

在使用全局阈值时，随便给了一个数来做阈值，那怎么知道选取的这个数的好坏呢？答案就是不停的尝试。如果是一副双峰图像（简单来说双峰图像是指图像直方图中存在两个峰）呢？我们岂不是应该在两个峰 之间的峰谷选一个值作为阈值？这就是 Otsu 二值化要做的。简单来说就是对 一副双峰图像自动根据其直方图计算出一个阈值。（对于非双峰图像，这种方法得到的结果可能会不理想）。

这里用到到的函数还是 cv2.threshold()，但是需要多传入一个参数 （flag）：cv2.THRESH_OTSU。这时要把阈值设为 0。然后算法会找到最优阈值，这个最优阈值就是返回值 retVal。如果不使用 Otsu 二值化，返回的 retVal 值与设定的阈值相等。

下面的例子中，输入图像是一副带有噪声的图像。第一种方法，设127为全局阈值。第二种方法，我们直接使用 Otsu 二值化。第三种方法，我 们首先使用一个 5x5 的高斯核除去噪音，然后再使用 Otsu 二值化。看看噪音去除对结果的影响有多大。

import cv2
import numpy as np
from matplotlib import pyplot as plt
 
 
img = cv2.imread('F:/OTSnoise.png',0)
#全局阈值
ret1, th1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
#OTS阈值
ret2, th2 = cv2.threshold(img,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
#(5,5)为高斯核的大小，0为标准差
blur = cv2.GaussianBlur(img,(5,5),0)
#阈值一定设为0
ret3, th3 = cv2.threshold(blur, 0, 255, cv2.THRESH_OTSU)
 
images = [img, 0, th1,
          img, 0, th2,
          blur, 0, th3]
 
titles = ['Original Noisy Image','Histogram','Global Thresholding (v=127)',
          'Original Noisy Image','Histogram',"Otsu's Thresholding",
          'Gaussian filtered Image','Histogtam',"Otus's Thresholding"]
 
for i in xrange(3):
    plt.subplot(3,3,i*3+1),plt.imshow(images[i*3],'gray')
    plt.title(titles[i*3]),plt.xticks([]),plt.yticks([])
    plt.subplot(3,3,i*3+2),plt.hist(images[i*3].ravel(),256)#plt.hist是画直方图
    plt.title(titles[i*3+1]),plt.xticks([]),plt.yticks([])
    plt.subplot(3,3,i*3+3),plt.imshow(images[i*3+2],'gray')
    plt.title(titles[i*3+2]),plt.xticks([]),plt.yticks([])
 
plt.show()

image.png

Otsu’s 二值化是如何工作的？

image.png

import cv2
import numpy as np
img = cv2.imread('noisy2.png',0)
blur = cv2.GaussianBlur(img,(5,5),0)
# find normalized_histogram, and its cumulative distribution function
# 计算归一化直方图
#CalcHist(image, accumulate=0, mask=NULL)
hist = cv2.calcHist([blur],[0],None,[256],[0,256])
hist_norm = hist.ravel()/hist.max()
Q = hist_norm.cumsum()
bins = np.arange(256)
fn_min = np.inf
thresh = -1
for i in xrange(1,256):
    p1,p2 = np.hsplit(hist_norm,[i]) # probabilities
    q1,q2 = Q[i],Q[255]-Q[i] # cum sum of classes 
    b1,b2 = np.hsplit(bins,[i]) # weights
    # finding means and variances
    m1,m2 = np.sum(p1*b1)/q1, np.sum(p2*b2)/q2
    v1,v2 = np.sum(((b1-m1)**2)*p1)/q1,np.sum(((b2-m2)**2)*p2)/q2
    # calculates the minimization function
    fn = v1*q1 + v2*q2
    if fn < fn_min:
        fn_min = fn
        thresh = i
# find otsu's threshold value with OpenCV function
ret, otsu = cv2.threshold(blur,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
print thresh,ret