1. Study and implement several edge detection methods including: Roberts, Sobel, Prewitt, Laplacian of Gaussian (LoG), and Canny.
2. Inspect the effects of different types noise on images.
3. Study how different types of noise affect the edge detection ability of the previously mentioned edge detection methods.
4. Become familiar with Matlab programming and the Image Processing Toolbox.

project2.m contains six parts.

1. Edge detection on original image.
2. Creating image noise on original image.
3. Filtering noisy images generated in part 2 and then running edge detection on those images.
 

Executing project2.m from Matlab

At the command prompt enter:

>>project2

*Note: imdetectedges.m is a user created library and does not need to be executed directly for this experiment.

*Note: Images will be labeled by figure. The images in this experiment are meant to be compared to each other and not directly referenced.

Original Image (pepper.gif)

Relative thresholding was used for all the edge detection algorithms.

Part 1
In this section we ran edge detection operators on the original image.

Above: Roberts Cross Operator

Above: Sobel

Above: Prewitt

Above: LoG (Laplacian of Gaussian)

Above: Canny

Part 2
Noise was added to the original image. Salt and Pepper noise was added to 10% of the pixels. Gaussian noise was added with mean = 0 and standard deviation = 5.

Salt and Pepper Noise	Gaussian Noise	Uniform Noise

Part 3
The noisy images were filtered using a variety of techniques. Then, the edge detection methods of Part 1 were run on them. There results are below. Results are color coded. (Salt and Pepper, Gaussian, Uniform)

Salt and Pepper Noise with 5x5 Gaussian Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Salt and Pepper Noise with 3x3 Mean Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Salt and Pepper Noise with 5x5 Mean Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Salt and Pepper Noise with 5x5 Median Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Salt and Pepper Noise with 3x3 Median Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Gaussian Noise with 5x5 Gaussian Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Gaussian Noise with 3x3 Mean Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Gaussian Noise with 5x5 Mean Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Gaussian Noise with 3x3 Median Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Gaussian Noise with 5x5 Median Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Uniform Noise with 5x5 Gaussian Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Uniform Noise with 3x3 Mean Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Uniform Noise with 5x5 Mean Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Uniform Noise with 3x3 Median Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Uniform Noise with 5x5 Median Filter Applied
Sobel	Canny
Roberts	LoG
Prewitt

Summary
All results were as expected in the experiment.

Edge detection is a powerful tool to separate features and objects from the background in an image.

In the real world, images are usually noisy. This is due to light fluctuations, camera lens, etc. We often model noise as salt and pepper, Gaussian, or impulse noise. These 3 models best represent most real world noise.

Filtering is a means of removing noise. However, filters can have some undesired affects and can hinder edge detection.

1.

In general with salt and pepper noise and uniform noise, the average and Gaussian filters spread some of the noise in these type of images. Median filters seemed to work the best at removing salt and pepper noise and some of the uniform noise. The larger kernels for median filters appear to yield better results. They are used over a larger area, hence better results. The smaller kernels for mean filters are betters as they don't smear the noise as much. The Gaussian filter just seemed to spread the noise around like the mean filters.

In general with salt and pepper noise, the average and Gaussian filters worked best at removing the noise. The larger kernels for the mean filters worked better. The median filters work somewhat but not as good as the mean filters.

2.

Canny appears to preserve thin edge better than the other edge detectors even with different types of noise models introduced into the image.

3.

Canny works the best in most situations. Prewitt and Sobel are close behind but don't get the detail that Canny has. Roberts is great for simple images with easy to spot objects. LoG was the worst. It yielded results that were not as useful as what the other methods had detected.

Source Code

project2.m source code.

imdetectedges.m source code.

%-------------------------------------------------------------------------------
% Project 2
% Group 8
% Isaac Gerg (idg101)
% CSE 486
%-------------------------------------------------------------------------------

clc;
%colormap('default');

%-------------------------------------------------------------------------------
% Part 1 - Edge Detection
imgPepper = imread('pepper.gif', 'gif');

% Note: the imdetectedges function uses the magnitude approximation of |G| = |G-x| + |G_y|
% Roberts
imwrite(imdetectedges(imgPepper, 'roberts', 0.1119), 'RobertsEdgeDetection.jpg', 'jpg');

% Sobel
imwrite(imdetectedges(imgPepper, 'sobel', 0.1429), 'SobelEdgeDetection.jpg', 'jpg');

