【论文复现】均值滤波改进：Adaptive Weighted Mean Filter（AWMF）

Adaptive Weighted Mean Filter (AWMF)

$$y_{i,j}=\{\begin{array}{rll}{s}_{min},& \text{ with probability }& p椒噪声\\ s_{\max },& \text{ with probability }& q盐噪声\\ x_{i,j},& \text{ with probability }& 1-p-q\end{array}$$
滤波器$S_{ij}(w)$：表示以$i,j$为中心的的$(2w+1)\times (2w+1)$的模板。我们使用$S_{i,j}^{min}$，$S_{i,j}^{med}$，$S_{i,j}^{max}$表示模板内的最小值，中值以及最大值。

AMF算法：
对于噪声图像$y$和重建图像$z$的每个像素：
（1）初始化$w=1,h=1,w_{max}=39$
（2）计算$S_{i,j}^{\min }(w),S_{i,j}^{med}(w)$和$S_{i,j}^{\max }(w)$
（3）如果$S_{i,j}^{\min }(w)<S_{i,j}^{med}(w)<S_{i,j}^{\max }(w)$，跳到步骤（5）
（4）如果$w<w_{max}$，跳到步骤（2），否则$z_{i,j}=S_{ij}^{med}并停止$
（5）如果$S_{i,j}^{min}(w)<y_{i,j}<S_{i,j}^{max}$，即$(i,j)$为非噪声点，则令$z_{i,j}=y_{i,j}$；否则令$z_{i,j}=S_{i,j}^{med}(w)$并停止

AWMF：
对于噪声图像$y$和重建图像$z$的每个像素：
（1）初始化$w=1,h=1,w_{max}=39$
（2）计算$S_{i,j}^{\min }(w),S_{i,j}^{mean}(w)$,$S_{i,j}^{\max }(w)，S_{i,j}^{min}(w+h)，S_{i,j}^{max}(w+h)$
（3）如果$S_{i,j}^{min}(w)=S_{i,j}^{min}(w+h),S_{i,j}^{max}(w)=S_{i,j}^{max}(w+h)$且$S_{i,j}^{mean}(w)\ne -1$，跳到步骤（5）否则$w=w+h$
（4）如果$w\le w_{max}$，跳到步骤（2），否则$z_{i,j}=S_{ij}^{mean}并停止$
（5）如果$S_{i,j}^{min}(w)<y_{i,j}<S_{i,j}^{max}$，即$(i,j)$为非噪声点，则令$z_{i,j}=y_{i,j}$；否则令$z_{i,j}=S_{i,j}^{mean}(w)$并停止

其中：

权重$a_{k,l}$设置为：
$$a_{k,l}=\{\begin{array}{cc}1,& S_{i,j}^{min}(w)<y_{k,l}<S_{i,j}^{max}(w)\\ 0.& \text{ otherwise }\end{array}$$
让我们来解释一下AWMF的细节。

我们首先通过连续扩大窗口尺寸直到两个连续窗口内的最大值和最小值分别相等。如果第一个窗口中心的像素值等于最大值或最小值，则认为它是噪声点，否则为非像素点。通过这种方式可以很大程度减少检测错误，特别是图像信噪比很低的时候。

如图1所示，对于像素值为66的非噪声点。AWMF将检测为非噪声点，输出66；而AMF将检测为噪声点，输出78。.

采用非噪声点的均值替代噪声点而不是普通中值滤波的原因：
（1）排除了噪声点的影响。

（2）经过实验，前者比后者更好。

# -*- coding:utf-8 -*-
'''
@paper:A New Adaptive Weighted Mean Filter for Removing Salt-and-Pepper Noise
'''
import numpy as np

# Adaptive Weighted Mean Filter
class Awmf(object):
    def __init__(self, h, w_max):
        self.h = h
        self.w_max = w_max

    def t_zero_pad_matrix(self, A, t):
        '''在图像四周填充t层0'''
        m, n = np.shape(A)
        img_pad = np.zeros((m + t, n + t))
        img_pad[t:, t:] = A
        return img_pad

    def k_approximate_matrix(self, img_pad, i, j, k, t):
        k_approximate_mat = img_pad[(i + t - k):(i + t + k + 1), (j + t - k):(j + t + k + 1)]
        return k_approximate_mat

    def row_matrix(self, img_k_approximate):
        H = img_k_approximate.flatten()
        H = np.sort(H)
        return H

    def amf(self, img):
        '''Adaptive Mean Filter'''
        m, n = np.shape(img)
        z = img.copy()
        img_pad = self.t_zero_pad_matrix(img, self.w_max)
        for i in range(m):
            for j in range(n):
                w = 1
                while w <= self.w_max:
                    k_approximate_mat = self.k_approximate_matrix(img_pad, i, j, k=w, t=self.w_max)
                    median_value = np.median(k_approximate_mat)
                    max_value = np.max(k_approximate_mat)
                    min_value = np.min(k_approximate_mat)
                    if min_value < median_value < max_value:
                        if min_value < img[i, j] < max_value:
                            z[i, j] = img[i, j]
                            break
                        else:
                            z[i, j] = median_value
                            break
                    else:
                        w = w + self.h
                        if w > self.w_max:
                            z[i, j] = median_value
        return z

    def mean_awmf(self, Y, max_value, min_value):
        m, n = np.shape(Y)
        A = np.zeros(np.shape(Y))
        for k in range(m):
            for l in range(n):
                if min_value < Y[k, l] < max_value:
                    A[k, l] = 1
        if np.sum(A) != 0:
            mean_value = np.sum(A * Y) / np.sum(A)
        else:
            mean_value = -1
        return mean_value

    def process_image(self, img):
        m, n = np.shape(img)
        z = img.copy()
        img_pad = self.t_zero_pad_matrix(img, self.w_max)
        for i in range(m):
            for j in range(n):
                w = 1
                while w <= self.w_max:
                    k_approximate_mat1 = self.k_approximate_matrix(img_pad, i, j, k=w, t=self.w_max)
                    k_approximate_mat2 = self.k_approximate_matrix(img_pad, i, j, k=w + self.h, t=self.w_max)
                    max_value1 = np.max(k_approximate_mat1)
                    min_value1 = np.min(k_approximate_mat1)
                    mean_value1 = self.mean_awmf(k_approximate_mat1, max_value1, min_value1)
                    max_value2 = np.max(k_approximate_mat2)
                    min_value2 = np.min(k_approximate_mat2)
                    if min_value1 == min_value2 and max_value1 == max_value2 and mean_value1 != -1:
                        if min_value1 < img[i, j] < max_value1:
                            z[i, j] = img[i, j]
                            break
                        else:
                            z[i, j] = mean_value1
                            break
                    else:
                        w = w + self.h
                        if w > self.w_max:
                            z[i, j] = mean_value1
        return z

Noise level	Noise image	AWMF
90%
95%
99%