Good Similar Patches for Image Denoising

TL;DR

This paper introduces a Gaussian Mixture Model-based patch clustering method and an unreliable pixel estimation algorithm to improve patch selection in image denoising, enhancing the performance of existing algorithms like BM3D.

Contribution

It proposes a novel patch searching technique using GMM clustering and unreliable pixel estimation to select better patches for denoising, improving existing methods without altering them.

Findings

Enhanced denoising performance with better patch selection.

Consistent improvements across multiple state-of-the-art algorithms.

Better capture of underlying image structures.

Abstract

Patch-based denoising algorithms like BM3D have achieved outstanding performance. An important idea for the success of these methods is to exploit the recurrence of similar patches in an input image to estimate the underlying image structures. However, in these algorithms, the similar patches used for denoising are obtained via Nearest Neighbour Search (NNS) and are sometimes not optimal. First, due to the existence of noise, NNS can select similar patches with similar noise patterns to the reference patch. Second, the unreliable noisy pixels in digital images can bring a bias to the patch searching process and result in a loss of color fidelity in the final denoising result. We observe that given a set of good similar patches, their distribution is not necessarily centered at the noisy reference patch and can be approximated by a Gaussian component. Based on this observation, we present a patch searching method that clusters similar patch candidates into patch groups using Gaussian Mixture Model-based clustering, and selects the patch group that contains the reference patch as the final patches for denoising. We also use an unreliable pixel estimation algorithm to pre-process the input noisy images to further improve the patch searching. Our experiments show that our approach can better capture the underlying patch structures and can consistently enable the state-of-the-art patch-based denoising algorithms, such as BM3D, LPCA and PLOW, to better denoise images by providing them with patches found by our approach while without modifying these algorithms.

Tables

Table 1. Table 1: Average PSNR results of the competing methods

$\sigma$	20	40	60	80	100
BM3D	31.34	27.97	25.71	23.82	22.10
BM3Dbst	31.39	28.11	26.00	24.35	23.08
PLOW	30.34	27.55	25.38	23.51	21.82
PLOWbst	30.46	27.72	25.62	24.10	22.79
LPCA	30.69	26.89	24.31	22.51	21.10
LPCAbas	30.69	26.91	24.36	22.58	21.19
LPCAbst	30.72	27.16	25.18	23.86	22.76
EPLL	31.16	27.83	25.41	23.13	21.12
PGPD	31.38	28.04	25.59	23.63	21.92
PCLR	31.58	28.11	25.46	23.03	20.91
WNNM	31.61	28.12	25.50	23.28	21.37

Table 2. Table 2: Average PSNR results on different levels of Poisson noise

$\kappa$	20	35	50	65	80
BM3D	26.92	25.22	24.03	22.83	21.93
BM3Dbst	27.12	25.65	24.52	23.55	22.31
PLOW	25.35	22.90	22.17	21.79	20.80
PLOWbst	25.48	23.31	22.62	21.98	21.06
LPCA	25.64	23.67	22.59	21.29	20.71
LPCAbas	25.65	23.74	22.52	21.39	20.59
LPCAbst	26.04	24.34	23.19	21.57	21.22

Table 3. Table 3: Average PSNR results of BM3D bst and POD

POD ($\sigma =20/50/75$)	BM3Dbst ($\sigma =20/50/75$)
$31.04/26.70/24.19$	$\text{31.39}/\text{27.03}/\text{24.75}$

Table 4. Table 4: Comparison of clustering methods on BM3D bst

$\sigma$	20	40	60	80	100
K-means++	31.39	28.11	26.00	24.35	23.08
GMM	31.37	28.08	25.95	24.31	23.02
LSC	31.37	28.04	25.91	24.23	22.92

Table 5. Table 5: Average SSIM scores of the competing methods

$\sigma$	20	40	60	80	100
BM3D	.8655	.7867	.7285	.6823	.6401
BM3Dbst	.8664	.7897	.7342	.6889	.6486
EPLL	.8629	.7805	.7124	.6591	.6027
PGPD	.8606	.7863	.7231	.6687	.6219
PCLR	.8668	.7898	.7233	.6563	.5955
WNNM	.8672	.7891	.7238	.6646	.6122