% Prewitt
imwrite(imdetectedges(imgPepper, 'prewitt', 0.1111), 'PrewittEdgeDetection.jpg', 'jpg');

% LoG
imwrite(imdetectedges(imgPepper, 'log', 0.1), 'LogEdgeDetection.jpg', 'jpg');

% Canny
imwrite(imdetectedges(imgPepper, 'canny', 0), 'CannyEdgeDetection.jpg', 'jpg');

%-------------------------------------------------------------------------------
% Part 2 - Noisy Images

% Salt and Pepper
imgSaltAndPepperNoise = imnoise(imgPepper, 'salt & pepper', 0.1);
imwrite(imgSaltAndPepperNoise, 'SaltAndPepperNoise.jpg', 'jpg');

% Gaussian
imgGaussianNoise = imnoise(imgPepper, 'gaussian', 0, 0.098);
%  25/255 = 0.098
imwrite(imgGaussianNoise, 'GaussianNoise.jpg', 'jpg');

% Uniform noise
imgUniformNoise = imgPepper;
for X = 1:256,
for Y = 1:256,
intOffset = round(30*rand(1) - 15);
% Convert the imgPepper Image to double here in order to use + operator.
imgUniformNoise(X,Y) = double(imgPepper(X,Y)) + intOffset;
end
end
imwrite(imgUniformNoise, 'UniformNoise.jpg', 'jpg');

%-------------------------------------------------------------------------------
% Part 3 - Image Filtering
iMeanFilter3_3 = [(1/9) (1/9) (1/9);
(1/9) (1/9) (1/9);
(1/9) (1/9) (1/9)];
iMeanFilter5_5 = [(1/25) (1/25) (1/25);
(1/25) (1/25) (1/25);
(1/25) (1/25) (1/25)];
iGaussianFilter5_5 = [1 4 7 4 1;
4 16 28 16 4;
7 28 49 28 7;
4 16 28 16 4;
1 4 7 4 1];

% Edge Detection with Salt and Pepper Noise
imgMean3_3 = conv2(imgSaltAndPepperNoise, iMeanFilter3_3);
imgMean5_5 = conv2(imgSaltAndPepperNoise, iMeanFilter5_5);
imgGaussian5_5 = conv2(imgSaltAndPepperNoise, iGaussianFilter5_5);
imgMedian3_3 = medfilt2(imgSaltAndPepperNoise, [3 3]);
imgMedian5_5 = medfilt2(imgSaltAndPepperNoise, [5 5]);

imwrite(imdetectedges(imgMean3_3, 'prewitt', 0.1111), 'S_P_Mean3_3_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'prewitt', 0.1111), 'S_P_Mean5_5_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'prewitt', 0.1111), 'S_P_Gaussian5_5_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'prewitt', 0.1111), 'S_P_Median3_3_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'prewitt', 0.1111), 'S_P_Median5_5_WithPrewitt.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Roberts', 0.1119), 'S_P_Mean3_3_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Roberts', 0.1119), 'S_P_Mean5_5_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Roberts', 0.1119), 'S_P_Gaussian5_5_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Roberts', 0.1119), 'S_P_Median3_3_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Roberts', 0.1119), 'S_P_Median5_5_WithRoberts.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Sobel', 0.1429), 'S_P_Mean3_3_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Sobel', 0.1429), 'S_P_Mean5_5_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Sobel', 0.1429), 'S_P_Gaussian5_5_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Sobel', 0.1429), 'S_P_Median3_3_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Sobel', 0.1429), 'S_P_Median5_5_WithSobel.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Log', 0.1), 'S_P_Mean3_3_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Log', 0.1), 'S_P_Mean5_5_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Log', 0.1), 'S_P_Gaussian5_5_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Log', 0.1), 'S_P_Median3_3_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Log', 0.1), 'S_P_Median5_5_WithLog.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Canny', 0), 'S_P_Mean3_3_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Canny', 0), 'S_P_Mean5_5_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Canny', 0), 'S_P_Gaussian5_5_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Canny', 0), 'S_P_Median3_3_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Canny', 0), 'S_P_Median5_5_WithCanny.jpg', 'jpg');

