【6】python-opencv3教程：阈值分割（全阈值分割，局部阈值分割，直方图技术法，熵算法，自适应算法，Otsu算法）

墨蓝 2022-03-16 08:08 588阅读 0赞

# 第六节：阈值分割 #

### **一： 全阈值分割** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70][]

实例代码：

image = cv2.imread('img.jpg', cv2.IMREAD_GRAYSCALE)
    the = 100   # 设置阈值为100
    maxval = 255
    dst, img = cv2.threshold(image, the, maxval, cv2.THRESH_BINARY)
    cv2.imshow('hand_thresh', img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

给出你的阈值 ，然后告诉你的最大阈值是多少 。。。也就是你二值图中一个阈值为0，另外一个阈值可以指定为多少。。这里指定为255

看一下输出结果。。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 1][]

### **二：局部阈值分割** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 2][]

局部阈值分割的核心是计算阈值矩阵。。比较常用的是后面提到的自适应阈值算法。。我们等会后面讲实现。。

### **三：直方图技术法** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 5][]

代码实现：

import numpy as np
    import cv2
    
    
    def calcGrayHist(image):
        '''
        统计像素值
        :param image:
        :return:
        '''
        # 灰度图像的高，宽
        rows, cols = image.shape
        # 存储灰度直方图
        grayHist = np.zeros([256], np.uint64)
        for r in range(rows):
            for c in range(cols):
                grayHist[image[r][c]] += 1
        return grayHist
    
    def threshTwoPeaks(image):
        # 计算灰度直方图
        histogram = calcGrayHist(image)
    
        # 找到灰度直方图的最大峰值对应的灰度值
        maxLoc = np.where(histogram == np.max(histogram))
        firstPeak = maxLoc[0][0]
    
        # 寻找灰度直方图的第二个峰值对应的灰度值
        measureDists = np.zeros([256], np.float32)
        for k in range(256):
            measureDists[k] = pow(k - firstPeak, 2)*histogram[k]
        maxLoc2 = np.where(measureDists == np.max(measureDists))
        secondPeak = maxLoc2[0][0]
    
        # 找两个峰值之间的最小值对应的灰度值，作为阈值
        thresh = 0
        if firstPeak > secondPeak:
            temp = histogram[int(secondPeak): int(firstPeak)]
            minLoc = np.where(temp == np.min(temp))
            thresh = secondPeak + minLoc[0][0] + 1
        else:
            temp = histogram[int(firstPeak): int(secondPeak)]
            minLoc = np.where(temp == np.min(temp))
            thresh = firstPeak + minLoc[0][0] + 1
    
        # 找到阈值，我们进行处理
        img = image.copy()
        img[img > thresh] = 255
        img[img <= thresh] = 0
        cv2.imshow('deal_image', img)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
    
    if __name__ == '__main__':
    
        image = cv2.imread('img.jpg', cv2.IMREAD_GRAYSCALE)
        threshTwoPeaks(image)

输出结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 6][]

### **四：熵算法** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 8][]

![20190227090458307.png][]

代码实现：

import numpy as np
    import cv2
    import math
    
    def calcGrayHist(image):
        '''
        统计像素值
        :param image:
        :return:
        '''
        # 灰度图像的高，宽
        rows, cols = image.shape
        # 存储灰度直方图
        grayHist = np.zeros([256], np.uint64)
        for r in range(rows):
            for c in range(cols):
                grayHist[image[r][c]] += 1
        return grayHist
    
    
    def threshEntroy(image):
    
        rows, cols = image.shape
        # 求灰度直方图
        grayHist = calcGrayHist(image)
        # 归一化灰度直方图，即概率直方图
        normGrayHist = grayHist / float(rows*cols)
    
        # 第一步:计算累加直方图，也称零阶累积矩
        zeroCumuMoment = np.zeros([256], np.float32)
        for k in range(256):
            if k == 0:
                zeroCumuMoment[k] = normGrayHist[k]
            else:
                zeroCumuMoment[k] = zeroCumuMoment[k-1] + normGrayHist[k]
    
        # 第二步:计算各个灰度级的熵
        entropy = np.zeros([256], np.float32)
        for k in range(256):
            if k == 0:
                if normGrayHist[k] == 0:
                    entropy[k] = 0
                else:
                    entropy[k] = -normGrayHist[k]*math.log10(normGrayHist[k])
            else:
                if normGrayHist[k] == 0:
                    entropy[k] = entropy[k-1]
                else:
                    entropy[k] = entropy[k-1] - normGrayHist[k]*math.log10(normGrayHist[k])
        # 第三步:找阈值
        fT = np.zeros([256], np.float32)
        ft1, ft2 = 0.0, 0.0
        totalEntropy = entropy[255]
        for k in range(255):
            # 找最大值
            maxFront = np.max(normGrayHist[0: k+1])
            maxBack = np.max(normGrayHist[k+1: 256])
            if (maxFront == 0 or zeroCumuMoment[k] == 0
                    or maxFront == 1 or zeroCumuMoment[k] == 1 or totalEntropy == 0):
                ft1 = 0
            else:
                ft1 = entropy[k] / totalEntropy*(math.log10(zeroCumuMoment[k])/math.log10(maxFront))
    
    
            if (maxBack == 0 or 1-zeroCumuMoment[k] == 0
                    or maxBack == 1 or 1-zeroCumuMoment[k] == 1):
                ft2 = 0
            else:
                if totalEntropy == 0:
                    ft2 = (math.log10(1-zeroCumuMoment[k]) / math.log10(maxBack))
                else:
                    ft2 = (1-entropy[k]/totalEntropy)*(math.log10(1-zeroCumuMoment[k])/math.log10(maxBack))
            fT[k] = ft1 + ft2
    
        # 找最大值的索引，作为得到的阈值
        threshLoc = np.where(fT == np.max(fT))
        thresh = threshLoc[0][0]
    
        # 阈值处理
        threshold = np.copy(image)
        threshold[threshold > thresh] = 255
        threshold[threshold <= thresh] = 0
        return threshold
    
    if __name__ == '__main__':
        image = cv2.imread('img5.jpg', cv2.IMREAD_GRAYSCALE)
        img = threshEntroy(image)
        cv2.imshow('origin', image)
        cv2.imshow('deal_image', img)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