Table 6. Table 6: Comparison on the BSD test images

$\sigma$

20

40

60

80

100

Equations

$$MDL(K,\theta )=-\log p_{{}_Q}(Q|K,\theta )+\lambda L\log (mn),$$

$$-\log p_{{}_Q}(Q|K,\theta )=\sum _{k=1}^K\sum _{j=1}^{m_k}||q_j-{\mu }_k|{|}^2,$$

$$L=K(1+n+(n+1)n/2)-1$$

$$\lambda =\alpha \exp (-\frac{1}{\beta }(\frac{1}{n}\sum _{i=1}^n||\nabla I_i||{)}^2)$$

Full text

1 Introduction

Image capturing has become a daily practice these days and millions of images are taken every day. These images, however, sometimes suffer from noise due to sensor errors. To solve this problem, image denoising has been extensively studied. Numerous image denoising methods [13, 14, 17, 20, 29, 33, 35, 36, 37, 38, 45] have been developed. Recently, patch-based approaches [5, 8, 10, 13, 16, 18, 27, 39, 41] have shown great success. Their key idea is to exploit the recurrence of similar patches in a noisy input image to estimate the underlying patch structure. The quality of the selected similar patches is therefore an important factor that can influence the final denoising result.

Nearest Neighbour Search (NNS), which selects each patch’s nearest neighbours as potential similar patches, is widely used for patch searching due to its simplicity. However, due to the existence of noise, this method can introduce bias to the search results of similar patches. As shown in Figure 1 (a), the reference patch is corrupted by noise (marked in red). NNS thus prefers similar patches that contain the same noise pattern as the reference one. Consequently, the estimated patch is close to the noisy reference rather than the ground truth clean patch (marked in green). This bias can finally retain the noise pattern in the denoised image, as shown in Figure 1 (b).

In this paper, we present a patch searching method to find a set of good similar patches for patch-based denoising algorithms, such as BM3D [14], LPCA [41] and PLOW [10]. We consider that a set of good similar patches should be as similar to the noise-free version of the reference patch as possible rather than the noisy reference patch. Our assumption is that the distribution of these good similar patches can be approximated as a Gaussian function although this distribution is not necessarily centered around the noisy reference patch. This is a popular assumption in image denoising. Based on this assumption, we develop the following patch searching method. We first use Nearest Neighbour Search to obtain a set of candidate similar patches for each reference patch. We then model the distribution of these candidate patches as a mixture of Gaussian components and cluster them into several sub-groups. We finally take the sub-group that contains the reference patch as the set of similar patches for denoising. To further improve the quality of similar patches, we pre-process the input noisy images using an unreliable pixel estimation to eliminate the influence of unreliable pixels.

This paper contributes to the problem of image denoising with a way to find better similar patches for image denoising. This paper shows that the performance of existing patch-based denoising algorithms can be consistently improved by inputting them with a better set of similar patches. Our method has an advantage that no modification needs to be made to these existing denoising algorithms. As shown in Figure 2, our method can enable the state-of-the-art denoising methods like BM3D, LPCA and PLOW to better denoise noisy images. We expect that our method can also be married to other patch-based denoising methods.

2 Related Work

Image denoising aims to recover the underlying clean image $I$ from the corrupted noisy observation $I_{n}$, which can be modeled as $I_{n}=I+N$, where $N$ is the additive noise. The additive noise is often assumed to have a Gaussian distribution with zero mean or a Poisson distribution [2, 7] and thus is usually denoted as White Gaussian noise or Poisson noise. A variety of denoising methods [22, 23, 35] have been developed based on different assumptions, models, priors or constraints.

As image denoising is an ill-posed problem, many methods exploit priors to denoise images [6, 9]. The EPLL algorithm [45] learns Gaussian Mixture Models from external clean patches and iteratively restores the underlying clean image via Expected Patch Log Likelihood (EPLL) maximization. Yue et al. [40] retrieved similar web images to help with image restoration by combining 3D block denoising in both the spatial and frequency domains. Zontak et al. [43] analysed the internal statistics of natural images and exploited internal patch recurrence across scales to restore the underlying image content from the noisy input [44]. Mosseri et al. [30] proposed a combining method to locally select external or internal priors for image denoising. The success of KSVD [1, 17] brought a new trend of image denoising by training dictionaries for patch restoration via sparse representation, including a number of variations and extensions [8, 26].