% Edge Detection with Gaussian Noise
imgMean3_3 = conv2(imgGaussianNoise, iMeanFilter3_3);
imgMean5_5 = conv2(imgGaussianNoise, iMeanFilter5_5);
imgGaussian5_5 = conv2(imgGaussianNoise, iGaussianFilter5_5);
imgMedian3_3 = medfilt2(imgGaussianNoise, [3 3]);
imgMedian5_5 = medfilt2(imgGaussianNoise, [5 5]);

imwrite(imdetectedges(imgMean3_3, 'prewitt', 0.1111), 'Gaussian_Mean3_3_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'prewitt', 0.1111), 'Gaussian_Mean5_5_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'prewitt', 0.1111), 'Gaussian_Gaussian5_5_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'prewitt', 0.1111), 'Gaussian_Median3_3_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'prewitt', 0.1111), 'Gaussian_Median5_5_WithPrewitt.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Roberts', 0.1119), 'Gaussian_Mean3_3_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Roberts', 0.1119), 'Gaussian_Mean5_5_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Roberts', 0.1119), 'Gaussian_Gaussian5_5_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Roberts', 0.1119), 'Gaussian_Median3_3_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Roberts', 0.1119), 'Gaussian_Median5_5_WithRoberts.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Sobel', 0.1429), 'Gaussian_Mean3_3_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Sobel', 0.1429), 'Gaussian_Mean5_5_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Sobel', 0.1429), 'Gaussian_Gaussian5_5_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Sobel', 0.1429), 'Gaussian_Median3_3_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Sobel', 0.1429), 'Gaussian_Median5_5_WithSobel.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Log', 0.1), 'Gaussian_Mean3_3_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Log', 0.1), 'Gaussian_Mean5_5_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Log', 0.1), 'Gaussian_Gaussian5_5_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Log', 0.1), 'Gaussian_Median3_3_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Log', 0.1), 'Gaussian_Median5_5_WithLog.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Canny', 0), 'Gaussian_Mean3_3_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Canny', 0), 'Gaussian_Mean5_5_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Canny', 0), 'Gaussian_Gaussian5_5_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Canny', 0), 'Gaussian_Median3_3_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Canny', 0), 'Gaussian_Median5_5_WithCanny.jpg', 'jpg');

% Edge Detection with Uniform Noise
imgMean3_3 = conv2(imgUniformNoise, iMeanFilter3_3);
imgMean5_5 = conv2(imgUniformNoise, iMeanFilter5_5);
imgGaussian5_5 = conv2(imgUniformNoise, iGaussianFilter5_5);
imgMedian3_3 = medfilt2(imgUniformNoise, [3 3]);
imgMedian5_5 = medfilt2(imgUniformNoise, [5 5]);

imwrite(imdetectedges(imgMean3_3, 'prewitt', 0.1111), 'Uniform_Mean3_3_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'prewitt', 0.1111), 'Uniform_Mean5_5_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'prewitt', 0.1111), 'Uniform_Gaussian5_5_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'prewitt', 0.1111), 'Uniform_Median3_3_WithPrewitt.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'prewitt', 0.1111), 'Uniform_Median5_5_WithPrewitt.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Roberts', 0.1119), 'Uniform_Mean3_3_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Roberts', 0.1119), 'Uniform_Mean5_5_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Roberts', 0.1119), 'Uniform_Gaussian5_5_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Roberts', 0.1119), 'Uniform_Median3_3_WithRoberts.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Roberts', 0.1119), 'Uniform_Median5_5_WithRoberts.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Sobel', 0.1429), 'Uniform_Mean3_3_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Sobel', 0.1429), 'Uniform_Mean5_5_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Sobel', 0.1429), 'Uniform_Gaussian5_5_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Sobel', 0.1429), 'Uniform_Median3_3_WithSobel.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Sobel', 0.1429), 'Uniform_Median5_5_WithSobel.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Log', 0.1), 'Uniform_Mean3_3_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Log', 0.1), 'Uniform_Mean5_5_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Log', 0.1), 'Uniform_Gaussian5_5_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Log', 0.1), 'Uniform_Median3_3_WithLog.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Log', 0.1), 'Uniform_Median5_5_WithLog.jpg', 'jpg');

imwrite(imdetectedges(imgMean3_3, 'Canny', 0), 'Uniform_Mean3_3_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgMean5_5, 'Canny', 0), 'Uniform_Mean5_5_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgGaussian5_5, 'Canny', 0), 'Uniform_Gaussian5_5_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgMedian3_3, 'Canny', 0), 'Uniform_Median3_3_WithCanny.jpg', 'jpg');
imwrite(imdetectedges(imgMedian5_5, 'Canny', 0), 'Uniform_Median5_5_WithCanny.jpg', 'jpg');

