-
Notifications
You must be signed in to change notification settings - Fork 0
/
edge_detectors_for_project.m
187 lines (150 loc) · 7.01 KB
/
edge_detectors_for_project.m
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
%Jon Dexter
%June 10, 2021
clear all
%roberts, %prewitts, %sobel, %canny, %log
f =figure();
f.WindowState = 'maximized';
myImagee=rgb2gray(imread('dog2.jpg')); %image read as grayscale
%subplot(3,3,[1,2,3]), imshow(myImagee), title('Original Image');
subplot(2,3,1), imshow(myImagee), title('Original Image');
myImage = double(myImagee); % convert from unit8 to double
%Roberts operator
%-------------------------------------------------------------------
filtered_image = zeros(size(myImage)); % Pre-allocate the filtered_image matrix with zeros
% Robert Operator Mask
Mx = [1 0; 0 -1];
My = [0 1; -1 0];
% Edge Detection Process
% When i = 1 and j = 1, then filtered_image pixel position will be filtered_image(1, 1)
% The mask is of 2x2, so we need to traverse % to % filtered_image(size(myImage, 1) - 1 %, size(myImage, 2) - 1)
for i = 1:size(myImage, 1) - 1
for j = 1:size(myImage, 2) - 1
% Gradient approximations
Gx = sum(sum(Mx.*myImage(i:i+1, j:j+1)));
Gy = sum(sum(My.*myImage(i:i+1, j:j+1)));
% Calculate magnitude of vector
filtered_image(i, j) = sqrt(Gx.^2 + Gy.^2);
end
end
filtered_image = uint8(filtered_image); % Displaying Filtered Image
% Define a threshold value
thresholdValue = 100; % varies between [0 255]
output_image = max(filtered_image, thresholdValue);
output_image(output_image == round(thresholdValue)) = 0;
%roberts =output_image;
tic
roberts = edge(myImage, 'roberts', []);
toc
time = toc;
fprintf("\n");
[MSE , PSNR_robs] = performance(myImage, roberts);
subplot(2,3,2), imshow(roberts), title('Roberts operator'), xlabel(sprintf('MSE: %02d\n PSNR: %f\nEt: %f secs', MSE , PSNR_robs, time));
%---------------------------------------------------------------------------------------------------------------------
%Prewitt operator
%---------------------------------------------------------------------------------------------------------------------
filtered_image = zeros(size(myImage)); % Pre-allocate the filtered_image matrix with zeros
% Prewitt Operator Mask
Mx = [-1 0 1; -1 0 1; -1 0 1];
My = [-1 -1 -1; 0 0 0; 1 1 1];
% Edge Detection Process
% When i = 1 and j = 1, then filtered_image pixel position will be filtered_image(2, 2)
% The mask is of 3x3, so we need to traverse % to filtered_image(size(myImage, 1) - 2
%, size(myImage, 2) - 2)
% Thus we are not considering the borders.
for i = 1:size(myImage, 1) - 2
for j = 1:size(myImage, 2) - 2
% Gradient approximations
Gx = sum(sum(Mx.*myImage(i:i+2, j:j+2)));
Gy = sum(sum(My.*myImage(i:i+2, j:j+2)));
% Calculate magnitude of vector
filtered_image(i+1, j+1) = sqrt(Gx.^2 + Gy.^2);
end
end
% Displaying Filtered Image
filtered_image = uint8(filtered_image);
% Define a threshold value
thresholdValue = 100; % varies between [0 255]
output_image = max(filtered_image, thresholdValue);
output_image(output_image == round(thresholdValue)) = 0;
%prewitt = output_image;
tic
prewitt = edge(myImage,'prewitt', []);
toc
time = toc;
fprintf("\n");
[MSE , PSNR_prewit] = performance(myImage, prewitt);
subplot(2,3,3), imshow(prewitt), title('Prewitt operator'), xlabel(sprintf('MSE: %02d\n PSNR: %f\nEt: %f secs', MSE , PSNR_prewit, time));
%---------------------------------------------------------------------------------------------------------------------
%sobel operator
%---------------------------------------------------------------------------------------------------------------------
filtered_image = zeros(size(myImage)); % Pre-allocate the filtered_image matrix with zeros
% Sobel Operator Mask
Mx = [-1 0 1; -2 0 2; -1 0 1];
My = [-1 -2 -1; 0 0 0; 1 2 1];
% Edge Detection Process
% When i = 1 and j = 1, then filtered_image pixel position will be filtered_image(2, 2)
% The mask is of 3x3, so we need to traverse to % filtered_image(size(myImage, 1) - 2 , size(myImage, 2) - 2)
% Thus we are not considering the borders.
for i = 1:size(myImage, 1) - 2
for j = 1:size(myImage, 2) - 2
% Gradient approximations
Gx = sum(sum(Mx.*myImage(i:i+2, j:j+2)));
Gy = sum(sum(My.*myImage(i:i+2, j:j+2)));
% Calculate magnitude of vector
filtered_image(i+1, j+1) = sqrt(Gx.^2 + Gy.^2);
end
end
filtered_image = uint8(filtered_image); % Displaying Filtered Image
% Define a threshold value
thresholdValue = 100; % varies between [0 255]
output_image = max(filtered_image, thresholdValue);
output_image(output_image == round(thresholdValue)) = 0;
%sobel = output_image;
tic
sobel = edge(myImage,'sobel', []);
toc
time = toc;
fprintf("\n");
[MSE , PSNR_sobel] = performance(myImage, sobel);
subplot(2,3,4), imshow(sobel), title('Sobel operator'), xlabel(sprintf('MSE: %02d\n PSNR: %f\nEt: %f secs', MSE , PSNR_sobel, time));
%---------------------------------------------------------------------------------------------------------------------
%canny operator
%-----------------------------------------------------------------------------------------------------------------------
tic
canny = edge(myImage,'canny',[]);
toc
time = toc;
fprintf("\n");
[MSE , PSNR_canny] = performance(myImage, canny);
subplot(2,3,5), imshow(canny, []), title('Canny edge operator'), xlabel(sprintf('MSE: %02d\n PSNR: %f\nEt: %f secs', MSE , PSNR_canny, time));
%-----------------------------------------------------------------------------------------------------------------------
%log operator
%----------------------------------------------------------------------------------------------------------------------
tic
log = edge(myImage,'log', []);
toc
time = toc;
fprintf("\n");
[MSE , PSNR_log] = performance(myImage, log);
subplot(2,3,6), imshow(log), title('LoG edge operator'), xlabel(sprintf('MSE: %02d\n PSNR: %f\nEt: %f secs', MSE , PSNR_log, time));
%----------------------------------------------------------------------------------------------------------------------
%DoG
%----------------------------------------------------------------------------------------------------------------------
G1= fspecial('gaussian',21,15);
G2 = fspecial('gaussian',21,20);
DoG = G1 - G2;
myImage_DoG = conv2(myImage,DoG,'same');
[MSE , PSNR_DoG] = performance(myImage, myImage_DoG);
%subplot(3,3,9), imshow(myImage_DoG,[]), title('DoG edge operator'), xlabel(sprintf('MSE: %02d and PSNR: %f', MSE , PSNR_DoG));
%----------------------------------------------------------------------------------------------------------------------
function [mse, psnr] = performance(myImage, edgeImage)
%function to calculate the performace measure, ie mse and psnr
[rows, columns] = size(myImage);
squaredErrorImage = (double(myImage) - double(edgeImage)) .^ 2;
% Sum the Squared Image and divide by the number of elements
% to get the Mean Squared Error. It will be a scalar (a single number).
mse = double(sum(sum(squaredErrorImage)) / (rows * columns));
% Calculate PSNR (Peak Signal to Noise Ratio) from the MSE according to the formula.
psnr = 10 * log10( 256^2 / mse);
%fprintf('The mean square error is %f\nThe psnr = %f', mse, psnr);
end