框模糊算法 - 使用Python实现

图像中的像素表示为整数。模糊后得到的图像的每个像素“x”的值等于“x”周围像素的平均值，包括“x”。例如，将 3 * 3 图像视为

$image = \begin{bmatrix} 1 & 1 & 1\\ 1 & 7 & 1\\ 1 & 1 & 1 \end{bmatrix}$
那么，模糊后得到的图像就是blurred_image = $\begin{bmatrix} 1 \end{bmatrix}$
因此，模糊图像的像素计算为 (1 + 1 + 1 + 1 + 7 + 1 + 1 + 1 + 1) / 9 = 1.66666 = 1

框模糊算法 –

框模糊也称为框线性过滤器。框模糊经常用于近似高斯模糊。

框模糊通常实现为影响整个屏幕的图像效果。当前像素的模糊颜色是当前像素的颜色与其相邻的 8 个像素的平均值。

Note: For each 3 * 3 pixel matrix there is one blurred pixel calculated as above.

例如，考虑下图。
$image = \begin{bmatrix} 7 & 4 & 0 & 1\\ 5 & 6 & 2 & 2\\ 6 & 10 & 7 & 8\\ 1 & 4 & 2 & 0 \end{bmatrix}$
它的模糊图像如下：
$blurred\_image = \begin{bmatrix} 5 & 4\\ 4 & 4 \end{bmatrix}$

解释：
上图中可能有四个 3 * 3 矩阵。所以生成的图像中有 4 个模糊像素。这四个矩阵是：

$\begin{bmatrix} 7 & 4 & 0\\ 5 & 6 & 2\\ 6 & 10 & 7 \end{bmatrix}$ , $\begin{bmatrix} 4 & 0 & 1\\ 6 & 2 & 2\\ 10 & 7 & 8 \end{bmatrix}$ , $\begin{bmatrix} 5 & 6 & 2\\ 6 & 10 & 7\\ 1 & 4 & 2 \end{bmatrix}$ ， 和$\begin{bmatrix} 6 & 2 & 2\\ 10 & 7 & 8\\ 4 & 2 & 0 \end{bmatrix}$

在Python中的实现：

def square_matrix(square):
    """ This function will calculate the value x 
       (i.e. blurred pixel value) for each 3 * 3 blur image.
    """
    tot_sum = 0
      
    # Calculate sum of all the pixels in 3 * 3 matrix
    for i in range(3):
        for j in range(3):
            tot_sum += square[i][j]
              
    return tot_sum // 9     # return the average of the sum of pixels
  
def boxBlur(image):
    """
    This function will calculate the blurred 
    image for given n * n image. 
    """
    square = []     # This will store the 3 * 3 matrix 
                 # which will be used to find its blurred pixel
                   
    square_row = [] # This will store one row of a 3 * 3 matrix and 
                    # will be appended in square
                      
    blur_row = []   # Here we will store the resulting blurred
                    # pixels possible in one row 
                    # and will append this in the blur_img
      
    blur_img = [] # This is the resulting blurred image
      
    # number of rows in the given image
    n_rows = len(image) 
      
    # number of columns in the given image
    n_col = len(image[0]) 
      
    # rp is row pointer and cp is column pointer
    rp, cp = 0, 0 
      
    # This while loop will be used to 
    # calculate all the blurred pixel in the first row 
    while rp <= n_rows - 3: 
        while cp <= n_col-3:
              
            for i in range(rp, rp + 3):
                  
                for j in range(cp, cp + 3):
                      
                    # append all the pixels in a row of 3 * 3 matrix
                    square_row.append(image[i][j])
                      
                # append the row in the square i.e. 3 * 3 matrix 
                square.append(square_row)
                square_row = []
              
            # calculate the blurred pixel for given 3 * 3 matrix 
            # i.e. square and append it in blur_row
            blur_row.append(square_matrix(square))
            square = []
              
            # increase the column pointer
            cp = cp + 1
          
        # append the blur_row in blur_image
        blur_img.append(blur_row)
        blur_row = []
        rp = rp + 1 # increase row pointer
        cp = 0 # start column pointer from 0 again
      
    # Return the resulting pixel matrix
    return blur_img
  
# Driver code
image = [[7, 4, 0, 1], 
        [5, 6, 2, 2], 
        [6, 10, 7, 8], 
        [1, 4, 2, 0]]
          
print(boxBlur(image))

输出：

[[5, 4], 
[4, 4]]

测试用例 2：

image = [[36, 0, 18, 9], 
         [27, 54, 9, 0], 
         [81, 63, 72, 45]]
  
print(boxBlur(image))

输出：

[[40, 30]]

进一步阅读：使用 PIL 库的 Box Blur | Python