%-------------------------------------------------------------------------------
% Author: Isaac Gerg, isaacgerg@psu.edu
% Date: October 2003
%
%
% IMDETECTEDGES ( Image, Method, Threshold )
%
%
% Image Grayscale image on which to perform edge detection.
%
% Method Method of edge detection.
% Methods available are:
% 'prewitt'
% 'roberts'
% 'sobel'
% 'log' - Laplacian of Gausian
% 'canny'
%
% Threshold Threshold value for edge creation. Relative threshold value.
% Thresholding is done at maxValue(Image)*Threshold.
%
% This function approximates the magnitude of the gradient as:
% |G| = |G_x| + |G_y|
%
%
%-------------------------------------------------------------------------------

function imgProcessedImage = imdetectedges(imgImage, strMethod, iThreshold)

%-------------------------------------------------------------------------------
% Validate input parameters.
if iThreshold < 0
error('Illeagal threshold value specified');
return
end

% Create masks.
iRobertsX = [1 0;
0 -1];
iRobertsY = [0 -1;
1 0];
iSobelX = [-1 0 1;
-2 0 2;
-1 0 1];
iSobelY = [1 2 1;
0 0 0;
-1 -2 -1];
iPrewittX = [ -1 0 1;
-1 0 1;
-1 0 1];
iPrewittY = [ 1 1 1;
0 0 0;
-1 -1 -1];
iLog = [ 1 1 1;
1 -8 1;
1 1 1];
% Canny edge detection will be implemented via Matlab function.

switch lower(strMethod)
case 'roberts'
imgX = conv2(imgImage, iRobertsX);
imgY = conv2(imgImage, iRobertsY);
imgMagnitude = abs(imgX) + abs(imgY);
iThreshold = max(max(imgMagnitude))*iThreshold;
iSize = size(imgImage);
for X = 1:iSize(1),
for Y = 1:iSize(2),
if imgMagnitude(X,Y) >= iThreshold;
imgMagnitude(X,Y) = 255;
else
imgMagnitude(X,Y) = 0;
end
end
end
disp('Roberts edge detection.');
imgProcessedImage = imgMagnitude;
case 'sobel'
imgX = conv2(imgImage, iSobelX);
imgY = conv2(imgImage, iSobelY);
imgMagnitude = abs(imgX) + abs(imgY);
iThreshold = max(max(imgMagnitude))*iThreshold;
iSize = size(imgImage);
for X = 1:iSize(1),
for Y = 1:iSize(2),
if imgMagnitude(X,Y) >= iThreshold;
imgMagnitude(X,Y) = 255;
else
imgMagnitude(X,Y) = 0;
end
end
end
disp('Sobel edge detection.');
imgProcessedImage = imgMagnitude;
case 'prewitt'
imgX = conv2(imgImage, iPrewittX);
imgY = conv2(imgImage, iPrewittY);
imgMagnitude = abs(imgX) + abs(imgY);
iThreshold = max(max(imgMagnitude))*iThreshold;
iSize = size(imgImage);
for X = 1:iSize(1),
for Y = 1:iSize(2),
if imgMagnitude(X,Y) >= iThreshold;
imgMagnitude(X,Y) = 255;
else
imgMagnitude(X,Y) = 0;
end
end
end
disp('Prewitt edge detection.');
imgProcessedImage = imgMagnitude;
case 'log'
imgImage = conv2(imgImage, iLog);
imgMagnitude = abs(imgImage);
iThreshold = max(max(imgMagnitude))*iThreshold;
iSize = size(imgImage);
for X = 1:iSize(1),
for Y = 1:iSize(2),
if imgMagnitude(X,Y) >= iThreshold;
imgMagnitude(X,Y) = 255;
else
imgMagnitude(X,Y) = 0;
end
end
end
disp('LoG edge detection.');
imgProcessedImage = imgMagnitude;
case 'canny'
disp('Canny edge detection.');
imgProcessedImage = edge(imgImage, 'canny');
otherwise
disp('Unknown edge detection method!');
imgProcessedImage = imgImage;
end
%-------------------------------------------------------------------------------

Time Management
Isaac spent six hours working on this project. Adam spent two hours working on this project. Jamie spent zero hours working on this project.