输出结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 9][]

### **五：Otsu算法** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 10][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 11][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 12][]

这里就不具体实现了。。我们调用opencv给的API

image = cv2.imread('img.jpg', cv2.IMREAD_GRAYSCALE)
    maxval = 255
    otsuThe = 0
    otsuThe, dst_Otsu = cv2.threshold(image, otsuThe, maxval, cv2.THRESH_OTSU)
    cv2.imshow('Otsu', dst_Otsu)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

输出结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 13][]

### ** 六：自适应阈值算法** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 14][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 15][]

![20190227091439517.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 16][]

代码实现：

import cv2
    import numpy as np
    
    def adaptiveThresh(I, winSize, ratio=0.15):
    
        # 第一步:对图像矩阵进行均值平滑
        I_mean = cv2.boxFilter(I, cv2.CV_32FC1, winSize)
    
        # 第二步:原图像矩阵与平滑结果做差
        out = I - (1.0 - ratio) * I_mean
    
        # 第三步:当差值大于或等于0时，输出值为255；反之，输出值为0
        out[out >= 0] = 255
        out[out < 0] = 0
        out = out.astype(np.uint8)
        return out
    
    if __name__ == '__main__':
        
        image = cv2.imread('img7.jpg', cv2.IMREAD_GRAYSCALE)
        img = adaptiveThresh(image, (5, 5))
        cv2.imshow('origin', image)
        cv2.imshow('deal_image', img)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

结果展示：  
  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 17][]

## ##

###       未完待续。。。。。。 ###

###                                       下节你将能够学到一些形态学处理（腐蚀，膨胀等等） ###

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70]: /images/20220316/fe7282c78bc04a5ea6f68282dac955af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 1]: /images/20220316/bcead7a98963432c9c2dbd0117d6ece9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 2]: /images/20220316/60574f697c8d4a2ebcb32b60c956ae1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 3]: /images/20220316/98700fcf7e304a0f8c761bb20dda246d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 4]: /images/20220316/276242847e1841018ec658f36d99ffec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 5]: /images/20220316/ca97806705db42d3b61349e424d76a01.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 6]: /images/20220316/e5279924e8df4d75af33c8b4466aa0a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 7]: /images/20220316/04d49ea4b8064c759e03e9fae0cee2a6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 8]: /images/20220316/1a57aa05e6cc498b89101c64fba7f097.png
[20190227090458307.png]: /images/20220316/4e62a0bee6444804a2d33f36a7333290.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 9]: /images/20220316/781405018caa46819f17cbbc57898d45.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 10]: /images/20220316/38bf366f7e0b42b6becf0c6c6c9b214d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 11]: /images/20220316/6296910bea874b5e9b2be6231448a5f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 12]: /images/20220316/fd74d942c4604aafb7a757f82643a1f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 13]: /images/20220316/0b8fab0529a34ad38e5d67326f8111ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 14]: /images/20220316/51143b87d3fa4036b0ea7d6f706f3c2b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 15]: /images/20220316/fa481cc8b3474efb8d55370d63f231a5.png
[20190227091439517.png]: /images/20220316/8b27334986d64666a421ba268eb6b52e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 16]: /images/20220316/577c5d75be254fefa19368a294afacf8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NoYXdyb2FkODg_size_16_color_FFFFFF_t_70 17]: /images/20220316/2e6e9d068ca64d54a41f43be013c49f8.png