1. 介绍

当目标和背景像素的灰度分布非常不同的时候，可以对整个图像使用全局阈值

在大多数的应用中，图像之间通常存在足够的变化，全局阈值是一种合适的办法。所以，需要一种对图像做阈值估计的算法。为了获取合适的阈值，可以利用直方图进行迭代计算：

算法步骤如下：

随机设置一个阈值的初始值 T
用 T 分割图像，这将会产生两个像素区域。一个是灰度值 <= T 所有像素组成的子区域 G1，一个是灰度值 >T 所有像素组成的子区域 G2
对G1、G2 两个子区域分别计算平均灰度值m1、m2
利用m1、m2得到新的阈值：T = （m1 + m2）/ 2
重复2-4，直到两个阈值T的差值小于某个预设定的值ΔT为止

当目标和背景之间存在一个非常清晰的波谷的时候，上述的算法很有效，

一般来说，初始的阈值T设定为整幅图像的平均灰度值

2. 代码实现

完整代码：


  
   
    
     
    
    
     
      import cv2
     
    
   
    
     
    
    
     
      import numpy 
      as np
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      def 
      global_threshold_processing(
      x):   
      # x 为传入的图像
     
    
   
    
     
    
    
     
          hist = cv2.calcHist([x], [
      0], 
      None, [
      256], [
      0, 
      256])  
      # 图像的灰度直方图 shape = (256,1)
     
    
   
    
     
    
    
     
          grayScale = np.arange(
      256).reshape(
      1, -
      1)             
      # 灰度级 [0,255] shape =(1,256)
     
    
   
    
     
    
    
     
          sum_pixels = x.shape[
      0] * x.shape[
      1]                  
      # 图像总共像素点的个数
     
    
   
    
     
    
    
     
          sum_gray = np.dot(grayScale, hist)                    
      # 每个灰度值像素的个数 * 对应灰度值 = 所有的像素灰度值的和
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
          T = np.around(sum_gray / sum_pixels).astype(np.uint).item()         
      # 初始阈值T，设定为整幅图像的平均灰度值
     
    
   
    
     
    
    
     
          theta = 
      1
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      while 
      True:         
      # 迭代算法
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              gray_c1 = grayScale[:, :T + 
      1]                     
      # 灰度值 <= T 的子区域 G1 的灰度级 (0,T)
     
    
   
    
     
    
    
     
              hist_c1 = hist[:T + 
      1, :]                          
      # 子区域G1 的直方图 (0,T),对应每个灰度值的像素点
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              sum_gray_G1 = np.dot(gray_c1, hist_c1)             
      # G1 区域所有像素点灰度值总和 = (0,T)的灰度值 * 对应像素点的个数
     
    
   
    
     
    
    
     
              sum_pixels_G1 = np.
      sum(hist_c1)                    
      # G1 区域所有像素点的个数
     
    
   
    
     
    
    
     
              m1 = sum_gray_G1 / sum_pixels_G1                   
      # G1 区域平均灰度值
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              sum_pixels_G2 = sum_pixels - sum_pixels_G1         
      # G2 区域所有像素点的个数 ： 所有像素点 - G1 区域像素点个数
     
    
   
    
     
    
    
     
              sum_gray_G2 = sum_gray - sum_gray_G1               
      # G2 区域所有像素点的灰度值总和 ：所有灰度值 - G1 灰度值
     
    
   
    
     
    
    
     
              m2 = sum_gray_G2 / sum_pixels_G2                   
      # G2 区域平均灰度值
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              T_new = np.around((m1 + m2) / 
      2).astype(np.uint).item()  
      # 计算新的阈值
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
             
      if 
      abs(T - T_new) < theta:
     
    
   
    
     
    
    
     
                  T = T_new
     
    
   
    
     
    
    
                 
      break
     
    
   
    
     
    
    
             
      else:
     
    
   
    
     
    
    
     
                  T = T_new
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
          x[x >= T] = 
      255         
      # 阈值处理
     
    
   
    
     
    
    
     
          x[x < T] = 
      0
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      return T,x
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      img = cv2.imread(
      "img.png",
      0)
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      ret,dst = global_threshold_processing(img.copy())
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      print(ret)
     
    
   
    
     
    
    
     
      cv2.imshow(
      'img',np.hstack((img,dst)))
     
    
   
    
     
    
    
     
      cv2.waitKey(
      0)
     
    
   
    
     
    
    
     
      cv2.destroyAllWindows()