Based on the assumption that the underlying similar patches lie in a low-dimensional subspace, low-rank constraint-based methods [15, 25, 31] have shown promising performance on image denoising in recent years. Gu et al. [18] considered the patch denoising as a low-rank matrix factorization problem for similar patches and proposed a Weighted Nuclear Norm Minimization (WNNM) process to assign different weights for different singular values.

Similar patch-based methods [5, 8, 10, 13, 16, 18, 27, 39, 41] are among the most popular denoising techniques and have shown great success on image denoising. All these methods exploit the image non-local self-similarity prior—natural image patterns repetitively occur across the whole image. The recent benchmark BM3D algorithm [14] applies collaborative filtering in the transform domain on 3D similar patch blocks to estimate the latent image structures. LPCA [41] performs PCA on similar patch groups and PLOW [10] restores the latent clean image structures using similar patches via an adaptive Wiener filter. However, as demonstrated in Section 1, Nearest Neighbour Search is not optimal for similar patch searching, especially in images with heavy noise. Our approach aims to solve this problem via a clustering-based patch searching approach. Our method modifies both the similar patch locations as well as the input similar patch values for similar patch-based denoising algorithms.

While most patch-based denoising techniques use Nearest Neighbour Search, clustering has already been proved effective for similar patch searching. Chatterjee et al. [10] used LARK [34] features to cluster the noisy image into regions with similar patch patterns. However, in images with heavy noise, LARK feature fails to capture properties of the underlying patches and thus can not provide accurate clustering results. Chen et al. [11] collected external clean patches to train a fixed set of Gaussian Mixture Models and cluster all noisy patches into clusters defined by the models. However, this method independently assigns each patch to a cluster with the maximum likelihood while our method exploits the overall similar patch distributions for clustering. Our method also differs from this method in that 1) our method does not require external clean patches for training, 2) rather than using fixed Gaussian Mixture Models for all input noisy images, our method tries to estimate dedicated Gaussian Mixture Models for each individual similar patch group and thus works better across images with different contents and properties, and 3) our method adaptively estimates the number of clusters via an optimization process while the previous methods used fixed cluster numbers. Thus, our method better exploits individual patch coherence and can recover patch structure details more adequately.

Lotan and Irani provided needle-match [24], an effective patch descriptor for patch searching for applications like denoising. While we share the same goal, our work is actually orthogonal to theirs. They find nearest neighbors as good patches according to their descriptor instead of pixel values while our method finds good patches by selecting a subset from the set of patches, which are currently found using nearest neighbor search based on pixel colors. We expect that combining our searching algorithm together with their powerful descriptor will further help denoising.

3 Good Similar Patch Searching

Most existing patch-based image denoising methods share a common two-step pipeline: first find a set of similar patches for each reference patch and then perform patch group denoising to obtain the denoising result for the reference patch. Our similar patch searching algorithm can be married with a patch-based denoising method by replacing its original similar patch searching algorithm with ours or embedded into the denoising method in-between these two steps, as illustrated in Figure 3. The overall goal of our algorithm is to provide a set of good similar patches to enable better image denoising.

We consider good similar patches for a reference patch should be close to its noise-free version. The widely used Nearest Neighbour Search (NNS) finds a set of similar patches that are closest to the reference. As shown in Figure 4 (a), many of these patches are faraway from the noise-free reference patch (indicated in green). If such a set of patches are used for denoising, the denoised result (indicated in blue) can deviate from the noise-free patch significantly, as illustrated in Figure 4 (b). Our assumption is that the distribution of these good similar patches can be modeled as a Gaussian function approximately around the noise-free reference patch, as illustrated in Figure 4 (d). This is a popular assumption in image denoising. Based on this assumption, we can formulate the problem of good similar patch searching as a Gaussian Mixture Model (GMM)-based clustering and group candidate patches into several clusters. The patches in the cluster containing the reference patch are selected as good similar patches for denoising.

