1 of 6 LAB 5 IMAGE FILTERING ECE180 Introduction to.docx

1 of 6
LAB 5: IMAGE FILTERING
ECE180: Introduction to Signal Processing
OVERVIEW
You have recently learned about the convolution sum that
serves as the basis of the FIR filter difference equation. The
filter
coefficient sequence {��} – equivalent to the filter’s impulse
response ℎ[�] – may be viewed as a one-dimensional moving
window that slides over the input signal �[�] to compute the
output signal �[�] at each time step. Extending the moving
window concept to a 2-D array that slides over an image pixel
array provides a useful and popular way to filter an image.
In this lab project you will implement two types of moving-
window image filters, one based on convolution and the other
based on the median value of the pixel grayscale values spanned
by the window. You will also gain experience with the
built-in image convolution filter imfilter.
OUTLINE

3. Evaluate the median and convolution filters to reduce noise
while preserving edges
for smoothing, edge detection, and sharpening
5. Learn how to use imfilter to convolution-filter color images,
and study the various mechanisms offered by
imfilter to deal with boundary effects
PREPARATION – TO BE COMPLETED BEFORE LAB
Study these tutorial videos:
1. Nested “for” loops -- http://youtu.be/q2xfz8mOuSI?t=1m8s
(review this part)
2. Functions -- http://youtu.be/0zTmMIh6I8A (review as
needed)
Ensure that you have added the ECE180 DFS folders to your
MATLAB path, especially the “images” and “matlab”
subfolders.
Follow along with the tutorial video
http://youtu.be/MEqUd0dJNBA, if necessary.
LAB ACTIVITIES
1.1. Implement the following algorithm as the function med3x3:
TIP: First implement and debug the algorithm as a script and
then convert it to a function as a final step. Use any

of the smaller grayscale images from the ECE180 “images”
folder as you develop the function, or use the test
image X described in the Step 1.2.
(a) Create the function template and save it to an .m file with
the same name as the function,
(b) Accept a grayscale image x as the function input,
http://youtu.be/q2xfz8mOuSI?t=1m8s
http://youtu.be/0zTmMIh6I8A
http://youtu.be/MEqUd0dJNBA
2 of 6
(c) Copy x to the output image y and then initialize y(:) to zero;
this technique creates y as the same size and
data type as x,
(d) Determine the number of image rows and columns (see
size),
(e) Loop over all pixels in image x (subject to boundary limits):
pixel,
-D array to a 1-D array,
-D array values (see sort),

