LLSURE: LOCAL LINEAR SURE-BASED
EDGE-PRESERVING IMAGE FILTERING
ABSTRACT
In this paper, we propose a novel approach for performing high-quality edgepreserving image filtering. Based on a local linear model and using the principle of Stein’s
unbiased risk estimate as an estimator for the mean squared error from the noisy image only,
we derive a simple explicit image filter which can filter out noise while preserving edges and
fine-scale details. Moreover, this filter has a fast and exact linear-time algorithm whose
computational complexity is independent of the filtering kernel size; thus, it can be applied to
real time image processing tasks. The experimental results demonstrate the effectiveness of
the new filter for various computer vision applications, including noise reduction, detail
smoothing and enhancement, high dynamic range compression, and flash/noflash denoising.
Existing System
In this Existing system, a variety of areas of computer vision and image processing.
However the direct implementation of bilateral filter is known to be slow. Although several
techniques are proposed to speed up the evaluation of the bilateral filter, its fast
implementation is still a challenging problem. And it has recently been noticed that bilateral
filter may have the gradient reversal artifacts in detail decomposition and high dynamic range
(HDR) compression.
Disadvantage
LTI filtering is very simple and is used extensively in early vision processing, it also
has some disadvantages. LTI filtering not only smooths the noise but also blurs important
structures along with noise, and outliers exert large influence on filtered output.
Proposed System
In Proposed System, to remove noise while preserving fine details and geometrical
structures in the original image. It is well known that the denoising performance of an
algorithm is often measured in terms of peak signal-to-noise ratio (PSNR). A higher PSNR
would normally indicate that the reconstruction is of higher quality. To maximize the PSNR,
an alternative approach is to minimize the mean square error (MSE) which can be estimated
accurately by Stein’s unbiased risk estimate (SURE) from the noisy image only.
MODULES
1. LLSURE-Local Linear SURE-Based Filter
2. Joint LLSURE Filter
3. Edge-Preserving Decompositions Based on LLSURE
4. Image Denoising
5. Smoothing and Enhancement
MODULES DESCRIPTION
1. LLSURE-Local Linear SURE-Based Filter
In this module, Firstly, in a local neighbourhood around every position, we assume
that the filtered output image patch is a very simple affine transform of input image patch in
the same position. Secondly, for every local neighbourhood, we determine the optimal
transform coefficients by minimizing the MSE estimate (SURE). Finally, all filtered output
image patches are averaged together to obtain the final filtered result.
2. Joint LLSURE Filter
In this module, here, we extend the LLSURE filter to joint LLSURE filter. In order to
smooth the input signal while relying on the guidance signal to locate the edges to preserve,
we rewrite are filter input image patch and guidance image patch respectively corresponding
to window.
3. Edge-Preserving Decompositions Based on LLSURE
In this module, Multi-scale edge-preserving decomposition is often required in many
applications of computational photography. The decomposition consists of a coarse piecewise
smoothed version of the image, along with a sequence of difference images capturing detail
at progressively finer scales
4. Image Denoising
In this module, Image noise reduction without structure degradation is perhaps the
most important task in low-level image processing. In this experiment, the proposed
algorithm is evaluated and compared with many other existing techniques, including fast
bilateral filter (FBF), guided image filter (GIF) and SURE-LET method.
5. Smoothing and Enhancement
In this module, Detail smoothing and enhancement are basic and common image
processing operations, available in most image editing software. Here we show that these
operations can be implemented in a simple and efficient way using our LLSURE method.
DONOHO’S SURESHRINK ALGORITHM
In image denoising, the aim is to suppress noise as much as possible while preserving
image features. The multire solution analysis performed by the wavelet transform is a
powerful tool used to achieve this goal. Indeed, in the orthonormal wavelet domain, most
image information is contained in the largest wavelet coefficients, while the noise is
uniformly spread out across all coefficients. Moreover, Gaussian white noise remains white
and Gaussian after orthogonal transformation. A good denoising approach thus consists in
setting the smallest coefficients to zero and shrinking the remaining ones above a certain
threshold. Donoho and Johnstone have proposed a method to find the threshold that
minimizes the estimate of the mean squared error.
namespace CSharpFilters
{
class Canny
{
private void GenerateGaussianKernel(int N, float S, out int Weight)
{
float Sigma = S;
float pi;
pi = (float)Math.PI;
int i, j;
int SizeofKernel = N;
float[,] Kernel = new float[N, N];
GaussianKernel = new int[N, N];
float[,] OP = new float[N, N];
float D1, D2;
D1 = 1 / (2 * pi * Sigma * Sigma);
D2 = 2 * Sigma * Sigma;
float min = 1000;
for (i = -SizeofKernel / 2; i <= SizeofKernel / 2; i++)
{
for (j = -SizeofKernel / 2; j <= SizeofKernel / 2; j++)
{
Kernel[SizeofKernel / 2 + i, SizeofKernel / 2 + j] = ((1 / D1) * (float)Math.Exp(-(i * i + j * j) /
D2));
if (Kernel[SizeofKernel / 2 + i, SizeofKernel / 2 + j] < min)
min = Kernel[SizeofKernel / 2 + i, SizeofKernel / 2 + j];
}
}
int mult = (int)(1 / min);
int sum = 0;
if ((min > 0) && (min < 1))
{
for (i = -SizeofKernel / 2; i <= SizeofKernel / 2; i++)
{
for (j = -SizeofKernel / 2; j <= SizeofKernel / 2; j++)
{
Kernel[SizeofKernel / 2 + i, SizeofKernel / 2 + j] = (float)Math.Round(Kernel[SizeofKernel / 2 +
i, SizeofKernel / 2 + j] * mult, 0);
GaussianKernel[SizeofKernel / 2 + i, SizeofKernel / 2 + j] = (int)Kernel[SizeofKernel / 2 + i,
SizeofKernel / 2 + j];
sum = sum + GaussianKernel[SizeofKernel / 2 + i, SizeofKernel / 2 + j];
}
}
}
else
{
sum = 0;
for (i = -SizeofKernel / 2; i <= SizeofKernel / 2; i++)
{
for (j = -SizeofKernel / 2; j <= SizeofKernel / 2; j++)
{
Kernel[SizeofKernel / 2 + i, SizeofKernel / 2 + j] = (float)Math.Round(Kernel[SizeofKernel / 2 +
i, SizeofKernel / 2 + j], 0);
GaussianKernel[SizeofKernel / 2 + i, SizeofKernel / 2 + j] = (int)Kernel[SizeofKernel / 2 + i,
SizeofKernel / 2 + j];
sum = sum + GaussianKernel[SizeofKernel / 2 + i, SizeofKernel / 2 + j];
}
}
}
//Normalizing kernel Weight
Weight = sum;
return;
}
HARDWARE REQUIREMENTS

System
:
Pentium IV 2.4 GHz.

Hard Disk
:
80 GB.

Monitor
:
15 VGA Colour.

Mouse
:
Logitech.

Ram
:
512 MB.
SOFTWARE REQUIREMENTS

Operating system
:
Windows 8 (32-Bit)

Front End
:
Visual Studio 2008

Coding Language
:
C#.NET

Database
:
SQL Server 2008