Our algorithm starts by using NNS to find a set of candidate similar patches for each reference patch. While NNS cannot find an optimal set of similar patches, it can filter out most outliers. We then select a set of good similar patches from these candidates. In the rest of this section, we first describe our GMM clustering-based good similar patch searching algorithm, then discuss how to detect unreliable pixels and update them to further improve our method, and finally discuss the complexity of our method.

3.1 Similar Patch Clustering

As shown in Figure 4 (a) and (b), NNS only considers the distance to the noisy reference in selecting similar patches. Outliers that are close to the noisy reference rather than the ground truth clean patch are thus selected as valid similar patch candidates. Ideally, the overall patch distribution should be carefully investigated to find good similar patches. For the example in Figure 4 (c), all the candidate patches from NNS can be roughly clustered into three groups. For the group that contains the reference patch, its center is closer to the ground truth clean patch than to the noisy reference patch, as shown in Figure 4 (d).

We model each patch group as a Gaussian function and then the whole set of candidate patches can be approximated as a Gaussian Mixture Model (GMM). Specifically, given a set of $m$ $n$-dimensional candidate patches $Q=\{q_{i}|_{i=1,...,m}\}$, we aim to estimate a GMM with $K$ components. We denote $\theta=\{\pi_{k},\mu_{k},R_{k}\}_{k={1...K}}$ as the parameters of the GMM, in which $R_{k}$ is the covariance matrix, $\mu_{k}$ is the centroid vector and $\pi_{k}$ is the probability that a given patch comes from the $k$th cluster. We regularize the estimation of the GMM using the Minimum Description Length (MDL) criteria introduced by Rissanen [32] as follows.

[TABLE]

where the first term is a data term that encourages smaller intra-patch distance in each cluster as follows.

[TABLE]

where $m_{k}$ and $\mu_{k}$ are the number of patches in the $k$th cluster and its centroid. The second term is a regularization term that penalizes a large number of clusters. $\lambda$ is a parameter that balances the contribution of the data term and the regularization term. $L$ is the number of parameters required to define $\theta$ and is defined as

[TABLE]

Based on an observation that candidate similar patches with complex structures are more likely to be generated from more clusters, we adaptively compute $\lambda$ according to the average gradient magnitude of the reference patch to prefer large cluster numbers for similar patches with complex structures.

[TABLE]

where the image gradient of each pixel $\nabla I_{i}$ can be computed from a preliminarily denoised version of the noisy input, since most patch-based denoising methods either generate a basic estimation for better patch searching or perform iterative image denoising. $\alpha$ and $\beta$ are two empirically selected parameters.

To verify this observation, we select images with different noise levels and examine how gradients affect the optimal cluster numbers. Specifically, we select the optimal cluster number for a patch as the one that leads to the best denoising result according to the corresponding ground truth clean patch. We show the results in Figure 5 where the intensity value of each pixel in the cluster number maps (b), (c), and (d) encodes the optimal number of clusters for the patch centered at that pixel. This shows that the cluster number typically increases with the magnitude of the image gradient, especially at higher noise levels. We also show a cluster number map for $\sigma=100$ estimated by our clustering patch searching approach in Figure 5 (e). It shows that our optimization approach properly estimates the cluster numbers for patches that are close to the optimal ones.

3.1.1 Optimization Reduction

Minimization for Equation 1 can be solved by a modified Expectation-Maximization (EM) algorithm proposed by Boumam et al. [4]. However, directly solving this optimization for the cluster number $K$ and the clustering results simultaneously is time-consuming. We reduce this problem with two ideas. First, we observe that the number of the clusters is relatively small and therefore use brute-force search to find an optimal cluster number since the searching space of $K$ is small. This step will not affect the optimality. Second, we use a fast K-means++ [3] algorithm to solve the GMM clustering problem given $K$. Note, given a cluster number, the regularization term is a constant and therefore can be ignored.

3.2 Unreliable Pixel Detection and Update

For a noisy pixel in a local reference patch, we can retrieve a group of similar pixels from the corresponding similar patches. These similar pixels can be used to estimate the latent clean intensity. However, outliers with pixel intensity values far away from the center might exist and the final estimated intensity would be biased.