output pixel, and
(f) Return the median-filtered image y.
1.2. Enter load lab_5_verify to load the .mat file that contains
the test images X and Ymed3x3. Compare your
function’s output image with the expected output image:
isequal(med3x3(X), Ymed3x3)
A “1” result indicates that your function produces the correct
result at every pixel, otherwise you need to keep
debugging your function.
text.
2.1. Implement the following algorithm as the function
conv3x3:
(a) Accept a grayscale image x and the convolution kernel h (a
development purposes use h=ones(3)/3^2,
(b) Convert x to the “double” datatype (see double),
(c) Allocate space for the output image y with zero initial value,

(d) Determine the dimensions of the image x,
(e) Loop over all pixels in image x (subject to boundary limits):
pixel,
-D subarray by the kernel h,
-D array to a 1-D array ,
he 1-D array values to a single value and assign this to
the current output pixel (see sum),
(f) Convert y back to the “unsigned 8-bit integer” datatype (see
uint8), and
(g) Return the convolution-filtered image y.
2.2. The .mat file you loaded in Step 1.2 also contains the
output image Yconv3x3. Compare your function’s output
image with the expected output image:
isequal(conv3x3(X,ones(3)/3^2), Yconv3x3)
Your function works properly when you see “1” as a result,
otherwise you need to keep debugging your function.
text.

3 of 6
-window filters:
The two filters you developed can be used to remove, or at least
reduce, the amount of noise in an image. Ideally noise
removal will not blur image edges, i.e., the grayscale
discontinuities that help us to recognize features in the image.
3.1. Create a new script for this part, and then load and display
one of the test patterns developed by the Society of
Motion Picture and Television Engineers (SMPTE, pronounced
“simp-tee”):
tp=imread('smpte.png'); imshow(tp)
3.2. Create a copy of the test pattern that includes Gaussian
noise:
tpn=imnoise(tp,'gaussian',0,0.01); figure, imshow(tpn)
3.3. Apply your median filter to tpn to create tpnm. Display the
noisy image and filtered image side by side:
imshowpair(tpn,tpnm,'montage')
filter.
3.5. Create a convolution kernel array h to perform the average

h=ones(3)/3^2
3.6. Apply your averaging filter to tpn to create tpnc. Display
the noisy image and filtered image side by side as you
did earlier with imshowpair.
lay window for the averaging
filter.
filter and the averaging filter in terms of reducing
noise and preserving edges for Gaussian noise; when you
“compare and contrast” two processing techniques you
discuss what is similar and what is different about the two
methods. Use the “Zoom In” tool on the figure
windows to study the noise and edges in more detail.
3.9. Repeat Steps 3.1 through 3.9 using “salt and pepper noise,”
a disturbance that causes random isolated pixels to
be set either to full white or full black:
tpn=imnoise(tp,'salt & pepper',0.02);
filter.
convolution filter.
filter and the convolution filter in terms of reducing
noise and preserving edges for salt-and-pepper noise. Remember

to use the “Zoom In” tool to study the noise,
edges, and other features.
4 of 6
image processing. In this section you will study the effects
kernels.
4.1. Develop a script to load the “camera” image from a file,
define the desired kernel as a string constant (e.g.,
kernel='average'), select a kernel array with a switch statement,
and then display the original image and
the convolved image side by side; use conv3x3 as before. Use
the kernel name as the figure title, i.e,
title(kernel,'FontSize',16). The switch statement will select from
among the following kernels:
average
[

1 1 1
1 1 1
1 1 1
] ×
1
9
hedges
[
−1 0 1
−1 0 1
−1 0 1
]
vedges
[
−1 −1 −1
0 0 0
1 1 1
]
edges

[
−1 −1 −1
−1 8 −1
−1 −1 −1
]
Laplacian
[
0 −1 0
−1 4 −1
0 −1 0
]
sharpen
[
0 −1 0
−1 5 −1
0 −1 0
]
pass
[

0 0 0
0 1 0
0 0 0
]
Enter the kernel as a 3x3 matrix using line continuation, e.g.,
enter the Laplacian kernel like this:
h = [ 0 -1 0; ...
-1 4 -1; ...
0 -1 0];
4.2. For each kernel, screenclip your image input/output pair
and then write some comments about its effect on the
processed image:
– note that hedges is a type of edge detector, can
you determine the meaning of the “h”
in the name? Also, what happens to the constant-intensity areas
of the image?
– how does this compare to the hedges kernel,
and what might the “v” signify?
– compare this result to the hedges and vedges
kernels.

– compare to edges.
– this kernel can be considered as a combination
of two of the other kernels; which are
the two, and how are they combined? How might this explain
the visual appearance of the processed
image? Try the “Zoom In” tool in the area of an edge.
5 of 6
5. Learn how to use imfilter:
MATLAB includes the function imfilter that operates just like
your conv3x3 filter but with extended capabilities
for arbitrary window sizes, several options to deal with
boundary effects, and the ability to work with color images.
Note that imfilter can also work directly with the uint8 data
type.
5.1. Create a new script for this part. Develop a code fragment
to create the “pass-through” kernel of an arbitrary size
of NxN elements that are all zero except for a single “1” in the
center of the kernel. Assume that N will always be
chosen as an odd number.

code for N = 3, 5, and 7. (To save space, run the
command format compact before producing your output.)
5.2. Load the “parrots” image as variable x, display the image,
-through kernel h, and then apply
this kernel to the image:
imshow(imfilter(x,h))
Expect to see the original image; can you explain why?
of avoiding the boundary as you did with
conv3x3. You can adjust how imfilter deals with the boundary,
but begin with the 'full' option to cause
imfilter to show the original image and the values that it
assumes are outside the limits of the input image
based on the size of the kernel; the image you see is larger than
the original image:
imshow(imfilter(x,h,'full'))
Explain what you see; what numerical value is assumed? If in
doubt on the value, click the “Data Cursor” tool on
the figure and then click on the image.

the assumed values can sometimes cause
erager:
avg=ones(41)/41^2;
imshow(imfilter(x,avg,'full'))
and then try reverting back to the default output style which is
the same size as the input image:
imshow(imfilter(x,avg))
Explain what you see, recalling that this kernel computes the
average value of all the pixels in the 2-D moving
window.
the image as an infinitely repeating (periodic)
image:
imshow(imfilter(x,h,'full','circular'))
Now try the averaging kernel again where the output image is
the same size as the input:
imshow(imfilter(x,avg,'full','circular'))
What is your opinion of this choice for boundary handling, at
least for the “parrots” image? What would have to
be true about an image for 'circular' to be a good choice?

the previous step:
imshow(imfilter(x,h,'full','replicate'))
and then
imshow(imfilter(x,avg,'replicate'))
Explain how the 'replicate' option creates pixel values beyond
the limits of the original image. How do the
6 of 6
results compare to the 'circular' method? Do you think that
'replicate' gives better results at the
boundaries?
two ways as before:
imshow(imfilter(x,h,'full','symmetric'))
and then
imshow(imfilter(x,avg,'symmetric'))
Explain how the 'symmetric' option creates pixel values outside
the limits of the original image. Try the
averaging kernel again; how do the results compare to the
previous methods? Which method of the four available

methods do you think would be the best choice for most
images?
uses imfilter instead of conv3x3. Try all of
n the “parrot” image. Pick your favorite
result, screenclip your input/output image results, state
the kernel you used, and explain what appeals to you about this
result.
6. Wrap Up:
projects for the term! Please comment on your
comfort level with MATLAB. Does any aspect of MATLAB
programming remain particularly unclear or confusing? If
so, please elaborate.
“Lab 5 _ Firstname Lastname.docx” and then submit
it to Turnitin by the end of the lab period today.

1 of 6 LAB 5 IMAGE FILTERING ECE180 Introduction to.docx

Recommended

More Related Content

Similar to 1 of 6 LAB 5 IMAGE FILTERING ECE180 Introduction to.docx (20)

More from mercysuttle (20)

Recently uploaded (20)

1 of 6 LAB 5 IMAGE FILTERING ECE180 Introduction to.docx