ABSTRACT
In this paper, we propose a novel
approach for performing high-quality edge-preserving 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
- LLSURE-Local Linear SURE-Based Filter
- Joint LLSURE Filter
- Edge-Preserving Decompositions Based on LLSURE
- Image Denoising
- 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;
}
System Requirement Specification:
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
No comments:
Post a Comment