We hence use a simple but effective unreliable pixel estimation (UPE) algorithm to detect outliers and accordingly modify their intensities in the input. For a reference pixel $x_{r}$ and its $m$ similar pixels $\{x_{i}|_{i=1,\cdots,m}\}$ ordered in intensities, we first compute two dynamic thresholds at both the high and low end ($t_{l}=max(0,x_{M}-\gamma\sigma)$ and $t_{h}=min(255,x_{M}+\gamma\sigma)$), where $x_{M}$ is the median and $\sigma$ is the standard deviation of the $m$ pixels. $\gamma$ is an empirically selected constant parameter with default value 2 for BM3D/PLOW and 4 for LPCA. Pixels with intensities beyond these two thresholds are then discarded. Suppose $n_{l}$ pixels have intensities smaller than $t_{l}$ and $n_{h}$ pixels have intensities larger than $t_{h}$, we set $t=\max(n_{l},n_{h})$ and discard $t$ pixels at both ends. A truncated mean $\hat{y}$ is then estimated by averaging the remaining pixels.

For ones with many outliers, the small amount of remained pixels may lead to inaccurate estimations. In this case, we find that the threshold $t_{l}$ or $t_{h}$ is a good approximation of $\hat{y}$ and directly assign $t_{l}$ or $t_{h}$ according to the number of outlier pixels at both the high and low end. For pixels with only a few outliers, we simply keep its intensity unchanged. Since each reference pixel $x_{r}$ is retrieved from a patch and most denoising algorithms use overlapped patches, each pixel can have multiple estimations. We simply use their weighted mean as the final modified intensity $y$ in the modified noisy input image, where the weight is set to $t$ to give more credits to pixels with more outliers.

Figure 6 shows that this simple and conservative strategy significantly improves the quality of the noisy input image. In addition, it can be seen that the UPE modifies the flat regions more. This is because initial patch searching step is biased more in flat areas than textured areas with strong structures. To statistically verify the effectiveness of UPE, we randomly sample 10,000 similar pixel groups and derive 3 versions of them: the original groups (ORG), the modified groups after UPE (UPE), and the final groups after both UPE and clustering (ALL), respectively. We report the average intensity difference between them and their corresponding ground truth references in Figure 7. It can be seen that UPE makes similar patches statistically closer to the ground truth than the original ones and clustering further reduces the difference.

There are two basic steps in a patch-based denoising method: finding a set of similar patches and recovering the clean patch from this patch set. The modified noisy input image can help 1) find a better set of patches and 2) better recover the clean patch since the unreliable pixels are corrected, in addition to having better similar patches.

3.3 Complexity

Assume that each reference patch has $m$ $n$-dimensional similar patches in at most k clusters, the main computational cost of our algorithm is the unreliable pixel estimation and clustering. Since we use K-means++, the cost of the clustering is $O(mnk)$. The unreliable pixel estimation has $O(mn)$ operations. Suppose there are $l$ reference patches in the image, the total computational complexity is $O(lmnk)$. In our MATLAB implementation, given a 256$\times$256 input noisy image with standard deviation $\sigma=20$, the running time is about 10 seconds for our patch searching on BM3D, is about 10 seconds on on a desktop with Intel(R) Core(TM) i7-4770 CPU (3.40GHz). While the running time of our patch searching part is similar on PLOW and LPCA, the actual speed is slower as extra overloaded is added to incorporate our patch searching into the authors’ original code.

4 Experimental Results

4.1 Implementation Details

We apply our algorithm for similar patch searching to three representative patch-based denoising methods, including BM3D [14], PLOW [10] and LPCA [41]. For BM3D, we use an open-source implementation (C++) proposed by Marc [21]. For PLOW and LPCA, we utilize the source code from the author’s website. All these methods share a common two-stage framework in which a preliminary denoised image is generated in the first stage to improve the similar patch searching in the second stage. Because similar patches with better similarities can benefit more from our clustering-based patch searching, we mainly apply our method to the similar patches obtained in the second denoising stage. We modify both the similar patches’ intensities as well as the similar patch locations. The algorithms embedded with our method for better patch searching are denoted as BM3Dbst, PLOWbst and LPCAbst, respectively. In addition, since LPCA uses 250 similar patches for image denoising, it may suffer from an over-smoothing problem. We thus modify LPCA by adaptively using NNS to search for the same number of similar patches as used in our LPCAbst for each noisy reference patch. We use this modified version of LPCA as an additional baseline for comparison and denote it as LPCAbas.

We extend our modified denoising algorithms to denoise color images. Specifically, for PLOW and LPCA, we separately apply our boosted denoising algorithms on individual R,G,B channels, as proposed in the original algorithms. For BM3D, the noisy images are first transformed from RGB to YUV and the indices of similar patches are searched in the Y channel. The denoising is then separately performed on R,G,B channels using the same indices that have been obtained in the patch searching step. Thus, in BM3Dbst for color image denoising, we apply our unreliable pixel estimation on all R,G,B and Y channels while the clustering-based patch searching is only performed on the Y channel. Finally, the R,G,B channels are denoised separately using our modified similar patches, in which the indices are searched in the Y channel and the pixel intensities are retrieved from the modified R,G,B channels, respectively.

4.2 Parameter Settings

For similar patch group denoising, we use exactly the same parameter settings as used in the original denoising methods. Different parameter settings are selected for the three denoising methods because 1) various quality of intermediate results are generated during denoising and 2) different denoising methodologies are exploited.

Take the number of similar patch candidates $m$ as an example, denote $m_{org}$ as the number of similar patches used in the original denoising algorithms. For BM3Dbst and PLOWbst, as only a small amount of similar patch candidates are used in the original methods, we collect more initial similar patch candidates (100 and 30, respectively). While for LPCA, as 250 similar patches are used in the original method, suffering from an over-smoothing problem, we reduce $m$ to 150 in our boosted method. We choose a small number of patch candidates because 1) Nearest Neighbour Search already provides a reasonable set of similar patch candidates and 2) a large number of patch candidates are slow to process.

Parameters $\alpha$ and $\beta$ in Equation 4 are selected according to how the image gradient is recovered in the basically denoised estimation. For BM3D, we set $\alpha=2.5$ and $\beta=72$. We select larger $\alpha$ and $\beta$ values for PLOW (20,144) and LPCA (25,100) as their corresponding basic estimations are often over-smoothed, leading to biased gradient estimations with magnitudes smaller than the ground truth.

We select the maximal cluster number $K_{max}=4$ empirically. Specifically, we tested a large number of patches at a range of noise levels and found that for about 90% of the patches, the optimal cluster numbers are less than or equal to 4. The maximal optimal cluster number is 6. More importantly, the denoising quality difference between 4 and 6 is negligible. Since a small $K_{max}$ value leads to a fast speed, we choose $K_{max}=4$ in all our experiments.

4.3 Results on standard test images

We test our method on 8 widely used standard test images as shown in Figure 8. To synthesize noisy images, we add White Gaussian noise with zero mean and standard deviation $\sigma=20,40,60,80,100$. Noisy pixels that are corrupted beyond the range of [0,255] are truncated. We use the PSNR to quantitatively evaluate the performance of our boosted patch-based denoising algorithms. In Table 1 we report the average PSNR results of the original similar patch-based denoising algorithms and our boosted algorithms. Higher PSNR results for each patch-based denoising algorithm on each noise level are highlighted in bold.

The results show that our similar patch searching algorithm can effectively improve the performance of the three patch-based denoising methods. By embedding our framework for similar patch searching, BM3D achieves an average improvement of 0.05dB–0.98dB across different noise levels. PLOW and LPCA’s performance are improved by 0.11dB-0.97dB and 0.03dB–1.66dB, respectively. One can also see that while LPCAbas gains a little improvement over LPCA, our LPCAbst still significantly performs better. BM3Dbst performs superior among the three boosted denoising algorithms. In addition, it can be seen in Figure 9 that images with higher noise levels gain larger improvements than the ones with lower noise levels. There are two reasons. First, heavy noise can bring a larger bias in the similar patch searching process. Second, images with higher level of noise have more unreliable pixels. Thus, these images can benefit more from our proposed similar patch search approach.

In Figure 2 we compare the visual performance of BM3D, PLOW and LPCA with their improved versions. It can be seen that the improved algorithms that incorporated with our patch searching method better recover fine image details as well as better preserve color fidelity.

We also compare BM3Dbst, which performs superior among the three improved algorithms, with the recent state-of-the-art denoising algorithms, including EPLL [45], WNNM [18], PGPD [39] and PCLR [11] in Table 1. It can be seen that BM3Dbst generally outperforms all other methods on images with noise levels higher than $\sigma=60$. For images with $\sigma=20$ and $40$, BM3Dbst has comparable performance with other methods. The visual comparisons of these competing denoising methods on images with heavy noise are shown in Figure 12, 12 and 12. Our boosted methods significantly outperform the other methods by as much as 1.88dB, 1.99dB and 0.79dB, respectively. Fine image structures as well as the color fidelity are therefore better reconstructed by our boosted denoising methods.

To test the robustness of our method across different noise types, we apply the three boosted denoising algorithms to images corrupted by Poisson noise. To add Poisson noise to a clean image $I$, we use $N=\kappa\cdot$poissrnd$(I/\kappa)$ in MATLAB as proposed by Zhang et al. [42], where poissrnd$(x)$ generates a Poisson distributed random number with mean and variance of $x$. We set $\kappa=20,35,50,65$ and $80$ to add different levels of Poisson noise. We report the average denoising performance in Table 2. One can see that the three patch-based methods still benefit from our patch searching method on images with Poisson noise.

To evaluate the effect of unreliable pixel estimation (UPE), we leave UPE out and compare the corresponding PSNR improvement to that of our method with UPE in Figure 13. It shows that UPE contributes significantly to the final result, especially with high levels of noise, and clustering further boosts the denoising performance.

We also compare our BM3Dbst to the Patch Ordering (POD) [19] method that selects better sets of similar patches for image denoising via patch ordering. We compare these two methods on images with noise levels $\sigma=20,50$ and $75$, as the parameter settings for those noise levels in the Patch Ordering method have been optimally set in the authors’ code. We report the average PSNR results in Table 3. It can be seen that our method outperforms POD.

We test our similar patch searching algorithm using different clustering methods on BM3Dbst, including Gaussian Mixture Model [4] clustering and Landmark-based Spectral Clustering [12], and compare them with K-means++ in Table 4. The results show that all three clustering algorithms have comparable performance.

We report SSIM scores of our boosted BM3Dbst in Table 5, which shows our method improves BM3D consistently. Our boosted PLOWbst and LPCAbst have similar performance improvement. We skip their quantitative results due to the lack of space.

4.4 Results on the BSD dataset

We use the 100 test images from the Berkeley Segmentation Dataset [28] to generate 500 noisy images with 5 different noise levels and test our method on them. In Table 6 we compare our boosted denoising methods with the original patch-based denoising algorithms as well as the competing methods. One can see that the boosted algorithms robustly outperform the original ones. Statistically, among all the 500 noisy images, the improved denoising methods, including BM3Dbst, PLOWbst and LPCAbst, beat their corresponding original methods for 482, 397 and 499 times, respectively. In addition, comparing with other state-of-the-art denoising methods, BM3Dbst has comparable performance on images with $\sigma=20$ and performs better on higher noise levels. More visual examples of the boosted algorithms can be find in the supplementary material.

5 Conclusion

This paper presented an approach to similar patch searching for patch-based denoising algorithms. By combing an unreliable pixel estimation algorithm and a clustering-based patch searching with adaptively estimated cluster numbers, better similar patches can be obtained for image denoising. We showed that similar patches collected by our approach can capture the underlying image intensity fidelity and the image structures more adequately. Experimental results demonstrated that our approach can effectively improve the quality of searched similar patches and can consistently enable better denoising performance for several recent patch-based methods, such as BM3D, PLOW and LPCA. Since patch-based methods have attracted a significant amount of research effort and provide the state-of-the-art performance, our method can be incorporated into all the patch-based denoising methods.